diff --git a/common-parent/common-all/pom.xml b/common-parent/common-all/pom.xml index aa83a27ce9..5c8125e93a 100644 --- a/common-parent/common-all/pom.xml +++ b/common-parent/common-all/pom.xml @@ -42,7 +42,7 @@ 1.0.1 1.0.1 1.0.3 - 1.0.3 + 1.0.4-SNAPSHOT 1.0.4 2.4.6-SNAPSHOT 1.0.2 diff --git a/common-parent/tuple/pom.xml b/common-parent/tuple/pom.xml index ffebb3e416..6b007c1fa5 100644 --- a/common-parent/tuple/pom.xml +++ b/common-parent/tuple/pom.xml @@ -26,16 +26,16 @@ com.speedment.common common-parent - 1.0.4 + 3.0.9-SNAPSHOT tuple - 1.0.3 + 1.0.4-SNAPSHOT bundle Speedment - Common - Tuple - A collection of Tuple classes that represent sets of a fixed length + A collection of Immutable Tuple classes that represent sets of a fixed length where every element has a specific type. https://github.com/speedment/speedment/wiki/Tuple diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/BasicTuple.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/BasicTuple.java index 9fd69f32bf..494195d6f9 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/BasicTuple.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/BasicTuple.java @@ -25,14 +25,13 @@ */ public interface BasicTuple { - /** - * Returns the length of the Tuple. For example, a Tuple2 has a length of 2 - * whereas a Tuple3 has a length of 3. + * Returns the degree of the Tuple. For example, a Tuple2 has a degree of 2 + * whereas a Tuple3 has a degree of 3. * - * @return the length of the Tuple + * @return the degree of the Tuple */ - int length(); + int degree(); /** * Gets the tuple element at the given index. For example, get(0) will @@ -46,10 +45,10 @@ public interface BasicTuple { R get(int index); /** - * Returns a {@link Stream} of all non-null values for this Tuple of the - * given class. I.e. all non-null members of a Tuple that can be cast to the - * given class are included in the Stream. If sequential, the Stream will - * start with the 0:th tuple and progress upwards. + * Returns a {@link Stream} of all values for this Tuple of the given class. + * I.e. all non-null members of a Tuple that can be cast to the given class + * are included in the Stream. If sequential, the Stream will start with the + * 0:th tuple and progress upwards. * * @param The type of stream * @param clazz The class of the type of the stream diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple.java index 68fd3e3013..4d3a65cb99 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple.java @@ -35,13 +35,14 @@ public interface Tuple extends BasicTuple { * @return a {@link Stream} of all values for this Tuple */ Stream stream(); - + @Override default Stream streamOf(Class clazz) { return stream() - .filter(s -> s != null) .filter(clazz::isInstance) .map(clazz::cast); } + // T map(Function mapper); + } diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple3OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple3OfNullables.java deleted file mode 100644 index 3aa9baaf36..0000000000 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple3OfNullables.java +++ /dev/null @@ -1,36 +0,0 @@ -/** - * - * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * - * Licensed under the Apache License, Version 2.0 (the "License"); You may not - * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations under - * the License. - */ -package com.speedment.common.tuple; - -import java.util.Optional; - -/** - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument - * @param Type of 2:nd argument - */ -public interface Tuple3OfNullables extends TupleOfNullables { - - Optional get0(); - - Optional get1(); - - Optional get2(); - -} diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple4OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple4OfNullables.java deleted file mode 100644 index 475f1b920f..0000000000 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple4OfNullables.java +++ /dev/null @@ -1,39 +0,0 @@ -/** - * - * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * - * Licensed under the Apache License, Version 2.0 (the "License"); You may not - * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations under - * the License. - */ -package com.speedment.common.tuple; - -import java.util.Optional; - -/** - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument - * @param Type of 2:nd argument - * @param Type of 3:rd argument - */ -public interface Tuple4OfNullables extends TupleOfNullables { - - Optional get0(); - - Optional get1(); - - Optional get2(); - - Optional get3(); - -} diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple5OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple5OfNullables.java deleted file mode 100644 index d80697736d..0000000000 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple5OfNullables.java +++ /dev/null @@ -1,42 +0,0 @@ -/** - * - * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * - * Licensed under the Apache License, Version 2.0 (the "License"); You may not - * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations under - * the License. - */ -package com.speedment.common.tuple; - -import java.util.Optional; - -/** - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument - * @param Type of 2:nd argument - * @param Type of 3:rd argument - * @param Type of 4:th argument - */ -public interface Tuple5OfNullables extends TupleOfNullables { - - Optional get0(); - - Optional get1(); - - Optional get2(); - - Optional get3(); - - Optional get4(); - -} diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple6OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple6OfNullables.java deleted file mode 100644 index 1e48e8a6c4..0000000000 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple6OfNullables.java +++ /dev/null @@ -1,45 +0,0 @@ -/** - * - * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * - * Licensed under the Apache License, Version 2.0 (the "License"); You may not - * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations under - * the License. - */ -package com.speedment.common.tuple; - -import java.util.Optional; - -/** - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument - * @param Type of 2:nd argument - * @param Type of 3:rd argument - * @param Type of 4:th argument - * @param Type of 5:th argument - */ -public interface Tuple6OfNullables extends TupleOfNullables { - - Optional get0(); - - Optional get1(); - - Optional get2(); - - Optional get3(); - - Optional get4(); - - Optional get5(); - -} diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/TupleBuilder.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/TupleBuilder.java index c0a4d8c5ce..61476f30ab 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/TupleBuilder.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/TupleBuilder.java @@ -1,13 +1,13 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the @@ -16,91 +16,543 @@ */ package com.speedment.common.tuple; +import com.speedment.common.tuple.nonnullable.Tuple0; +import com.speedment.common.tuple.nonnullable.Tuple10; +import com.speedment.common.tuple.nonnullable.Tuple11; +import com.speedment.common.tuple.nonnullable.Tuple12; +import com.speedment.common.tuple.nonnullable.Tuple13; +import com.speedment.common.tuple.nonnullable.Tuple14; +import com.speedment.common.tuple.nonnullable.Tuple15; +import com.speedment.common.tuple.nonnullable.Tuple16; +import com.speedment.common.tuple.nonnullable.Tuple17; +import com.speedment.common.tuple.nonnullable.Tuple18; +import com.speedment.common.tuple.nonnullable.Tuple19; +import com.speedment.common.tuple.nonnullable.Tuple1; +import com.speedment.common.tuple.nonnullable.Tuple20; +import com.speedment.common.tuple.nonnullable.Tuple21; +import com.speedment.common.tuple.nonnullable.Tuple22; +import com.speedment.common.tuple.nonnullable.Tuple23; +import com.speedment.common.tuple.nonnullable.Tuple2; +import com.speedment.common.tuple.nonnullable.Tuple3; +import com.speedment.common.tuple.nonnullable.Tuple4; +import com.speedment.common.tuple.nonnullable.Tuple5; +import com.speedment.common.tuple.nonnullable.Tuple6; +import com.speedment.common.tuple.nonnullable.Tuple7; +import com.speedment.common.tuple.nonnullable.Tuple8; +import com.speedment.common.tuple.nonnullable.Tuple9; + /** - * + * This class is a Builder that can be used to build type safe Tuple of degree + * up to 23 that can hold non-null + * values. + * * @author Per Minborg */ public class TupleBuilder { - - private Tuple current = Tuples.of(); - + + private Tuple current; + private TupleBuilder() { + this.current = Tuples.of(); } - - public static Build0 builder() { - return new TupleBuilder().new Build0(); + + static Builder0 builder() { + return new TupleBuilder().new Builder0(); } - - public class Build0 extends BaseBuilder { - - public Build1 add(T0 e0) { - current = Tuples.of(e0); - return new Build1<>(); + + public class Builder0 extends BaseBuilder { + + public Builder1 add(T0 e0) { + current = Tuples.of( + e0 + ); + return new Builder1<>(); } - } - - public class Build1 extends BaseBuilder> { - - public Build2 add(T1 e1) { - current = Tuples.of(current.get(0), e1); - return new Build2<>(); + + public class Builder1 extends BaseBuilder> { + + public Builder2 add(T1 e1) { + current = Tuples.of( + current.get(0), + e1 + ); + return new Builder2<>(); } - } - - public class Build2 extends BaseBuilder> { - - public Build3 add(T2 e2) { - current = Tuples.of(current.get(0), current.get(1), e2); - return new Build3<>(); + + public class Builder2 extends BaseBuilder> { + + public Builder3 add(T2 e2) { + current = Tuples.of( + current.get(0), + current.get(1), + e2 + ); + return new Builder3<>(); } - } - - public class Build3 extends BaseBuilder> { - - public Build4 add(T3 e3) { - current = Tuples.of(current.get(0), current.get(1), current.get(2), e3); - return new Build4<>(); + + public class Builder3 extends BaseBuilder> { + + public Builder4 add(T3 e3) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + e3 + ); + return new Builder4<>(); } } - - public class Build4 extends BaseBuilder> { - - public Build5 add(T4 e4) { - current = Tuples.of(current.get(0), current.get(1), current.get(2), current.get(3), e4); - return new Build5<>(); + + public class Builder4 extends BaseBuilder> { + + public Builder5 add(T4 e4) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + e4 + ); + return new Builder5<>(); } - } - - public class Build5 extends BaseBuilder> { - - public Build6 add(T5 e5) { - current = Tuples.of( - current.get(0), - current.get(1), - current.get(2), - current.get(3), - current.get(4), - e5); - return new Build6<>(); + + public class Builder5 extends BaseBuilder> { + + public Builder6 add(T5 e5) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + e5 + ); + return new Builder6<>(); } - } - - public class Build6 extends BaseBuilder> { - + + public class Builder6 extends BaseBuilder> { + + public Builder7 add(T6 e6) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + current.get(5), + e6 + ); + return new Builder7<>(); + } } - - protected class BaseBuilder { - + + public class Builder7 extends BaseBuilder> { + + public Builder8 add(T7 e7) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + current.get(5), + current.get(6), + e7 + ); + return new Builder8<>(); + } + } + + public class Builder8 extends BaseBuilder> { + + public Builder9 add(T8 e8) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + current.get(5), + current.get(6), + current.get(7), + e8 + ); + return new Builder9<>(); + } + } + + public class Builder9 extends BaseBuilder> { + + public Builder10 add(T9 e9) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + current.get(5), + current.get(6), + current.get(7), + current.get(8), + e9 + ); + return new Builder10<>(); + } + } + + public class Builder10 extends BaseBuilder> { + + public Builder11 add(T10 e10) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + current.get(5), + current.get(6), + current.get(7), + current.get(8), + current.get(9), + e10 + ); + return new Builder11<>(); + } + } + + public class Builder11 extends BaseBuilder> { + + public Builder12 add(T11 e11) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + current.get(5), + current.get(6), + current.get(7), + current.get(8), + current.get(9), + current.get(10), + e11 + ); + return new Builder12<>(); + } + } + + public class Builder12 extends BaseBuilder> { + + public Builder13 add(T12 e12) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + current.get(5), + current.get(6), + current.get(7), + current.get(8), + current.get(9), + current.get(10), + current.get(11), + e12 + ); + return new Builder13<>(); + } + } + + public class Builder13 extends BaseBuilder> { + + public Builder14 add(T13 e13) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + current.get(5), + current.get(6), + current.get(7), + current.get(8), + current.get(9), + current.get(10), + current.get(11), + current.get(12), + e13 + ); + return new Builder14<>(); + } + } + + public class Builder14 extends BaseBuilder> { + + public Builder15 add(T14 e14) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + current.get(5), + current.get(6), + current.get(7), + current.get(8), + current.get(9), + current.get(10), + current.get(11), + current.get(12), + current.get(13), + e14 + ); + return new Builder15<>(); + } + } + + public class Builder15 extends BaseBuilder> { + + public Builder16 add(T15 e15) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + current.get(5), + current.get(6), + current.get(7), + current.get(8), + current.get(9), + current.get(10), + current.get(11), + current.get(12), + current.get(13), + current.get(14), + e15 + ); + return new Builder16<>(); + } + } + + public class Builder16 extends BaseBuilder> { + + public Builder17 add(T16 e16) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + current.get(5), + current.get(6), + current.get(7), + current.get(8), + current.get(9), + current.get(10), + current.get(11), + current.get(12), + current.get(13), + current.get(14), + current.get(15), + e16 + ); + return new Builder17<>(); + } + } + + public class Builder17 extends BaseBuilder> { + + public Builder18 add(T17 e17) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + current.get(5), + current.get(6), + current.get(7), + current.get(8), + current.get(9), + current.get(10), + current.get(11), + current.get(12), + current.get(13), + current.get(14), + current.get(15), + current.get(16), + e17 + ); + return new Builder18<>(); + } + } + + public class Builder18 extends BaseBuilder> { + + public Builder19 add(T18 e18) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + current.get(5), + current.get(6), + current.get(7), + current.get(8), + current.get(9), + current.get(10), + current.get(11), + current.get(12), + current.get(13), + current.get(14), + current.get(15), + current.get(16), + current.get(17), + e18 + ); + return new Builder19<>(); + } + } + + public class Builder19 extends BaseBuilder> { + + public Builder20 add(T19 e19) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + current.get(5), + current.get(6), + current.get(7), + current.get(8), + current.get(9), + current.get(10), + current.get(11), + current.get(12), + current.get(13), + current.get(14), + current.get(15), + current.get(16), + current.get(17), + current.get(18), + e19 + ); + return new Builder20<>(); + } + } + + public class Builder20 extends BaseBuilder> { + + public Builder21 add(T20 e20) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + current.get(5), + current.get(6), + current.get(7), + current.get(8), + current.get(9), + current.get(10), + current.get(11), + current.get(12), + current.get(13), + current.get(14), + current.get(15), + current.get(16), + current.get(17), + current.get(18), + current.get(19), + e20 + ); + return new Builder21<>(); + } + } + + public class Builder21 extends BaseBuilder> { + + public Builder22 add(T21 e21) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + current.get(5), + current.get(6), + current.get(7), + current.get(8), + current.get(9), + current.get(10), + current.get(11), + current.get(12), + current.get(13), + current.get(14), + current.get(15), + current.get(16), + current.get(17), + current.get(18), + current.get(19), + current.get(20), + e21 + ); + return new Builder22<>(); + } + } + + public class Builder22 extends BaseBuilder> { + + public Builder23 add(T22 e22) { + current = Tuples.of( + current.get(0), + current.get(1), + current.get(2), + current.get(3), + current.get(4), + current.get(5), + current.get(6), + current.get(7), + current.get(8), + current.get(9), + current.get(10), + current.get(11), + current.get(12), + current.get(13), + current.get(14), + current.get(15), + current.get(16), + current.get(17), + current.get(18), + current.get(19), + current.get(20), + current.get(21), + e22 + ); + return new Builder23<>(); + } + } + + public class Builder23 extends BaseBuilder> { + + + } + + private class BaseBuilder { + @SuppressWarnings("unchecked") public T build() { return (T) current; } - } - -} +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/TupleMapper.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/TupleMapper.java new file mode 100644 index 0000000000..5e641c73dc --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/TupleMapper.java @@ -0,0 +1,48 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple; + +import java.util.function.Function; + +/** + * A BasicTupleMapper may be used to map from an object of type T to a Tuple + * + * @author pemi + * @param The return type of the apply method + */ +public interface TupleMapper extends Function { + + /** + * Returns the degree of the Tuple. For example, a Tuple2 has a degree of 2 + * whereas a Tuple3 has a degree of 3. + * + * @return the degree of the Tuple + */ + int degree(); + + /** + * Gets the mapper at the given index. For example, get(0) will return the + * first mapper and get(1) will return the second etc. + * + * @param index of the mapper to get + * @return the mapper at the given index + * @throws IndexOutOfBoundsException if + * {@code index < 0 || index >= length()} + */ + Function get(int index); + +} diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuples.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuples.java index 9b39a19c08..5972efa49c 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuples.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuples.java @@ -1,13 +1,13 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the @@ -16,278 +16,2419 @@ */ package com.speedment.common.tuple; -import com.speedment.common.tuple.internal.*; +import com.speedment.common.tuple.internal.nonnullable.Tuple0Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple10Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple11Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple12Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple13Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple14Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple15Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple16Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple17Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple18Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple19Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple1Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple20Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple21Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple22Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple23Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple2Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple3Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple4Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple5Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple6Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple7Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple8Impl; +import com.speedment.common.tuple.internal.nonnullable.Tuple9Impl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple0MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple10MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple11MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple12MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple13MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple14MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple15MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple16MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple17MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple18MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple19MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple1MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple20MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple21MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple22MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple23MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple2MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple3MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple4MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple5MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple6MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple7MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple8MapperImpl; +import com.speedment.common.tuple.internal.nonnullable.mapper.Tuple9MapperImpl; +import com.speedment.common.tuple.nonnullable.Tuple0; +import com.speedment.common.tuple.nonnullable.Tuple10; +import com.speedment.common.tuple.nonnullable.Tuple11; +import com.speedment.common.tuple.nonnullable.Tuple12; +import com.speedment.common.tuple.nonnullable.Tuple13; +import com.speedment.common.tuple.nonnullable.Tuple14; +import com.speedment.common.tuple.nonnullable.Tuple15; +import com.speedment.common.tuple.nonnullable.Tuple16; +import com.speedment.common.tuple.nonnullable.Tuple17; +import com.speedment.common.tuple.nonnullable.Tuple18; +import com.speedment.common.tuple.nonnullable.Tuple19; +import com.speedment.common.tuple.nonnullable.Tuple1; +import com.speedment.common.tuple.nonnullable.Tuple20; +import com.speedment.common.tuple.nonnullable.Tuple21; +import com.speedment.common.tuple.nonnullable.Tuple22; +import com.speedment.common.tuple.nonnullable.Tuple23; +import com.speedment.common.tuple.nonnullable.Tuple2; +import com.speedment.common.tuple.nonnullable.Tuple3; +import com.speedment.common.tuple.nonnullable.Tuple4; +import com.speedment.common.tuple.nonnullable.Tuple5; +import com.speedment.common.tuple.nonnullable.Tuple6; +import com.speedment.common.tuple.nonnullable.Tuple7; +import com.speedment.common.tuple.nonnullable.Tuple8; +import com.speedment.common.tuple.nonnullable.Tuple9; +import java.util.function.Function; /** - * Basic convenience factory for Tuples. - * - * @author pemi + * A collection of static methods to produce different types of {@link Tuple } + * objects + * + * @author Per Minborg */ -public interface Tuples { - +public final class Tuples { + + private Tuples() { + throw new UnsupportedOperationException(); + } + /** - * Creates and returns an empty Tuple - * - * @return a {@link Tuple0} - * + * Creates and returns a {@link Tuple0} with the given parameters. + * + * @return a {@link Tuple0} with the given parameters. + * * @see Tuple0 * @see Tuple */ - static Tuple0 of() { + public static Tuple0 of() { return Tuple0Impl.EMPTY_TUPLE; } - + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple0} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple0 } + * @return a Function that, when applied, creates a {@link Tuple0} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple0 + * @see Tuple + */ + @SuppressWarnings("unchecked") + public static Function toTuple() { + return (Function) Tuple0MapperImpl.EMPTY_MAPPER; + } + /** - * Creates and returns a Tuple1 with the given parameters. - * + * Creates and returns a {@link Tuple1} with the given parameters. + * * @param type of element 0 - * @param e0 element 0 - * - * @return a {@link Tuple1} with the given parameters - * + * @param e0 element 0 + * @return a {@link Tuple1} with the given parameters. + * * @see Tuple1 * @see Tuple */ - static Tuple1 of(T0 e0) { + public static Tuple1 of(T0 e0) { return new Tuple1Impl<>(e0); } - + /** - * Creates and returns a Tuple2 with the given parameters. - * + * Creates and returns a Function that, when applied, creates a {@link + * Tuple1} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple1 } + * @param target type of m0 + * @param m0 mapper to apply for Tuple1's element 0 + * @return a Function that, when applied, creates a {@link Tuple1} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple1 + * @see Tuple + */ + public static Function> toTuple(Function m0) { + return new Tuple1MapperImpl<>(m0); + } + + /** + * Creates and returns a {@link Tuple2} with the given parameters. + * * @param type of element 0 * @param type of element 1 - * @param e0 element 0 - * @param e1 element 1 - * - * @return a {@link Tuple2} with the given parameters - * + * @param e0 element 0 + * @param e1 element 1 + * @return a {@link Tuple2} with the given parameters. + * * @see Tuple2 * @see Tuple */ - static Tuple2 of(T0 e0, T1 e1) { + public static Tuple2 of(T0 e0, T1 e1) { return new Tuple2Impl<>(e0, e1); } - + /** - * Creates and returns a Tuple3 with the given parameters. - * + * Creates and returns a Function that, when applied, creates a {@link + * Tuple2} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple2 } + * @param target type of m0 + * @param target type of m1 + * @param m0 mapper to apply for Tuple2's element 0 + * @param m1 mapper to apply for Tuple2's element 1 + * @return a Function that, when applied, creates a {@link Tuple2} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple2 + * @see Tuple + */ + public static Function> toTuple(Function m0, Function m1) { + return new Tuple2MapperImpl<>(m0, m1); + } + + /** + * Creates and returns a {@link Tuple3} with the given parameters. + * * @param type of element 0 * @param type of element 1 * @param type of element 2 - * @param e0 element 0 - * @param e1 element 1 - * @param e2 element 2 - * - * @return a {@link Tuple3} with the given parameters - * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @return a {@link Tuple3} with the given parameters. + * * @see Tuple3 * @see Tuple */ - static Tuple3 of(T0 e0, T1 e1, T2 e2) { + public static Tuple3 of(T0 e0, T1 e1, T2 e2) { return new Tuple3Impl<>(e0, e1, e2); } - + /** - * Creates and returns a Tuple3 with the given parameters. - * + * Creates and returns a Function that, when applied, creates a {@link + * Tuple3} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple3 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param m0 mapper to apply for Tuple3's element 0 + * @param m1 mapper to apply for Tuple3's element 1 + * @param m2 mapper to apply for Tuple3's element 2 + * @return a Function that, when applied, creates a {@link Tuple3} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple3 + * @see Tuple + */ + public static Function> toTuple(Function m0, Function m1, Function m2) { + return new Tuple3MapperImpl<>(m0, m1, m2); + } + + /** + * Creates and returns a {@link Tuple4} with the given parameters. + * * @param type of element 0 * @param type of element 1 * @param type of element 2 * @param type of element 3 - * @param e0 element 0 - * @param e1 element 1 - * @param e2 element 2 - * @param e3 element 3 - * - * @return a {@link Tuple4} with the given parameters - * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @return a {@link Tuple4} with the given parameters. + * * @see Tuple4 * @see Tuple */ - static Tuple4 of(T0 e0, T1 e1, T2 e2, T3 e3) { + public static Tuple4 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3) { return new Tuple4Impl<>(e0, e1, e2, e3); } - + /** - * Creates and returns a Tuple3 with the given parameters. - * + * Creates and returns a Function that, when applied, creates a {@link + * Tuple4} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple4 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param m0 mapper to apply for Tuple4's element 0 + * @param m1 mapper to apply for Tuple4's element 1 + * @param m2 mapper to apply for Tuple4's element 2 + * @param m3 mapper to apply for Tuple4's element 3 + * @return a Function that, when applied, creates a {@link Tuple4} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple4 + * @see Tuple + */ + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3) { + return new Tuple4MapperImpl<>(m0, m1, m2, m3); + } + + /** + * Creates and returns a {@link Tuple5} with the given parameters. + * * @param type of element 0 * @param type of element 1 * @param type of element 2 * @param type of element 3 - * @param type of element 3 - * @param e0 element 0 - * @param e1 element 1 - * @param e2 element 2 - * @param e3 element 3 - * @param e4 element 4 - * - * @return a {@link Tuple5} with the given parameters - * + * @param type of element 4 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @return a {@link Tuple5} with the given parameters. + * * @see Tuple5 * @see Tuple */ - static Tuple5 of(T0 e0, T1 e1, T2 e2, T3 e3, T4 e4) { + public static Tuple5 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4) { return new Tuple5Impl<>(e0, e1, e2, e3, e4); } - + /** - * Creates and returns a Tuple3 with the given parameters. - * + * Creates and returns a Function that, when applied, creates a {@link + * Tuple5} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple5 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param m0 mapper to apply for Tuple5's element 0 + * @param m1 mapper to apply for Tuple5's element 1 + * @param m2 mapper to apply for Tuple5's element 2 + * @param m3 mapper to apply for Tuple5's element 3 + * @param m4 mapper to apply for Tuple5's element 4 + * @return a Function that, when applied, creates a {@link Tuple5} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple5 + * @see Tuple + */ + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4) { + return new Tuple5MapperImpl<>(m0, m1, m2, m3, m4); + } + + /** + * Creates and returns a {@link Tuple6} with the given parameters. + * * @param type of element 0 * @param type of element 1 * @param type of element 2 * @param type of element 3 - * @param type of element 3 - * @param type of element 4 - * @param e0 element 0 - * @param e1 element 1 - * @param e2 element 2 - * @param e3 element 3 - * @param e4 element 4 - * @param e5 element 5 - * - * @return a {@link Tuple6} with the given parameters - * + * @param type of element 4 + * @param type of element 5 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @return a {@link Tuple6} with the given parameters. + * * @see Tuple6 * @see Tuple */ - static Tuple6 of(T0 e0, T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) { + public static Tuple6 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5) { return new Tuple6Impl<>(e0, e1, e2, e3, e4, e5); } - + /** - * Creates and returns a Tuple0OfNullables . - * - * @return a {@link Tuple0OfNullables} - * - * @see Tuple0OfNullables + * Creates and returns a Function that, when applied, creates a {@link + * Tuple6} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple6 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param m0 mapper to apply for Tuple6's element 0 + * @param m1 mapper to apply for Tuple6's element 1 + * @param m2 mapper to apply for Tuple6's element 2 + * @param m3 mapper to apply for Tuple6's element 3 + * @param m4 mapper to apply for Tuple6's element 4 + * @param m5 mapper to apply for Tuple6's element 5 + * @return a Function that, when applied, creates a {@link Tuple6} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple6 * @see Tuple */ - static Tuple0OfNullables ofNullables() { - return Tuple0OfNullablesImpl.EMPTY_TUPLE; + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5) { + return new Tuple6MapperImpl<>(m0, m1, m2, m3, m4, m5); } - + /** - * Creates and returns a Tuple1OfNullables with the given parameters. - * + * Creates and returns a {@link Tuple7} with the given parameters. + * * @param type of element 0 - * @param e0 element 0 - * - * @return a {@link Tuple1OfNullables} with the given parameters - * - * @see Tuple1OfNullables + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @return a {@link Tuple7} with the given parameters. + * + * @see Tuple7 * @see Tuple */ - static Tuple1OfNullables ofNullables(T0 e0) { - return new Tuple1OfNullablesImpl<>(e0); + public static Tuple7 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6) { + return new Tuple7Impl<>(e0, e1, e2, e3, e4, e5, e6); } - + /** - * Creates and returns a Tuple2OfNullables with the given parameters. - * - * @param type of element 0 - * @param type of element 1 - * @param e0 element 0 - * @param e1 element 1 - * - * @return a {@link Tuple2OfNullables} with the given parameters - * - * @see Tuple2OfNullables + * Creates and returns a Function that, when applied, creates a {@link + * Tuple7} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple7 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param m0 mapper to apply for Tuple7's element 0 + * @param m1 mapper to apply for Tuple7's element 1 + * @param m2 mapper to apply for Tuple7's element 2 + * @param m3 mapper to apply for Tuple7's element 3 + * @param m4 mapper to apply for Tuple7's element 4 + * @param m5 mapper to apply for Tuple7's element 5 + * @param m6 mapper to apply for Tuple7's element 6 + * @return a Function that, when applied, creates a {@link Tuple7} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple7 * @see Tuple */ - static Tuple2OfNullables ofNullables(T0 e0, T1 e1) { - return new Tuple2OfNullablesImpl<>(e0, e1); + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6) { + return new Tuple7MapperImpl<>(m0, m1, m2, m3, m4, m5, m6); } - + /** - * Creates and returns a Tuple3OfNullables with the given parameters. - * + * Creates and returns a {@link Tuple8} with the given parameters. + * * @param type of element 0 * @param type of element 1 * @param type of element 2 - * @param e0 element 0 - * @param e1 element 1 - * @param e2 element 2 - * - * @return a {@link Tuple3OfNullables} with the given parameters - * - * @see Tuple3OfNullables + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @return a {@link Tuple8} with the given parameters. + * + * @see Tuple8 * @see Tuple */ - static Tuple3OfNullables ofNullables(T0 e0, T1 e1, T2 e2) { - return new Tuple3OfNullablesImpl<>(e0, e1, e2); + public static Tuple8 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7) { + return new Tuple8Impl<>(e0, e1, e2, e3, e4, e5, e6, e7); } - + /** - * Creates and returns a Tuple4OfNullables with the given parameters. - * - * @param type of element 0 - * @param type of element 1 - * @param type of element 2 - * @param type of element 3 - * @param e0 element 0 - * @param e1 element 1 - * @param e2 element 2 - * @param e3 element 3 - * - * @return a {@link Tuple4OfNullables} with the given parameters - * - * @see Tuple4OfNullables + * Creates and returns a Function that, when applied, creates a {@link + * Tuple8} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple8 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param m0 mapper to apply for Tuple8's element 0 + * @param m1 mapper to apply for Tuple8's element 1 + * @param m2 mapper to apply for Tuple8's element 2 + * @param m3 mapper to apply for Tuple8's element 3 + * @param m4 mapper to apply for Tuple8's element 4 + * @param m5 mapper to apply for Tuple8's element 5 + * @param m6 mapper to apply for Tuple8's element 6 + * @param m7 mapper to apply for Tuple8's element 7 + * @return a Function that, when applied, creates a {@link Tuple8} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple8 * @see Tuple */ - static Tuple4OfNullables ofNullables(T0 e0, T1 e1, T2 e2, T3 e3) { - return new Tuple4OfNullablesImpl<>(e0, e1, e2, e3); + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7) { + return new Tuple8MapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7); } - + /** - * Creates and returns a Tuple5OfNullables with the given parameters. - * + * Creates and returns a {@link Tuple9} with the given parameters. + * * @param type of element 0 * @param type of element 1 * @param type of element 2 * @param type of element 3 * @param type of element 4 - * @param e0 element 0 - * @param e1 element 1 - * @param e2 element 2 - * @param e3 element 3 - * @param e4 element 4 - * - * @return a {@link Tuple5OfNullables} with the given parameters - * - * @see Tuple5OfNullables + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @return a {@link Tuple9} with the given parameters. + * + * @see Tuple9 * @see Tuple */ - static Tuple5OfNullables ofNullables(T0 e0, T1 e1, T2 e2, T3 e3, T4 e4) { - return new Tuple5OfNullablesImpl<>(e0, e1, e2, e3, e4); + public static Tuple9 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8) { + return new Tuple9Impl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8); } - + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple9} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple9 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param m0 mapper to apply for Tuple9's element 0 + * @param m1 mapper to apply for Tuple9's element 1 + * @param m2 mapper to apply for Tuple9's element 2 + * @param m3 mapper to apply for Tuple9's element 3 + * @param m4 mapper to apply for Tuple9's element 4 + * @param m5 mapper to apply for Tuple9's element 5 + * @param m6 mapper to apply for Tuple9's element 6 + * @param m7 mapper to apply for Tuple9's element 7 + * @param m8 mapper to apply for Tuple9's element 8 + * @return a Function that, when applied, creates a {@link Tuple9} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple9 + * @see Tuple + */ + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8) { + return new Tuple9MapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8); + } + /** - * Creates and returns a Tuple6OfNullables with the given parameters. - * + * Creates and returns a {@link Tuple10} with the given parameters. + * * @param type of element 0 * @param type of element 1 * @param type of element 2 * @param type of element 3 * @param type of element 4 * @param type of element 5 - * @param e0 element 0 - * @param e1 element 1 - * @param e2 element 2 - * @param e3 element 3 - * @param e4 element 4 - * @param e5 element 5 - * - * @return a {@link Tuple6OfNullables} with the given parameters - * - * @see Tuple5OfNullables + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @return a {@link Tuple10} with the given parameters. + * + * @see Tuple10 * @see Tuple */ - static Tuple6OfNullables ofNullables(T0 e0, T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) { - return new Tuple6OfNullablesImpl<>(e0, e1, e2, e3, e4, e5); + public static Tuple10 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9) { + return new Tuple10Impl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9); } - - // Todo: Add builder that makes .add(e0) -> Tuple1 .add(e0).add(e2) -> Tuple2 .set(3, e3) -> Tuple3 -} + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple10} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple10 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param m0 mapper to apply for Tuple10's element 0 + * @param m1 mapper to apply for Tuple10's element 1 + * @param m2 mapper to apply for Tuple10's element 2 + * @param m3 mapper to apply for Tuple10's element 3 + * @param m4 mapper to apply for Tuple10's element 4 + * @param m5 mapper to apply for Tuple10's element 5 + * @param m6 mapper to apply for Tuple10's element 6 + * @param m7 mapper to apply for Tuple10's element 7 + * @param m8 mapper to apply for Tuple10's element 8 + * @param m9 mapper to apply for Tuple10's element 9 + * @return a Function that, when applied, creates a {@link Tuple10} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple10 + * @see Tuple + */ + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9) { + return new Tuple10MapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9); + } + + /** + * Creates and returns a {@link Tuple11} with the given parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @return a {@link Tuple11} with the given parameters. + * + * @see Tuple11 + * @see Tuple + */ + public static Tuple11 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10) { + return new Tuple11Impl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple11} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple11 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param m0 mapper to apply for Tuple11's element 0 + * @param m1 mapper to apply for Tuple11's element 1 + * @param m2 mapper to apply for Tuple11's element 2 + * @param m3 mapper to apply for Tuple11's element 3 + * @param m4 mapper to apply for Tuple11's element 4 + * @param m5 mapper to apply for Tuple11's element 5 + * @param m6 mapper to apply for Tuple11's element 6 + * @param m7 mapper to apply for Tuple11's element 7 + * @param m8 mapper to apply for Tuple11's element 8 + * @param m9 mapper to apply for Tuple11's element 9 + * @param m10 mapper to apply for Tuple11's element 10 + * @return a Function that, when applied, creates a {@link Tuple11} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple11 + * @see Tuple + */ + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10) { + return new Tuple11MapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10); + } + + /** + * Creates and returns a {@link Tuple12} with the given parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @return a {@link Tuple12} with the given parameters. + * + * @see Tuple12 + * @see Tuple + */ + public static Tuple12 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11) { + return new Tuple12Impl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple12} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple12 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param m0 mapper to apply for Tuple12's element 0 + * @param m1 mapper to apply for Tuple12's element 1 + * @param m2 mapper to apply for Tuple12's element 2 + * @param m3 mapper to apply for Tuple12's element 3 + * @param m4 mapper to apply for Tuple12's element 4 + * @param m5 mapper to apply for Tuple12's element 5 + * @param m6 mapper to apply for Tuple12's element 6 + * @param m7 mapper to apply for Tuple12's element 7 + * @param m8 mapper to apply for Tuple12's element 8 + * @param m9 mapper to apply for Tuple12's element 9 + * @param m10 mapper to apply for Tuple12's element 10 + * @param m11 mapper to apply for Tuple12's element 11 + * @return a Function that, when applied, creates a {@link Tuple12} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple12 + * @see Tuple + */ + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11) { + return new Tuple12MapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11); + } + + /** + * Creates and returns a {@link Tuple13} with the given parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @return a {@link Tuple13} with the given parameters. + * + * @see Tuple13 + * @see Tuple + */ + public static Tuple13 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12) { + return new Tuple13Impl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple13} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple13 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param m0 mapper to apply for Tuple13's element 0 + * @param m1 mapper to apply for Tuple13's element 1 + * @param m2 mapper to apply for Tuple13's element 2 + * @param m3 mapper to apply for Tuple13's element 3 + * @param m4 mapper to apply for Tuple13's element 4 + * @param m5 mapper to apply for Tuple13's element 5 + * @param m6 mapper to apply for Tuple13's element 6 + * @param m7 mapper to apply for Tuple13's element 7 + * @param m8 mapper to apply for Tuple13's element 8 + * @param m9 mapper to apply for Tuple13's element 9 + * @param m10 mapper to apply for Tuple13's element 10 + * @param m11 mapper to apply for Tuple13's element 11 + * @param m12 mapper to apply for Tuple13's element 12 + * @return a Function that, when applied, creates a {@link Tuple13} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple13 + * @see Tuple + */ + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12) { + return new Tuple13MapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12); + } + + /** + * Creates and returns a {@link Tuple14} with the given parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @return a {@link Tuple14} with the given parameters. + * + * @see Tuple14 + * @see Tuple + */ + public static Tuple14 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13) { + return new Tuple14Impl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple14} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple14 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param m0 mapper to apply for Tuple14's element 0 + * @param m1 mapper to apply for Tuple14's element 1 + * @param m2 mapper to apply for Tuple14's element 2 + * @param m3 mapper to apply for Tuple14's element 3 + * @param m4 mapper to apply for Tuple14's element 4 + * @param m5 mapper to apply for Tuple14's element 5 + * @param m6 mapper to apply for Tuple14's element 6 + * @param m7 mapper to apply for Tuple14's element 7 + * @param m8 mapper to apply for Tuple14's element 8 + * @param m9 mapper to apply for Tuple14's element 9 + * @param m10 mapper to apply for Tuple14's element 10 + * @param m11 mapper to apply for Tuple14's element 11 + * @param m12 mapper to apply for Tuple14's element 12 + * @param m13 mapper to apply for Tuple14's element 13 + * @return a Function that, when applied, creates a {@link Tuple14} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple14 + * @see Tuple + */ + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13) { + return new Tuple14MapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13); + } + + /** + * Creates and returns a {@link Tuple15} with the given parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @return a {@link Tuple15} with the given parameters. + * + * @see Tuple15 + * @see Tuple + */ + public static Tuple15 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14) { + return new Tuple15Impl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple15} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple15 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param m0 mapper to apply for Tuple15's element 0 + * @param m1 mapper to apply for Tuple15's element 1 + * @param m2 mapper to apply for Tuple15's element 2 + * @param m3 mapper to apply for Tuple15's element 3 + * @param m4 mapper to apply for Tuple15's element 4 + * @param m5 mapper to apply for Tuple15's element 5 + * @param m6 mapper to apply for Tuple15's element 6 + * @param m7 mapper to apply for Tuple15's element 7 + * @param m8 mapper to apply for Tuple15's element 8 + * @param m9 mapper to apply for Tuple15's element 9 + * @param m10 mapper to apply for Tuple15's element 10 + * @param m11 mapper to apply for Tuple15's element 11 + * @param m12 mapper to apply for Tuple15's element 12 + * @param m13 mapper to apply for Tuple15's element 13 + * @param m14 mapper to apply for Tuple15's element 14 + * @return a Function that, when applied, creates a {@link Tuple15} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple15 + * @see Tuple + */ + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14) { + return new Tuple15MapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14); + } + + /** + * Creates and returns a {@link Tuple16} with the given parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @return a {@link Tuple16} with the given parameters. + * + * @see Tuple16 + * @see Tuple + */ + public static Tuple16 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15) { + return new Tuple16Impl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple16} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple16 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param target type of m15 + * @param m0 mapper to apply for Tuple16's element 0 + * @param m1 mapper to apply for Tuple16's element 1 + * @param m2 mapper to apply for Tuple16's element 2 + * @param m3 mapper to apply for Tuple16's element 3 + * @param m4 mapper to apply for Tuple16's element 4 + * @param m5 mapper to apply for Tuple16's element 5 + * @param m6 mapper to apply for Tuple16's element 6 + * @param m7 mapper to apply for Tuple16's element 7 + * @param m8 mapper to apply for Tuple16's element 8 + * @param m9 mapper to apply for Tuple16's element 9 + * @param m10 mapper to apply for Tuple16's element 10 + * @param m11 mapper to apply for Tuple16's element 11 + * @param m12 mapper to apply for Tuple16's element 12 + * @param m13 mapper to apply for Tuple16's element 13 + * @param m14 mapper to apply for Tuple16's element 14 + * @param m15 mapper to apply for Tuple16's element 15 + * @return a Function that, when applied, creates a {@link Tuple16} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple16 + * @see Tuple + */ + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15) { + return new Tuple16MapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15); + } + + /** + * Creates and returns a {@link Tuple17} with the given parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @return a {@link Tuple17} with the given parameters. + * + * @see Tuple17 + * @see Tuple + */ + public static Tuple17 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16) { + return new Tuple17Impl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple17} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple17 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param target type of m15 + * @param target type of m16 + * @param m0 mapper to apply for Tuple17's element 0 + * @param m1 mapper to apply for Tuple17's element 1 + * @param m2 mapper to apply for Tuple17's element 2 + * @param m3 mapper to apply for Tuple17's element 3 + * @param m4 mapper to apply for Tuple17's element 4 + * @param m5 mapper to apply for Tuple17's element 5 + * @param m6 mapper to apply for Tuple17's element 6 + * @param m7 mapper to apply for Tuple17's element 7 + * @param m8 mapper to apply for Tuple17's element 8 + * @param m9 mapper to apply for Tuple17's element 9 + * @param m10 mapper to apply for Tuple17's element 10 + * @param m11 mapper to apply for Tuple17's element 11 + * @param m12 mapper to apply for Tuple17's element 12 + * @param m13 mapper to apply for Tuple17's element 13 + * @param m14 mapper to apply for Tuple17's element 14 + * @param m15 mapper to apply for Tuple17's element 15 + * @param m16 mapper to apply for Tuple17's element 16 + * @return a Function that, when applied, creates a {@link Tuple17} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple17 + * @see Tuple + */ + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16) { + return new Tuple17MapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16); + } + + /** + * Creates and returns a {@link Tuple18} with the given parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @return a {@link Tuple18} with the given parameters. + * + * @see Tuple18 + * @see Tuple + */ + public static Tuple18 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17) { + return new Tuple18Impl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple18} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple18 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param target type of m15 + * @param target type of m16 + * @param target type of m17 + * @param m0 mapper to apply for Tuple18's element 0 + * @param m1 mapper to apply for Tuple18's element 1 + * @param m2 mapper to apply for Tuple18's element 2 + * @param m3 mapper to apply for Tuple18's element 3 + * @param m4 mapper to apply for Tuple18's element 4 + * @param m5 mapper to apply for Tuple18's element 5 + * @param m6 mapper to apply for Tuple18's element 6 + * @param m7 mapper to apply for Tuple18's element 7 + * @param m8 mapper to apply for Tuple18's element 8 + * @param m9 mapper to apply for Tuple18's element 9 + * @param m10 mapper to apply for Tuple18's element 10 + * @param m11 mapper to apply for Tuple18's element 11 + * @param m12 mapper to apply for Tuple18's element 12 + * @param m13 mapper to apply for Tuple18's element 13 + * @param m14 mapper to apply for Tuple18's element 14 + * @param m15 mapper to apply for Tuple18's element 15 + * @param m16 mapper to apply for Tuple18's element 16 + * @param m17 mapper to apply for Tuple18's element 17 + * @return a Function that, when applied, creates a {@link Tuple18} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple18 + * @see Tuple + */ + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17) { + return new Tuple18MapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17); + } + + /** + * Creates and returns a {@link Tuple19} with the given parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @return a {@link Tuple19} with the given parameters. + * + * @see Tuple19 + * @see Tuple + */ + public static Tuple19 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18) { + return new Tuple19Impl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple19} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple19 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param target type of m15 + * @param target type of m16 + * @param target type of m17 + * @param target type of m18 + * @param m0 mapper to apply for Tuple19's element 0 + * @param m1 mapper to apply for Tuple19's element 1 + * @param m2 mapper to apply for Tuple19's element 2 + * @param m3 mapper to apply for Tuple19's element 3 + * @param m4 mapper to apply for Tuple19's element 4 + * @param m5 mapper to apply for Tuple19's element 5 + * @param m6 mapper to apply for Tuple19's element 6 + * @param m7 mapper to apply for Tuple19's element 7 + * @param m8 mapper to apply for Tuple19's element 8 + * @param m9 mapper to apply for Tuple19's element 9 + * @param m10 mapper to apply for Tuple19's element 10 + * @param m11 mapper to apply for Tuple19's element 11 + * @param m12 mapper to apply for Tuple19's element 12 + * @param m13 mapper to apply for Tuple19's element 13 + * @param m14 mapper to apply for Tuple19's element 14 + * @param m15 mapper to apply for Tuple19's element 15 + * @param m16 mapper to apply for Tuple19's element 16 + * @param m17 mapper to apply for Tuple19's element 17 + * @param m18 mapper to apply for Tuple19's element 18 + * @return a Function that, when applied, creates a {@link Tuple19} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple19 + * @see Tuple + */ + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18) { + return new Tuple19MapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18); + } + + /** + * Creates and returns a {@link Tuple20} with the given parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @param e19 element 19 + * @return a {@link Tuple20} with the given parameters. + * + * @see Tuple20 + * @see Tuple + */ + public static Tuple20 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18, + T19 e19) { + return new Tuple20Impl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple20} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple20 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param target type of m15 + * @param target type of m16 + * @param target type of m17 + * @param target type of m18 + * @param target type of m19 + * @param m0 mapper to apply for Tuple20's element 0 + * @param m1 mapper to apply for Tuple20's element 1 + * @param m2 mapper to apply for Tuple20's element 2 + * @param m3 mapper to apply for Tuple20's element 3 + * @param m4 mapper to apply for Tuple20's element 4 + * @param m5 mapper to apply for Tuple20's element 5 + * @param m6 mapper to apply for Tuple20's element 6 + * @param m7 mapper to apply for Tuple20's element 7 + * @param m8 mapper to apply for Tuple20's element 8 + * @param m9 mapper to apply for Tuple20's element 9 + * @param m10 mapper to apply for Tuple20's element 10 + * @param m11 mapper to apply for Tuple20's element 11 + * @param m12 mapper to apply for Tuple20's element 12 + * @param m13 mapper to apply for Tuple20's element 13 + * @param m14 mapper to apply for Tuple20's element 14 + * @param m15 mapper to apply for Tuple20's element 15 + * @param m16 mapper to apply for Tuple20's element 16 + * @param m17 mapper to apply for Tuple20's element 17 + * @param m18 mapper to apply for Tuple20's element 18 + * @param m19 mapper to apply for Tuple20's element 19 + * @return a Function that, when applied, creates a {@link Tuple20} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple20 + * @see Tuple + */ + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18, + Function m19) { + return new Tuple20MapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19); + } + + /** + * Creates and returns a {@link Tuple21} with the given parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @param e19 element 19 + * @param e20 element 20 + * @return a {@link Tuple21} with the given parameters. + * + * @see Tuple21 + * @see Tuple + */ + public static Tuple21 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18, + T19 e19, + T20 e20) { + return new Tuple21Impl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple21} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple21 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param target type of m15 + * @param target type of m16 + * @param target type of m17 + * @param target type of m18 + * @param target type of m19 + * @param target type of m20 + * @param m0 mapper to apply for Tuple21's element 0 + * @param m1 mapper to apply for Tuple21's element 1 + * @param m2 mapper to apply for Tuple21's element 2 + * @param m3 mapper to apply for Tuple21's element 3 + * @param m4 mapper to apply for Tuple21's element 4 + * @param m5 mapper to apply for Tuple21's element 5 + * @param m6 mapper to apply for Tuple21's element 6 + * @param m7 mapper to apply for Tuple21's element 7 + * @param m8 mapper to apply for Tuple21's element 8 + * @param m9 mapper to apply for Tuple21's element 9 + * @param m10 mapper to apply for Tuple21's element 10 + * @param m11 mapper to apply for Tuple21's element 11 + * @param m12 mapper to apply for Tuple21's element 12 + * @param m13 mapper to apply for Tuple21's element 13 + * @param m14 mapper to apply for Tuple21's element 14 + * @param m15 mapper to apply for Tuple21's element 15 + * @param m16 mapper to apply for Tuple21's element 16 + * @param m17 mapper to apply for Tuple21's element 17 + * @param m18 mapper to apply for Tuple21's element 18 + * @param m19 mapper to apply for Tuple21's element 19 + * @param m20 mapper to apply for Tuple21's element 20 + * @return a Function that, when applied, creates a {@link Tuple21} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple21 + * @see Tuple + */ + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18, + Function m19, + Function m20) { + return new Tuple21MapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20); + } + + /** + * Creates and returns a {@link Tuple22} with the given parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param type of element 21 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @param e19 element 19 + * @param e20 element 20 + * @param e21 element 21 + * @return a {@link Tuple22} with the given parameters. + * + * @see Tuple22 + * @see Tuple + */ + public static Tuple22 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18, + T19 e19, + T20 e20, + T21 e21) { + return new Tuple22Impl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple22} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple22 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param target type of m15 + * @param target type of m16 + * @param target type of m17 + * @param target type of m18 + * @param target type of m19 + * @param target type of m20 + * @param target type of m21 + * @param m0 mapper to apply for Tuple22's element 0 + * @param m1 mapper to apply for Tuple22's element 1 + * @param m2 mapper to apply for Tuple22's element 2 + * @param m3 mapper to apply for Tuple22's element 3 + * @param m4 mapper to apply for Tuple22's element 4 + * @param m5 mapper to apply for Tuple22's element 5 + * @param m6 mapper to apply for Tuple22's element 6 + * @param m7 mapper to apply for Tuple22's element 7 + * @param m8 mapper to apply for Tuple22's element 8 + * @param m9 mapper to apply for Tuple22's element 9 + * @param m10 mapper to apply for Tuple22's element 10 + * @param m11 mapper to apply for Tuple22's element 11 + * @param m12 mapper to apply for Tuple22's element 12 + * @param m13 mapper to apply for Tuple22's element 13 + * @param m14 mapper to apply for Tuple22's element 14 + * @param m15 mapper to apply for Tuple22's element 15 + * @param m16 mapper to apply for Tuple22's element 16 + * @param m17 mapper to apply for Tuple22's element 17 + * @param m18 mapper to apply for Tuple22's element 18 + * @param m19 mapper to apply for Tuple22's element 19 + * @param m20 mapper to apply for Tuple22's element 20 + * @param m21 mapper to apply for Tuple22's element 21 + * @return a Function that, when applied, creates a {@link Tuple22} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple22 + * @see Tuple + */ + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18, + Function m19, + Function m20, + Function m21) { + return new Tuple22MapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21); + } + + /** + * Creates and returns a {@link Tuple23} with the given parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param type of element 21 + * @param type of element 22 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @param e19 element 19 + * @param e20 element 20 + * @param e21 element 21 + * @param e22 element 22 + * @return a {@link Tuple23} with the given parameters. + * + * @see Tuple23 + * @see Tuple + */ + public static Tuple23 of( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18, + T19 e19, + T20 e20, + T21 e21, + T22 e22) { + return new Tuple23Impl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple23} from an initial object of type T by applying the given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple23 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param target type of m15 + * @param target type of m16 + * @param target type of m17 + * @param target type of m18 + * @param target type of m19 + * @param target type of m20 + * @param target type of m21 + * @param target type of m22 + * @param m0 mapper to apply for Tuple23's element 0 + * @param m1 mapper to apply for Tuple23's element 1 + * @param m2 mapper to apply for Tuple23's element 2 + * @param m3 mapper to apply for Tuple23's element 3 + * @param m4 mapper to apply for Tuple23's element 4 + * @param m5 mapper to apply for Tuple23's element 5 + * @param m6 mapper to apply for Tuple23's element 6 + * @param m7 mapper to apply for Tuple23's element 7 + * @param m8 mapper to apply for Tuple23's element 8 + * @param m9 mapper to apply for Tuple23's element 9 + * @param m10 mapper to apply for Tuple23's element 10 + * @param m11 mapper to apply for Tuple23's element 11 + * @param m12 mapper to apply for Tuple23's element 12 + * @param m13 mapper to apply for Tuple23's element 13 + * @param m14 mapper to apply for Tuple23's element 14 + * @param m15 mapper to apply for Tuple23's element 15 + * @param m16 mapper to apply for Tuple23's element 16 + * @param m17 mapper to apply for Tuple23's element 17 + * @param m18 mapper to apply for Tuple23's element 18 + * @param m19 mapper to apply for Tuple23's element 19 + * @param m20 mapper to apply for Tuple23's element 20 + * @param m21 mapper to apply for Tuple23's element 21 + * @param m22 mapper to apply for Tuple23's element 22 + * @return a Function that, when applied, creates a {@link Tuple23} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple23 + * @see Tuple + */ + public static Function> toTuple( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18, + Function m19, + Function m20, + Function m21, + Function m22) { + return new Tuple23MapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/TuplesOfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/TuplesOfNullables.java new file mode 100644 index 0000000000..57480a2786 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/TuplesOfNullables.java @@ -0,0 +1,2482 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple; + +import com.speedment.common.tuple.internal.nullable.Tuple0OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple10OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple11OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple12OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple13OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple14OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple15OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple16OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple17OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple18OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple19OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple1OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple20OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple21OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple22OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple23OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple2OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple3OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple4OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple5OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple6OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple7OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple8OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.Tuple9OfNullablesImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple0OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple10OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple11OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple12OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple13OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple14OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple15OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple16OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple17OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple18OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple19OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple1OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple20OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple21OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple22OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple23OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple2OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple3OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple4OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple5OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple6OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple7OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple8OfNullablesMapperImpl; +import com.speedment.common.tuple.internal.nullable.mapper.Tuple9OfNullablesMapperImpl; +import com.speedment.common.tuple.nullable.Tuple0OfNullables; +import com.speedment.common.tuple.nullable.Tuple10OfNullables; +import com.speedment.common.tuple.nullable.Tuple11OfNullables; +import com.speedment.common.tuple.nullable.Tuple12OfNullables; +import com.speedment.common.tuple.nullable.Tuple13OfNullables; +import com.speedment.common.tuple.nullable.Tuple14OfNullables; +import com.speedment.common.tuple.nullable.Tuple15OfNullables; +import com.speedment.common.tuple.nullable.Tuple16OfNullables; +import com.speedment.common.tuple.nullable.Tuple17OfNullables; +import com.speedment.common.tuple.nullable.Tuple18OfNullables; +import com.speedment.common.tuple.nullable.Tuple19OfNullables; +import com.speedment.common.tuple.nullable.Tuple1OfNullables; +import com.speedment.common.tuple.nullable.Tuple20OfNullables; +import com.speedment.common.tuple.nullable.Tuple21OfNullables; +import com.speedment.common.tuple.nullable.Tuple22OfNullables; +import com.speedment.common.tuple.nullable.Tuple23OfNullables; +import com.speedment.common.tuple.nullable.Tuple2OfNullables; +import com.speedment.common.tuple.nullable.Tuple3OfNullables; +import com.speedment.common.tuple.nullable.Tuple4OfNullables; +import com.speedment.common.tuple.nullable.Tuple5OfNullables; +import com.speedment.common.tuple.nullable.Tuple6OfNullables; +import com.speedment.common.tuple.nullable.Tuple7OfNullables; +import com.speedment.common.tuple.nullable.Tuple8OfNullables; +import com.speedment.common.tuple.nullable.Tuple9OfNullables; +import java.util.function.Function; + +/** + * A collection of static methods to produce different types of {@link + * TupleOfNullables } objects + * + * @author Per Minborg + */ +public final class TuplesOfNullables { + + private TuplesOfNullables() { + throw new UnsupportedOperationException(); + } + + /** + * Creates and returns a {@link Tuple0OfNullables} with the given + * parameters. + * + * @return a {@link Tuple0OfNullables} with the given parameters. + * + * @see Tuple0 + * @see Tuple + */ + public static Tuple0OfNullables ofNullables() { + return Tuple0OfNullablesImpl.EMPTY_TUPLE; + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple0OfNullables} from an initial object of type T by applying the given + * mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple0 } + * @return a Function that, when applied, creates a {@link Tuple0} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple0 + * @see Tuple + */ + @SuppressWarnings("unchecked") + public static Function toTupleOfNullables() { + return (Function) Tuple0OfNullablesMapperImpl.EMPTY_MAPPER; + } + + /** + * Creates and returns a {@link Tuple1OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param e0 element 0 + * @return a {@link Tuple1OfNullables} with the given parameters. + * + * @see Tuple1 + * @see Tuple + */ + public static Tuple1OfNullables ofNullables(T0 e0) { + return new Tuple1OfNullablesImpl<>(e0); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple1OfNullables} from an initial object of type T by applying the given + * mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple1 } + * @param target type of m0 + * @param m0 mapper to apply for Tuple1's element 0 + * @return a Function that, when applied, creates a {@link Tuple1} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple1 + * @see Tuple + */ + public static Function> toTupleOfNullables(Function m0) { + return new Tuple1OfNullablesMapperImpl<>(m0); + } + + /** + * Creates and returns a {@link Tuple2OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param e0 element 0 + * @param e1 element 1 + * @return a {@link Tuple2OfNullables} with the given parameters. + * + * @see Tuple2 + * @see Tuple + */ + public static Tuple2OfNullables ofNullables(T0 e0, T1 e1) { + return new Tuple2OfNullablesImpl<>(e0, e1); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple2OfNullables} from an initial object of type T by applying the given + * mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple2 } + * @param target type of m0 + * @param target type of m1 + * @param m0 mapper to apply for Tuple2's element 0 + * @param m1 mapper to apply for Tuple2's element 1 + * @return a Function that, when applied, creates a {@link Tuple2} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple2 + * @see Tuple + */ + public static Function> toTupleOfNullables(Function m0, Function m1) { + return new Tuple2OfNullablesMapperImpl<>(m0, m1); + } + + /** + * Creates and returns a {@link Tuple3OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @return a {@link Tuple3OfNullables} with the given parameters. + * + * @see Tuple3 + * @see Tuple + */ + public static Tuple3OfNullables ofNullables(T0 e0, T1 e1, T2 e2) { + return new Tuple3OfNullablesImpl<>(e0, e1, e2); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple3OfNullables} from an initial object of type T by applying the given + * mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple3 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param m0 mapper to apply for Tuple3's element 0 + * @param m1 mapper to apply for Tuple3's element 1 + * @param m2 mapper to apply for Tuple3's element 2 + * @return a Function that, when applied, creates a {@link Tuple3} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple3 + * @see Tuple + */ + public static Function> toTupleOfNullables(Function m0, Function m1, Function m2) { + return new Tuple3OfNullablesMapperImpl<>(m0, m1, m2); + } + + /** + * Creates and returns a {@link Tuple4OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @return a {@link Tuple4OfNullables} with the given parameters. + * + * @see Tuple4 + * @see Tuple + */ + public static Tuple4OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3) { + return new Tuple4OfNullablesImpl<>(e0, e1, e2, e3); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple4OfNullables} from an initial object of type T by applying the given + * mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple4 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param m0 mapper to apply for Tuple4's element 0 + * @param m1 mapper to apply for Tuple4's element 1 + * @param m2 mapper to apply for Tuple4's element 2 + * @param m3 mapper to apply for Tuple4's element 3 + * @return a Function that, when applied, creates a {@link Tuple4} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple4 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3) { + return new Tuple4OfNullablesMapperImpl<>(m0, m1, m2, m3); + } + + /** + * Creates and returns a {@link Tuple5OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @return a {@link Tuple5OfNullables} with the given parameters. + * + * @see Tuple5 + * @see Tuple + */ + public static Tuple5OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4) { + return new Tuple5OfNullablesImpl<>(e0, e1, e2, e3, e4); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple5OfNullables} from an initial object of type T by applying the given + * mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple5 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param m0 mapper to apply for Tuple5's element 0 + * @param m1 mapper to apply for Tuple5's element 1 + * @param m2 mapper to apply for Tuple5's element 2 + * @param m3 mapper to apply for Tuple5's element 3 + * @param m4 mapper to apply for Tuple5's element 4 + * @return a Function that, when applied, creates a {@link Tuple5} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple5 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4) { + return new Tuple5OfNullablesMapperImpl<>(m0, m1, m2, m3, m4); + } + + /** + * Creates and returns a {@link Tuple6OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @return a {@link Tuple6OfNullables} with the given parameters. + * + * @see Tuple6 + * @see Tuple + */ + public static Tuple6OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5) { + return new Tuple6OfNullablesImpl<>(e0, e1, e2, e3, e4, e5); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple6OfNullables} from an initial object of type T by applying the given + * mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple6 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param m0 mapper to apply for Tuple6's element 0 + * @param m1 mapper to apply for Tuple6's element 1 + * @param m2 mapper to apply for Tuple6's element 2 + * @param m3 mapper to apply for Tuple6's element 3 + * @param m4 mapper to apply for Tuple6's element 4 + * @param m5 mapper to apply for Tuple6's element 5 + * @return a Function that, when applied, creates a {@link Tuple6} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple6 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5) { + return new Tuple6OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5); + } + + /** + * Creates and returns a {@link Tuple7OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @return a {@link Tuple7OfNullables} with the given parameters. + * + * @see Tuple7 + * @see Tuple + */ + public static Tuple7OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6) { + return new Tuple7OfNullablesImpl<>(e0, e1, e2, e3, e4, e5, e6); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple7OfNullables} from an initial object of type T by applying the given + * mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple7 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param m0 mapper to apply for Tuple7's element 0 + * @param m1 mapper to apply for Tuple7's element 1 + * @param m2 mapper to apply for Tuple7's element 2 + * @param m3 mapper to apply for Tuple7's element 3 + * @param m4 mapper to apply for Tuple7's element 4 + * @param m5 mapper to apply for Tuple7's element 5 + * @param m6 mapper to apply for Tuple7's element 6 + * @return a Function that, when applied, creates a {@link Tuple7} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple7 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6) { + return new Tuple7OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5, m6); + } + + /** + * Creates and returns a {@link Tuple8OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @return a {@link Tuple8OfNullables} with the given parameters. + * + * @see Tuple8 + * @see Tuple + */ + public static Tuple8OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7) { + return new Tuple8OfNullablesImpl<>(e0, e1, e2, e3, e4, e5, e6, e7); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple8OfNullables} from an initial object of type T by applying the given + * mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple8 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param m0 mapper to apply for Tuple8's element 0 + * @param m1 mapper to apply for Tuple8's element 1 + * @param m2 mapper to apply for Tuple8's element 2 + * @param m3 mapper to apply for Tuple8's element 3 + * @param m4 mapper to apply for Tuple8's element 4 + * @param m5 mapper to apply for Tuple8's element 5 + * @param m6 mapper to apply for Tuple8's element 6 + * @param m7 mapper to apply for Tuple8's element 7 + * @return a Function that, when applied, creates a {@link Tuple8} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple8 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7) { + return new Tuple8OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7); + } + + /** + * Creates and returns a {@link Tuple9OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @return a {@link Tuple9OfNullables} with the given parameters. + * + * @see Tuple9 + * @see Tuple + */ + public static Tuple9OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8) { + return new Tuple9OfNullablesImpl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple9OfNullables} from an initial object of type T by applying the given + * mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple9 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param m0 mapper to apply for Tuple9's element 0 + * @param m1 mapper to apply for Tuple9's element 1 + * @param m2 mapper to apply for Tuple9's element 2 + * @param m3 mapper to apply for Tuple9's element 3 + * @param m4 mapper to apply for Tuple9's element 4 + * @param m5 mapper to apply for Tuple9's element 5 + * @param m6 mapper to apply for Tuple9's element 6 + * @param m7 mapper to apply for Tuple9's element 7 + * @param m8 mapper to apply for Tuple9's element 8 + * @return a Function that, when applied, creates a {@link Tuple9} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple9 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8) { + return new Tuple9OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8); + } + + /** + * Creates and returns a {@link Tuple10OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @return a {@link Tuple10OfNullables} with the given parameters. + * + * @see Tuple10 + * @see Tuple + */ + public static Tuple10OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9) { + return new Tuple10OfNullablesImpl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple10OfNullables} from an initial object of type T by applying the + * given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple10 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param m0 mapper to apply for Tuple10's element 0 + * @param m1 mapper to apply for Tuple10's element 1 + * @param m2 mapper to apply for Tuple10's element 2 + * @param m3 mapper to apply for Tuple10's element 3 + * @param m4 mapper to apply for Tuple10's element 4 + * @param m5 mapper to apply for Tuple10's element 5 + * @param m6 mapper to apply for Tuple10's element 6 + * @param m7 mapper to apply for Tuple10's element 7 + * @param m8 mapper to apply for Tuple10's element 8 + * @param m9 mapper to apply for Tuple10's element 9 + * @return a Function that, when applied, creates a {@link Tuple10} from + * an initial object of type T by applying the given mappers. + * + * @see Tuple10 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9) { + return new Tuple10OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9); + } + + /** + * Creates and returns a {@link Tuple11OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @return a {@link Tuple11OfNullables} with the given parameters. + * + * @see Tuple11 + * @see Tuple + */ + public static Tuple11OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10) { + return new Tuple11OfNullablesImpl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple11OfNullables} from an initial object of type T by applying the + * given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple11 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param m0 mapper to apply for Tuple11's element 0 + * @param m1 mapper to apply for Tuple11's element 1 + * @param m2 mapper to apply for Tuple11's element 2 + * @param m3 mapper to apply for Tuple11's element 3 + * @param m4 mapper to apply for Tuple11's element 4 + * @param m5 mapper to apply for Tuple11's element 5 + * @param m6 mapper to apply for Tuple11's element 6 + * @param m7 mapper to apply for Tuple11's element 7 + * @param m8 mapper to apply for Tuple11's element 8 + * @param m9 mapper to apply for Tuple11's element 9 + * @param m10 mapper to apply for Tuple11's element 10 + * @return a Function that, when applied, creates a {@link Tuple11} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple11 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10) { + return new Tuple11OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10); + } + + /** + * Creates and returns a {@link Tuple12OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @return a {@link Tuple12OfNullables} with the given parameters. + * + * @see Tuple12 + * @see Tuple + */ + public static Tuple12OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11) { + return new Tuple12OfNullablesImpl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple12OfNullables} from an initial object of type T by applying the + * given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple12 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param m0 mapper to apply for Tuple12's element 0 + * @param m1 mapper to apply for Tuple12's element 1 + * @param m2 mapper to apply for Tuple12's element 2 + * @param m3 mapper to apply for Tuple12's element 3 + * @param m4 mapper to apply for Tuple12's element 4 + * @param m5 mapper to apply for Tuple12's element 5 + * @param m6 mapper to apply for Tuple12's element 6 + * @param m7 mapper to apply for Tuple12's element 7 + * @param m8 mapper to apply for Tuple12's element 8 + * @param m9 mapper to apply for Tuple12's element 9 + * @param m10 mapper to apply for Tuple12's element 10 + * @param m11 mapper to apply for Tuple12's element 11 + * @return a Function that, when applied, creates a {@link Tuple12} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple12 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11) { + return new Tuple12OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11); + } + + /** + * Creates and returns a {@link Tuple13OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @return a {@link Tuple13OfNullables} with the given parameters. + * + * @see Tuple13 + * @see Tuple + */ + public static Tuple13OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12) { + return new Tuple13OfNullablesImpl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple13OfNullables} from an initial object of type T by applying the + * given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple13 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param m0 mapper to apply for Tuple13's element 0 + * @param m1 mapper to apply for Tuple13's element 1 + * @param m2 mapper to apply for Tuple13's element 2 + * @param m3 mapper to apply for Tuple13's element 3 + * @param m4 mapper to apply for Tuple13's element 4 + * @param m5 mapper to apply for Tuple13's element 5 + * @param m6 mapper to apply for Tuple13's element 6 + * @param m7 mapper to apply for Tuple13's element 7 + * @param m8 mapper to apply for Tuple13's element 8 + * @param m9 mapper to apply for Tuple13's element 9 + * @param m10 mapper to apply for Tuple13's element 10 + * @param m11 mapper to apply for Tuple13's element 11 + * @param m12 mapper to apply for Tuple13's element 12 + * @return a Function that, when applied, creates a {@link Tuple13} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple13 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12) { + return new Tuple13OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12); + } + + /** + * Creates and returns a {@link Tuple14OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @return a {@link Tuple14OfNullables} with the given parameters. + * + * @see Tuple14 + * @see Tuple + */ + public static Tuple14OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13) { + return new Tuple14OfNullablesImpl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple14OfNullables} from an initial object of type T by applying the + * given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple14 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param m0 mapper to apply for Tuple14's element 0 + * @param m1 mapper to apply for Tuple14's element 1 + * @param m2 mapper to apply for Tuple14's element 2 + * @param m3 mapper to apply for Tuple14's element 3 + * @param m4 mapper to apply for Tuple14's element 4 + * @param m5 mapper to apply for Tuple14's element 5 + * @param m6 mapper to apply for Tuple14's element 6 + * @param m7 mapper to apply for Tuple14's element 7 + * @param m8 mapper to apply for Tuple14's element 8 + * @param m9 mapper to apply for Tuple14's element 9 + * @param m10 mapper to apply for Tuple14's element 10 + * @param m11 mapper to apply for Tuple14's element 11 + * @param m12 mapper to apply for Tuple14's element 12 + * @param m13 mapper to apply for Tuple14's element 13 + * @return a Function that, when applied, creates a {@link Tuple14} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple14 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13) { + return new Tuple14OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13); + } + + /** + * Creates and returns a {@link Tuple15OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @return a {@link Tuple15OfNullables} with the given parameters. + * + * @see Tuple15 + * @see Tuple + */ + public static Tuple15OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14) { + return new Tuple15OfNullablesImpl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple15OfNullables} from an initial object of type T by applying the + * given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple15 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param m0 mapper to apply for Tuple15's element 0 + * @param m1 mapper to apply for Tuple15's element 1 + * @param m2 mapper to apply for Tuple15's element 2 + * @param m3 mapper to apply for Tuple15's element 3 + * @param m4 mapper to apply for Tuple15's element 4 + * @param m5 mapper to apply for Tuple15's element 5 + * @param m6 mapper to apply for Tuple15's element 6 + * @param m7 mapper to apply for Tuple15's element 7 + * @param m8 mapper to apply for Tuple15's element 8 + * @param m9 mapper to apply for Tuple15's element 9 + * @param m10 mapper to apply for Tuple15's element 10 + * @param m11 mapper to apply for Tuple15's element 11 + * @param m12 mapper to apply for Tuple15's element 12 + * @param m13 mapper to apply for Tuple15's element 13 + * @param m14 mapper to apply for Tuple15's element 14 + * @return a Function that, when applied, creates a {@link Tuple15} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple15 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14) { + return new Tuple15OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14); + } + + /** + * Creates and returns a {@link Tuple16OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @return a {@link Tuple16OfNullables} with the given parameters. + * + * @see Tuple16 + * @see Tuple + */ + public static Tuple16OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15) { + return new Tuple16OfNullablesImpl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple16OfNullables} from an initial object of type T by applying the + * given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple16 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param target type of m15 + * @param m0 mapper to apply for Tuple16's element 0 + * @param m1 mapper to apply for Tuple16's element 1 + * @param m2 mapper to apply for Tuple16's element 2 + * @param m3 mapper to apply for Tuple16's element 3 + * @param m4 mapper to apply for Tuple16's element 4 + * @param m5 mapper to apply for Tuple16's element 5 + * @param m6 mapper to apply for Tuple16's element 6 + * @param m7 mapper to apply for Tuple16's element 7 + * @param m8 mapper to apply for Tuple16's element 8 + * @param m9 mapper to apply for Tuple16's element 9 + * @param m10 mapper to apply for Tuple16's element 10 + * @param m11 mapper to apply for Tuple16's element 11 + * @param m12 mapper to apply for Tuple16's element 12 + * @param m13 mapper to apply for Tuple16's element 13 + * @param m14 mapper to apply for Tuple16's element 14 + * @param m15 mapper to apply for Tuple16's element 15 + * @return a Function that, when applied, creates a {@link Tuple16} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple16 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15) { + return new Tuple16OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15); + } + + /** + * Creates and returns a {@link Tuple17OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @return a {@link Tuple17OfNullables} with the given parameters. + * + * @see Tuple17 + * @see Tuple + */ + public static Tuple17OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16) { + return new Tuple17OfNullablesImpl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple17OfNullables} from an initial object of type T by applying the + * given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple17 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param target type of m15 + * @param target type of m16 + * @param m0 mapper to apply for Tuple17's element 0 + * @param m1 mapper to apply for Tuple17's element 1 + * @param m2 mapper to apply for Tuple17's element 2 + * @param m3 mapper to apply for Tuple17's element 3 + * @param m4 mapper to apply for Tuple17's element 4 + * @param m5 mapper to apply for Tuple17's element 5 + * @param m6 mapper to apply for Tuple17's element 6 + * @param m7 mapper to apply for Tuple17's element 7 + * @param m8 mapper to apply for Tuple17's element 8 + * @param m9 mapper to apply for Tuple17's element 9 + * @param m10 mapper to apply for Tuple17's element 10 + * @param m11 mapper to apply for Tuple17's element 11 + * @param m12 mapper to apply for Tuple17's element 12 + * @param m13 mapper to apply for Tuple17's element 13 + * @param m14 mapper to apply for Tuple17's element 14 + * @param m15 mapper to apply for Tuple17's element 15 + * @param m16 mapper to apply for Tuple17's element 16 + * @return a Function that, when applied, creates a {@link Tuple17} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple17 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16) { + return new Tuple17OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16); + } + + /** + * Creates and returns a {@link Tuple18OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @return a {@link Tuple18OfNullables} with the given parameters. + * + * @see Tuple18 + * @see Tuple + */ + public static Tuple18OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17) { + return new Tuple18OfNullablesImpl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple18OfNullables} from an initial object of type T by applying the + * given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple18 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param target type of m15 + * @param target type of m16 + * @param target type of m17 + * @param m0 mapper to apply for Tuple18's element 0 + * @param m1 mapper to apply for Tuple18's element 1 + * @param m2 mapper to apply for Tuple18's element 2 + * @param m3 mapper to apply for Tuple18's element 3 + * @param m4 mapper to apply for Tuple18's element 4 + * @param m5 mapper to apply for Tuple18's element 5 + * @param m6 mapper to apply for Tuple18's element 6 + * @param m7 mapper to apply for Tuple18's element 7 + * @param m8 mapper to apply for Tuple18's element 8 + * @param m9 mapper to apply for Tuple18's element 9 + * @param m10 mapper to apply for Tuple18's element 10 + * @param m11 mapper to apply for Tuple18's element 11 + * @param m12 mapper to apply for Tuple18's element 12 + * @param m13 mapper to apply for Tuple18's element 13 + * @param m14 mapper to apply for Tuple18's element 14 + * @param m15 mapper to apply for Tuple18's element 15 + * @param m16 mapper to apply for Tuple18's element 16 + * @param m17 mapper to apply for Tuple18's element 17 + * @return a Function that, when applied, creates a {@link Tuple18} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple18 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17) { + return new Tuple18OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17); + } + + /** + * Creates and returns a {@link Tuple19OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @return a {@link Tuple19OfNullables} with the given parameters. + * + * @see Tuple19 + * @see Tuple + */ + public static Tuple19OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18) { + return new Tuple19OfNullablesImpl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple19OfNullables} from an initial object of type T by applying the + * given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple19 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param target type of m15 + * @param target type of m16 + * @param target type of m17 + * @param target type of m18 + * @param m0 mapper to apply for Tuple19's element 0 + * @param m1 mapper to apply for Tuple19's element 1 + * @param m2 mapper to apply for Tuple19's element 2 + * @param m3 mapper to apply for Tuple19's element 3 + * @param m4 mapper to apply for Tuple19's element 4 + * @param m5 mapper to apply for Tuple19's element 5 + * @param m6 mapper to apply for Tuple19's element 6 + * @param m7 mapper to apply for Tuple19's element 7 + * @param m8 mapper to apply for Tuple19's element 8 + * @param m9 mapper to apply for Tuple19's element 9 + * @param m10 mapper to apply for Tuple19's element 10 + * @param m11 mapper to apply for Tuple19's element 11 + * @param m12 mapper to apply for Tuple19's element 12 + * @param m13 mapper to apply for Tuple19's element 13 + * @param m14 mapper to apply for Tuple19's element 14 + * @param m15 mapper to apply for Tuple19's element 15 + * @param m16 mapper to apply for Tuple19's element 16 + * @param m17 mapper to apply for Tuple19's element 17 + * @param m18 mapper to apply for Tuple19's element 18 + * @return a Function that, when applied, creates a {@link Tuple19} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple19 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18) { + return new Tuple19OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18); + } + + /** + * Creates and returns a {@link Tuple20OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @param e19 element 19 + * @return a {@link Tuple20OfNullables} with the given parameters. + * + * @see Tuple20 + * @see Tuple + */ + public static Tuple20OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18, + T19 e19) { + return new Tuple20OfNullablesImpl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple20OfNullables} from an initial object of type T by applying the + * given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple20 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param target type of m15 + * @param target type of m16 + * @param target type of m17 + * @param target type of m18 + * @param target type of m19 + * @param m0 mapper to apply for Tuple20's element 0 + * @param m1 mapper to apply for Tuple20's element 1 + * @param m2 mapper to apply for Tuple20's element 2 + * @param m3 mapper to apply for Tuple20's element 3 + * @param m4 mapper to apply for Tuple20's element 4 + * @param m5 mapper to apply for Tuple20's element 5 + * @param m6 mapper to apply for Tuple20's element 6 + * @param m7 mapper to apply for Tuple20's element 7 + * @param m8 mapper to apply for Tuple20's element 8 + * @param m9 mapper to apply for Tuple20's element 9 + * @param m10 mapper to apply for Tuple20's element 10 + * @param m11 mapper to apply for Tuple20's element 11 + * @param m12 mapper to apply for Tuple20's element 12 + * @param m13 mapper to apply for Tuple20's element 13 + * @param m14 mapper to apply for Tuple20's element 14 + * @param m15 mapper to apply for Tuple20's element 15 + * @param m16 mapper to apply for Tuple20's element 16 + * @param m17 mapper to apply for Tuple20's element 17 + * @param m18 mapper to apply for Tuple20's element 18 + * @param m19 mapper to apply for Tuple20's element 19 + * @return a Function that, when applied, creates a {@link Tuple20} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple20 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18, + Function m19) { + return new Tuple20OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19); + } + + /** + * Creates and returns a {@link Tuple21OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @param e19 element 19 + * @param e20 element 20 + * @return a {@link Tuple21OfNullables} with the given parameters. + * + * @see Tuple21 + * @see Tuple + */ + public static Tuple21OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18, + T19 e19, + T20 e20) { + return new Tuple21OfNullablesImpl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple21OfNullables} from an initial object of type T by applying the + * given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple21 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param target type of m15 + * @param target type of m16 + * @param target type of m17 + * @param target type of m18 + * @param target type of m19 + * @param target type of m20 + * @param m0 mapper to apply for Tuple21's element 0 + * @param m1 mapper to apply for Tuple21's element 1 + * @param m2 mapper to apply for Tuple21's element 2 + * @param m3 mapper to apply for Tuple21's element 3 + * @param m4 mapper to apply for Tuple21's element 4 + * @param m5 mapper to apply for Tuple21's element 5 + * @param m6 mapper to apply for Tuple21's element 6 + * @param m7 mapper to apply for Tuple21's element 7 + * @param m8 mapper to apply for Tuple21's element 8 + * @param m9 mapper to apply for Tuple21's element 9 + * @param m10 mapper to apply for Tuple21's element 10 + * @param m11 mapper to apply for Tuple21's element 11 + * @param m12 mapper to apply for Tuple21's element 12 + * @param m13 mapper to apply for Tuple21's element 13 + * @param m14 mapper to apply for Tuple21's element 14 + * @param m15 mapper to apply for Tuple21's element 15 + * @param m16 mapper to apply for Tuple21's element 16 + * @param m17 mapper to apply for Tuple21's element 17 + * @param m18 mapper to apply for Tuple21's element 18 + * @param m19 mapper to apply for Tuple21's element 19 + * @param m20 mapper to apply for Tuple21's element 20 + * @return a Function that, when applied, creates a {@link Tuple21} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple21 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18, + Function m19, + Function m20) { + return new Tuple21OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20); + } + + /** + * Creates and returns a {@link Tuple22OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param type of element 21 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @param e19 element 19 + * @param e20 element 20 + * @param e21 element 21 + * @return a {@link Tuple22OfNullables} with the given parameters. + * + * @see Tuple22 + * @see Tuple + */ + public static Tuple22OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18, + T19 e19, + T20 e20, + T21 e21) { + return new Tuple22OfNullablesImpl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple22OfNullables} from an initial object of type T by applying the + * given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple22 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param target type of m15 + * @param target type of m16 + * @param target type of m17 + * @param target type of m18 + * @param target type of m19 + * @param target type of m20 + * @param target type of m21 + * @param m0 mapper to apply for Tuple22's element 0 + * @param m1 mapper to apply for Tuple22's element 1 + * @param m2 mapper to apply for Tuple22's element 2 + * @param m3 mapper to apply for Tuple22's element 3 + * @param m4 mapper to apply for Tuple22's element 4 + * @param m5 mapper to apply for Tuple22's element 5 + * @param m6 mapper to apply for Tuple22's element 6 + * @param m7 mapper to apply for Tuple22's element 7 + * @param m8 mapper to apply for Tuple22's element 8 + * @param m9 mapper to apply for Tuple22's element 9 + * @param m10 mapper to apply for Tuple22's element 10 + * @param m11 mapper to apply for Tuple22's element 11 + * @param m12 mapper to apply for Tuple22's element 12 + * @param m13 mapper to apply for Tuple22's element 13 + * @param m14 mapper to apply for Tuple22's element 14 + * @param m15 mapper to apply for Tuple22's element 15 + * @param m16 mapper to apply for Tuple22's element 16 + * @param m17 mapper to apply for Tuple22's element 17 + * @param m18 mapper to apply for Tuple22's element 18 + * @param m19 mapper to apply for Tuple22's element 19 + * @param m20 mapper to apply for Tuple22's element 20 + * @param m21 mapper to apply for Tuple22's element 21 + * @return a Function that, when applied, creates a {@link Tuple22} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple22 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18, + Function m19, + Function m20, + Function m21) { + return new Tuple22OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21); + } + + /** + * Creates and returns a {@link Tuple23OfNullables} with the given + * parameters. + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param type of element 21 + * @param type of element 22 + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @param e19 element 19 + * @param e20 element 20 + * @param e21 element 21 + * @param e22 element 22 + * @return a {@link Tuple23OfNullables} with the given parameters. + * + * @see Tuple23 + * @see Tuple + */ + public static Tuple23OfNullables ofNullables( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18, + T19 e19, + T20 e20, + T21 e21, + T22 e22) { + return new Tuple23OfNullablesImpl<>(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22); + } + + /** + * Creates and returns a Function that, when applied, creates a {@link + * Tuple23OfNullables} from an initial object of type T by applying the + * given mappers. + * + * @param type of the initial object to be used by the function to + * create a {@link Tuple23 } + * @param target type of m0 + * @param target type of m1 + * @param target type of m2 + * @param target type of m3 + * @param target type of m4 + * @param target type of m5 + * @param target type of m6 + * @param target type of m7 + * @param target type of m8 + * @param target type of m9 + * @param target type of m10 + * @param target type of m11 + * @param target type of m12 + * @param target type of m13 + * @param target type of m14 + * @param target type of m15 + * @param target type of m16 + * @param target type of m17 + * @param target type of m18 + * @param target type of m19 + * @param target type of m20 + * @param target type of m21 + * @param target type of m22 + * @param m0 mapper to apply for Tuple23's element 0 + * @param m1 mapper to apply for Tuple23's element 1 + * @param m2 mapper to apply for Tuple23's element 2 + * @param m3 mapper to apply for Tuple23's element 3 + * @param m4 mapper to apply for Tuple23's element 4 + * @param m5 mapper to apply for Tuple23's element 5 + * @param m6 mapper to apply for Tuple23's element 6 + * @param m7 mapper to apply for Tuple23's element 7 + * @param m8 mapper to apply for Tuple23's element 8 + * @param m9 mapper to apply for Tuple23's element 9 + * @param m10 mapper to apply for Tuple23's element 10 + * @param m11 mapper to apply for Tuple23's element 11 + * @param m12 mapper to apply for Tuple23's element 12 + * @param m13 mapper to apply for Tuple23's element 13 + * @param m14 mapper to apply for Tuple23's element 14 + * @param m15 mapper to apply for Tuple23's element 15 + * @param m16 mapper to apply for Tuple23's element 16 + * @param m17 mapper to apply for Tuple23's element 17 + * @param m18 mapper to apply for Tuple23's element 18 + * @param m19 mapper to apply for Tuple23's element 19 + * @param m20 mapper to apply for Tuple23's element 20 + * @param m21 mapper to apply for Tuple23's element 21 + * @param m22 mapper to apply for Tuple23's element 22 + * @return a Function that, when applied, creates a {@link Tuple23} + * from an initial object of type T by applying the given + * mappers. + * + * @see Tuple23 + * @see Tuple + */ + public static Function> toTupleOfNullables( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18, + Function m19, + Function m20, + Function m21, + Function m22) { + return new Tuple23OfNullablesMapperImpl<>(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/AbstractTuple.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/AbstractTuple.java index 89ba68ed1a..2793fab878 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/AbstractTuple.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/AbstractTuple.java @@ -44,4 +44,4 @@ public Object get(int index) { public Stream stream() { return Stream.of(values); } -} \ No newline at end of file +} diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/BasicAbstractTuple.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/BasicAbstractTuple.java index b1b97bf5c1..e5903a1951 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/BasicAbstractTuple.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/BasicAbstractTuple.java @@ -17,12 +17,11 @@ package com.speedment.common.tuple.internal; import com.speedment.common.tuple.BasicTuple; - import java.util.Arrays; import java.util.Objects; -import java.util.stream.Stream; - +import static java.util.Objects.requireNonNull; import static java.util.stream.Collectors.joining; +import java.util.stream.Stream; /** * The BasicAbstractTuple implements parts of a generic Tuple of any order. @@ -40,13 +39,16 @@ public abstract class BasicAbstractTuple, R> implements @SuppressWarnings("rawtypes") BasicAbstractTuple(Class baseClass, Object... values) { - this.baseClass = baseClass; + this.baseClass = requireNonNull(baseClass); if (!isNullable()) { - if (Stream.of(values).filter(Objects::isNull).findAny().isPresent()) { - throw new NullPointerException(getClass().getName() + " can not hold null values."); + if (Stream.of(values).anyMatch(Objects::isNull)) { + throw new NullPointerException(getClass().getName() + " cannot hold null values."); } } - this.values = Arrays.copyOf(values, values.length); + if (values.length != degree()) { + throw new IllegalArgumentException("A Tuple of degree " + degree() + " must contain exactly " + degree() + " elements. Element length was " + values.length); + } + this.values = Arrays.copyOf(values, requireNonNull(values.length)); } /** @@ -57,17 +59,12 @@ public abstract class BasicAbstractTuple, R> implements protected abstract boolean isNullable(); protected int assertIndexBounds(int index) { - if (index < 0 || index >= length()) { - throw new IndexOutOfBoundsException("index " + index + " is illegal. There is capacity for " + length() + " items in this class."); + if (index < 0 || index >= degree()) { + throw new IndexOutOfBoundsException("index " + index + " is illegal. The degree of this Tuple is " + degree() + "."); } return index; } - @Override - public int length() { - return values.length; - } - @Override public int hashCode() { return Objects.hash(values); @@ -87,7 +84,7 @@ public boolean equals(Object obj) { // Must be a BasicTuple since baseClass is a BasicTuple @SuppressWarnings("unchecked") final BasicTuple tuple = (BasicTuple) obj; - final int capacity = tuple.length(); + final int capacity = tuple.degree(); for (int i = 0; i < capacity; i++) { if (!Objects.equals(get(i), tuple.get(i))) { return false; @@ -100,14 +97,14 @@ public boolean equals(Object obj) { public String toString() { return getClass().getSimpleName() + " " + Stream.of(values) - .map(Objects::toString) - .collect(joining(", ", "{", "}")); + .map(Objects::toString) + .collect(joining(", ", "{", "}")); } @Override public Stream streamOf(Class clazz) { + requireNonNull(clazz); return Stream.of(values) - .filter(Objects::nonNull) .filter(clazz::isInstance) .map(clazz::cast); } diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple0Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple0Impl.java similarity index 61% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple0Impl.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple0Impl.java index eaccb5695d..a3f2a66bfb 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple0Impl.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple0Impl.java @@ -1,31 +1,37 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple.internal; +package com.speedment.common.tuple.internal.nonnullable; -import com.speedment.common.tuple.Tuple0; +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple0; /** - * - * @author pemi + * An implementation class of a {@link Tuple0 } + * + * @author Per Minborg */ public final class Tuple0Impl extends AbstractTuple implements Tuple0 { - - public static final Tuple0Impl EMPTY_TUPLE = new Tuple0Impl(); - + + public final static Tuple0 EMPTY_TUPLE = new Tuple0Impl(); + + /** + * Constructs a {@link Tuple } of type {@link Tuple0 }. + */ private Tuple0Impl() { super(Tuple0Impl.class); } diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple10Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple10Impl.java new file mode 100644 index 0000000000..9618de2960 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple10Impl.java @@ -0,0 +1,128 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple10; + +/** + * An implementation class of a {@link Tuple10 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * + * @author Per Minborg + */ +public final class Tuple10Impl extends AbstractTuple implements Tuple10 { + + /** + * Constructs a {@link Tuple } of type {@link Tuple10 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + */ + public Tuple10Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9) { + super(Tuple10Impl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9); + } + + @SuppressWarnings("unchecked") + @Override + public T0 get0() { + return ((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public T1 get1() { + return ((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public T2 get2() { + return ((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public T3 get3() { + return ((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public T4 get4() { + return ((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public T5 get5() { + return ((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public T6 get6() { + return ((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public T7 get7() { + return ((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public T8 get8() { + return ((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public T9 get9() { + return ((T9) values[9]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple11Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple11Impl.java new file mode 100644 index 0000000000..1b8defe90f --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple11Impl.java @@ -0,0 +1,137 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple11; + +/** + * An implementation class of a {@link Tuple11 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * + * @author Per Minborg + */ +public final class Tuple11Impl extends AbstractTuple implements Tuple11 { + + /** + * Constructs a {@link Tuple } of type {@link Tuple11 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + */ + public Tuple11Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10) { + super(Tuple11Impl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10); + } + + @SuppressWarnings("unchecked") + @Override + public T0 get0() { + return ((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public T1 get1() { + return ((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public T2 get2() { + return ((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public T3 get3() { + return ((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public T4 get4() { + return ((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public T5 get5() { + return ((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public T6 get6() { + return ((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public T7 get7() { + return ((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public T8 get8() { + return ((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public T9 get9() { + return ((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public T10 get10() { + return ((T10) values[10]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple12Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple12Impl.java new file mode 100644 index 0000000000..f238457c37 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple12Impl.java @@ -0,0 +1,146 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple12; + +/** + * An implementation class of a {@link Tuple12 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * + * @author Per Minborg + */ +public final class Tuple12Impl extends AbstractTuple implements Tuple12 { + + /** + * Constructs a {@link Tuple } of type {@link Tuple12 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + */ + public Tuple12Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11) { + super(Tuple12Impl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11); + } + + @SuppressWarnings("unchecked") + @Override + public T0 get0() { + return ((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public T1 get1() { + return ((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public T2 get2() { + return ((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public T3 get3() { + return ((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public T4 get4() { + return ((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public T5 get5() { + return ((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public T6 get6() { + return ((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public T7 get7() { + return ((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public T8 get8() { + return ((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public T9 get9() { + return ((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public T10 get10() { + return ((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public T11 get11() { + return ((T11) values[11]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple13Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple13Impl.java new file mode 100644 index 0000000000..630c57a814 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple13Impl.java @@ -0,0 +1,155 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple13; + +/** + * An implementation class of a {@link Tuple13 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * + * @author Per Minborg + */ +public final class Tuple13Impl extends AbstractTuple implements Tuple13 { + + /** + * Constructs a {@link Tuple } of type {@link Tuple13 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + */ + public Tuple13Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12) { + super(Tuple13Impl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12); + } + + @SuppressWarnings("unchecked") + @Override + public T0 get0() { + return ((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public T1 get1() { + return ((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public T2 get2() { + return ((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public T3 get3() { + return ((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public T4 get4() { + return ((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public T5 get5() { + return ((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public T6 get6() { + return ((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public T7 get7() { + return ((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public T8 get8() { + return ((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public T9 get9() { + return ((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public T10 get10() { + return ((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public T11 get11() { + return ((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public T12 get12() { + return ((T12) values[12]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple14Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple14Impl.java new file mode 100644 index 0000000000..17002e7ba1 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple14Impl.java @@ -0,0 +1,164 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple14; + +/** + * An implementation class of a {@link Tuple14 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * + * @author Per Minborg + */ +public final class Tuple14Impl extends AbstractTuple implements Tuple14 { + + /** + * Constructs a {@link Tuple } of type {@link Tuple14 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + */ + public Tuple14Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13) { + super(Tuple14Impl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13); + } + + @SuppressWarnings("unchecked") + @Override + public T0 get0() { + return ((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public T1 get1() { + return ((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public T2 get2() { + return ((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public T3 get3() { + return ((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public T4 get4() { + return ((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public T5 get5() { + return ((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public T6 get6() { + return ((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public T7 get7() { + return ((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public T8 get8() { + return ((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public T9 get9() { + return ((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public T10 get10() { + return ((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public T11 get11() { + return ((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public T12 get12() { + return ((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public T13 get13() { + return ((T13) values[13]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple15Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple15Impl.java new file mode 100644 index 0000000000..f6647dc01f --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple15Impl.java @@ -0,0 +1,173 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple15; + +/** + * An implementation class of a {@link Tuple15 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * + * @author Per Minborg + */ +public final class Tuple15Impl extends AbstractTuple implements Tuple15 { + + /** + * Constructs a {@link Tuple } of type {@link Tuple15 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + */ + public Tuple15Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14) { + super(Tuple15Impl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14); + } + + @SuppressWarnings("unchecked") + @Override + public T0 get0() { + return ((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public T1 get1() { + return ((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public T2 get2() { + return ((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public T3 get3() { + return ((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public T4 get4() { + return ((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public T5 get5() { + return ((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public T6 get6() { + return ((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public T7 get7() { + return ((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public T8 get8() { + return ((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public T9 get9() { + return ((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public T10 get10() { + return ((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public T11 get11() { + return ((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public T12 get12() { + return ((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public T13 get13() { + return ((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public T14 get14() { + return ((T14) values[14]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple16Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple16Impl.java new file mode 100644 index 0000000000..c57a9fceb8 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple16Impl.java @@ -0,0 +1,182 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple16; + +/** + * An implementation class of a {@link Tuple16 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * + * @author Per Minborg + */ +public final class Tuple16Impl extends AbstractTuple implements Tuple16 { + + /** + * Constructs a {@link Tuple } of type {@link Tuple16 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + */ + public Tuple16Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15) { + super(Tuple16Impl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15); + } + + @SuppressWarnings("unchecked") + @Override + public T0 get0() { + return ((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public T1 get1() { + return ((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public T2 get2() { + return ((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public T3 get3() { + return ((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public T4 get4() { + return ((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public T5 get5() { + return ((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public T6 get6() { + return ((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public T7 get7() { + return ((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public T8 get8() { + return ((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public T9 get9() { + return ((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public T10 get10() { + return ((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public T11 get11() { + return ((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public T12 get12() { + return ((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public T13 get13() { + return ((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public T14 get14() { + return ((T14) values[14]); + } + + @SuppressWarnings("unchecked") + @Override + public T15 get15() { + return ((T15) values[15]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple17Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple17Impl.java new file mode 100644 index 0000000000..9eff68204b --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple17Impl.java @@ -0,0 +1,191 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple17; + +/** + * An implementation class of a {@link Tuple17 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * + * @author Per Minborg + */ +public final class Tuple17Impl extends AbstractTuple implements Tuple17 { + + /** + * Constructs a {@link Tuple } of type {@link Tuple17 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + */ + public Tuple17Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16) { + super(Tuple17Impl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16); + } + + @SuppressWarnings("unchecked") + @Override + public T0 get0() { + return ((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public T1 get1() { + return ((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public T2 get2() { + return ((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public T3 get3() { + return ((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public T4 get4() { + return ((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public T5 get5() { + return ((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public T6 get6() { + return ((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public T7 get7() { + return ((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public T8 get8() { + return ((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public T9 get9() { + return ((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public T10 get10() { + return ((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public T11 get11() { + return ((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public T12 get12() { + return ((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public T13 get13() { + return ((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public T14 get14() { + return ((T14) values[14]); + } + + @SuppressWarnings("unchecked") + @Override + public T15 get15() { + return ((T15) values[15]); + } + + @SuppressWarnings("unchecked") + @Override + public T16 get16() { + return ((T16) values[16]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple18Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple18Impl.java new file mode 100644 index 0000000000..c8d1565be9 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple18Impl.java @@ -0,0 +1,200 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple18; + +/** + * An implementation class of a {@link Tuple18 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * + * @author Per Minborg + */ +public final class Tuple18Impl extends AbstractTuple implements Tuple18 { + + /** + * Constructs a {@link Tuple } of type {@link Tuple18 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + */ + public Tuple18Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17) { + super(Tuple18Impl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17); + } + + @SuppressWarnings("unchecked") + @Override + public T0 get0() { + return ((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public T1 get1() { + return ((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public T2 get2() { + return ((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public T3 get3() { + return ((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public T4 get4() { + return ((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public T5 get5() { + return ((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public T6 get6() { + return ((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public T7 get7() { + return ((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public T8 get8() { + return ((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public T9 get9() { + return ((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public T10 get10() { + return ((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public T11 get11() { + return ((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public T12 get12() { + return ((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public T13 get13() { + return ((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public T14 get14() { + return ((T14) values[14]); + } + + @SuppressWarnings("unchecked") + @Override + public T15 get15() { + return ((T15) values[15]); + } + + @SuppressWarnings("unchecked") + @Override + public T16 get16() { + return ((T16) values[16]); + } + + @SuppressWarnings("unchecked") + @Override + public T17 get17() { + return ((T17) values[17]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple19Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple19Impl.java new file mode 100644 index 0000000000..0bddb80e83 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple19Impl.java @@ -0,0 +1,209 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple19; + +/** + * An implementation class of a {@link Tuple19 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * + * @author Per Minborg + */ +public final class Tuple19Impl extends AbstractTuple implements Tuple19 { + + /** + * Constructs a {@link Tuple } of type {@link Tuple19 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + */ + public Tuple19Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18) { + super(Tuple19Impl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18); + } + + @SuppressWarnings("unchecked") + @Override + public T0 get0() { + return ((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public T1 get1() { + return ((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public T2 get2() { + return ((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public T3 get3() { + return ((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public T4 get4() { + return ((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public T5 get5() { + return ((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public T6 get6() { + return ((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public T7 get7() { + return ((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public T8 get8() { + return ((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public T9 get9() { + return ((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public T10 get10() { + return ((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public T11 get11() { + return ((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public T12 get12() { + return ((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public T13 get13() { + return ((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public T14 get14() { + return ((T14) values[14]); + } + + @SuppressWarnings("unchecked") + @Override + public T15 get15() { + return ((T15) values[15]); + } + + @SuppressWarnings("unchecked") + @Override + public T16 get16() { + return ((T16) values[16]); + } + + @SuppressWarnings("unchecked") + @Override + public T17 get17() { + return ((T17) values[17]); + } + + @SuppressWarnings("unchecked") + @Override + public T18 get18() { + return ((T18) values[18]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple1Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple1Impl.java similarity index 62% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple1Impl.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple1Impl.java index 3b1ce2daa3..a9aaf394b9 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple1Impl.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple1Impl.java @@ -1,37 +1,46 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple.internal; +package com.speedment.common.tuple.internal.nonnullable; -import com.speedment.common.tuple.Tuple1; +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple1; /** - * - * @author pemi - * @param Type of 0:th argument + * An implementation class of a {@link Tuple1 } + * + * @param type of element 0 + * + * @author Per Minborg */ public final class Tuple1Impl extends AbstractTuple implements Tuple1 { - + + /** + * Constructs a {@link Tuple } of type {@link Tuple1 }. + * + * @param e0 element 0 + */ public Tuple1Impl(T0 e0) { super(Tuple1Impl.class, e0); } - + @SuppressWarnings("unchecked") @Override public T0 get0() { - return (T0) values[0]; + return ((T0) values[0]); } } \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple20Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple20Impl.java new file mode 100644 index 0000000000..fa5451e369 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple20Impl.java @@ -0,0 +1,218 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple20; + +/** + * An implementation class of a {@link Tuple20 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * + * @author Per Minborg + */ +public final class Tuple20Impl extends AbstractTuple implements Tuple20 { + + /** + * Constructs a {@link Tuple } of type {@link Tuple20 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @param e19 element 19 + */ + public Tuple20Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18, + T19 e19) { + super(Tuple20Impl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19); + } + + @SuppressWarnings("unchecked") + @Override + public T0 get0() { + return ((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public T1 get1() { + return ((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public T2 get2() { + return ((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public T3 get3() { + return ((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public T4 get4() { + return ((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public T5 get5() { + return ((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public T6 get6() { + return ((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public T7 get7() { + return ((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public T8 get8() { + return ((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public T9 get9() { + return ((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public T10 get10() { + return ((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public T11 get11() { + return ((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public T12 get12() { + return ((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public T13 get13() { + return ((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public T14 get14() { + return ((T14) values[14]); + } + + @SuppressWarnings("unchecked") + @Override + public T15 get15() { + return ((T15) values[15]); + } + + @SuppressWarnings("unchecked") + @Override + public T16 get16() { + return ((T16) values[16]); + } + + @SuppressWarnings("unchecked") + @Override + public T17 get17() { + return ((T17) values[17]); + } + + @SuppressWarnings("unchecked") + @Override + public T18 get18() { + return ((T18) values[18]); + } + + @SuppressWarnings("unchecked") + @Override + public T19 get19() { + return ((T19) values[19]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple21Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple21Impl.java new file mode 100644 index 0000000000..31c1e6bd82 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple21Impl.java @@ -0,0 +1,227 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple21; + +/** + * An implementation class of a {@link Tuple21 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * + * @author Per Minborg + */ +public final class Tuple21Impl extends AbstractTuple implements Tuple21 { + + /** + * Constructs a {@link Tuple } of type {@link Tuple21 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @param e19 element 19 + * @param e20 element 20 + */ + public Tuple21Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18, + T19 e19, + T20 e20) { + super(Tuple21Impl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20); + } + + @SuppressWarnings("unchecked") + @Override + public T0 get0() { + return ((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public T1 get1() { + return ((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public T2 get2() { + return ((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public T3 get3() { + return ((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public T4 get4() { + return ((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public T5 get5() { + return ((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public T6 get6() { + return ((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public T7 get7() { + return ((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public T8 get8() { + return ((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public T9 get9() { + return ((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public T10 get10() { + return ((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public T11 get11() { + return ((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public T12 get12() { + return ((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public T13 get13() { + return ((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public T14 get14() { + return ((T14) values[14]); + } + + @SuppressWarnings("unchecked") + @Override + public T15 get15() { + return ((T15) values[15]); + } + + @SuppressWarnings("unchecked") + @Override + public T16 get16() { + return ((T16) values[16]); + } + + @SuppressWarnings("unchecked") + @Override + public T17 get17() { + return ((T17) values[17]); + } + + @SuppressWarnings("unchecked") + @Override + public T18 get18() { + return ((T18) values[18]); + } + + @SuppressWarnings("unchecked") + @Override + public T19 get19() { + return ((T19) values[19]); + } + + @SuppressWarnings("unchecked") + @Override + public T20 get20() { + return ((T20) values[20]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple22Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple22Impl.java new file mode 100644 index 0000000000..32ae1d32c2 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple22Impl.java @@ -0,0 +1,236 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple22; + +/** + * An implementation class of a {@link Tuple22 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param type of element 21 + * + * @author Per Minborg + */ +public final class Tuple22Impl extends AbstractTuple implements Tuple22 { + + /** + * Constructs a {@link Tuple } of type {@link Tuple22 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @param e19 element 19 + * @param e20 element 20 + * @param e21 element 21 + */ + public Tuple22Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18, + T19 e19, + T20 e20, + T21 e21) { + super(Tuple22Impl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21); + } + + @SuppressWarnings("unchecked") + @Override + public T0 get0() { + return ((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public T1 get1() { + return ((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public T2 get2() { + return ((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public T3 get3() { + return ((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public T4 get4() { + return ((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public T5 get5() { + return ((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public T6 get6() { + return ((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public T7 get7() { + return ((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public T8 get8() { + return ((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public T9 get9() { + return ((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public T10 get10() { + return ((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public T11 get11() { + return ((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public T12 get12() { + return ((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public T13 get13() { + return ((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public T14 get14() { + return ((T14) values[14]); + } + + @SuppressWarnings("unchecked") + @Override + public T15 get15() { + return ((T15) values[15]); + } + + @SuppressWarnings("unchecked") + @Override + public T16 get16() { + return ((T16) values[16]); + } + + @SuppressWarnings("unchecked") + @Override + public T17 get17() { + return ((T17) values[17]); + } + + @SuppressWarnings("unchecked") + @Override + public T18 get18() { + return ((T18) values[18]); + } + + @SuppressWarnings("unchecked") + @Override + public T19 get19() { + return ((T19) values[19]); + } + + @SuppressWarnings("unchecked") + @Override + public T20 get20() { + return ((T20) values[20]); + } + + @SuppressWarnings("unchecked") + @Override + public T21 get21() { + return ((T21) values[21]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple23Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple23Impl.java new file mode 100644 index 0000000000..991ff33d89 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple23Impl.java @@ -0,0 +1,245 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple23; + +/** + * An implementation class of a {@link Tuple23 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param type of element 21 + * @param type of element 22 + * + * @author Per Minborg + */ +public final class Tuple23Impl extends AbstractTuple implements Tuple23 { + + /** + * Constructs a {@link Tuple } of type {@link Tuple23 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @param e19 element 19 + * @param e20 element 20 + * @param e21 element 21 + * @param e22 element 22 + */ + public Tuple23Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18, + T19 e19, + T20 e20, + T21 e21, + T22 e22) { + super(Tuple23Impl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22); + } + + @SuppressWarnings("unchecked") + @Override + public T0 get0() { + return ((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public T1 get1() { + return ((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public T2 get2() { + return ((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public T3 get3() { + return ((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public T4 get4() { + return ((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public T5 get5() { + return ((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public T6 get6() { + return ((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public T7 get7() { + return ((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public T8 get8() { + return ((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public T9 get9() { + return ((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public T10 get10() { + return ((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public T11 get11() { + return ((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public T12 get12() { + return ((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public T13 get13() { + return ((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public T14 get14() { + return ((T14) values[14]); + } + + @SuppressWarnings("unchecked") + @Override + public T15 get15() { + return ((T15) values[15]); + } + + @SuppressWarnings("unchecked") + @Override + public T16 get16() { + return ((T16) values[16]); + } + + @SuppressWarnings("unchecked") + @Override + public T17 get17() { + return ((T17) values[17]); + } + + @SuppressWarnings("unchecked") + @Override + public T18 get18() { + return ((T18) values[18]); + } + + @SuppressWarnings("unchecked") + @Override + public T19 get19() { + return ((T19) values[19]); + } + + @SuppressWarnings("unchecked") + @Override + public T20 get20() { + return ((T20) values[20]); + } + + @SuppressWarnings("unchecked") + @Override + public T21 get21() { + return ((T21) values[21]); + } + + @SuppressWarnings("unchecked") + @Override + public T22 get22() { + return ((T22) values[22]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple2Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple2Impl.java similarity index 60% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple2Impl.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple2Impl.java index 107ab9a4d0..fe97dac0b0 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple2Impl.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple2Impl.java @@ -1,45 +1,54 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple.internal; +package com.speedment.common.tuple.internal.nonnullable; -import com.speedment.common.tuple.Tuple2; +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple2; /** - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument + * An implementation class of a {@link Tuple2 } + * + * @param type of element 0 + * @param type of element 1 + * + * @author Per Minborg */ public final class Tuple2Impl extends AbstractTuple implements Tuple2 { - + + /** + * Constructs a {@link Tuple } of type {@link Tuple2 }. + * + * @param e0 element 0 + * @param e1 element 1 + */ public Tuple2Impl(T0 e0, T1 e1) { super(Tuple2Impl.class, e0, e1); } - + @SuppressWarnings("unchecked") @Override public T0 get0() { - return (T0) values[0]; + return ((T0) values[0]); } - + @SuppressWarnings("unchecked") @Override public T1 get1() { - return (T1) values[1]; + return ((T1) values[1]); } - -} +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple3Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple3Impl.java similarity index 54% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple3Impl.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple3Impl.java index 07db077a32..dd93ec6851 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple3Impl.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple3Impl.java @@ -1,52 +1,62 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple.internal; +package com.speedment.common.tuple.internal.nonnullable; -import com.speedment.common.tuple.Tuple3; +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple3; /** - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument - * @param Type of 2:nd argument + * An implementation class of a {@link Tuple3 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * + * @author Per Minborg */ public final class Tuple3Impl extends AbstractTuple implements Tuple3 { - - public Tuple3Impl(T0 v0, T1 v1, T2 v2) { - super(Tuple3Impl.class, v0, v1, v2); + + /** + * Constructs a {@link Tuple } of type {@link Tuple3 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + */ + public Tuple3Impl(T0 e0, T1 e1, T2 e2) { + super(Tuple3Impl.class, e0, e1, e2); } - + @SuppressWarnings("unchecked") @Override public T0 get0() { - return (T0) values[0]; + return ((T0) values[0]); } - + @SuppressWarnings("unchecked") @Override public T1 get1() { - return (T1) values[1]; + return ((T1) values[1]); } - + @SuppressWarnings("unchecked") @Override public T2 get2() { - return (T2) values[2]; + return ((T2) values[2]); } - -} +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple4Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple4Impl.java similarity index 51% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple4Impl.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple4Impl.java index 7b409708f5..ddda49c96d 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple4Impl.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple4Impl.java @@ -1,59 +1,74 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple.internal; +package com.speedment.common.tuple.internal.nonnullable; -import com.speedment.common.tuple.Tuple4; +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple4; /** - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument - * @param Type of 2:nd argument - * @param Type of 3:rd argument + * An implementation class of a {@link Tuple4 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * + * @author Per Minborg */ public final class Tuple4Impl extends AbstractTuple implements Tuple4 { - - public Tuple4Impl(T0 v0, T1 v1, T2 v2, T3 v3) { - super(Tuple4Impl.class, v0, v1, v2, v3); + + /** + * Constructs a {@link Tuple } of type {@link Tuple4 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + */ + public Tuple4Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3) { + super(Tuple4Impl.class, e0, e1, e2, e3); } - + @SuppressWarnings("unchecked") @Override public T0 get0() { - return (T0) values[0]; + return ((T0) values[0]); } - + @SuppressWarnings("unchecked") @Override public T1 get1() { - return (T1) values[1]; + return ((T1) values[1]); } - + @SuppressWarnings("unchecked") @Override public T2 get2() { - return (T2) values[2]; + return ((T2) values[2]); } - + @SuppressWarnings("unchecked") @Override public T3 get3() { - return (T3) values[3]; + return ((T3) values[3]); } - -} +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple5Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple5Impl.java similarity index 50% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple5Impl.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple5Impl.java index 32e10a7c19..afeac48a47 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple5Impl.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple5Impl.java @@ -1,66 +1,83 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple.internal; +package com.speedment.common.tuple.internal.nonnullable; -import com.speedment.common.tuple.Tuple5; +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple5; /** - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument - * @param Type of 2:nd argument - * @param Type of 3:rd argument - * @param Type of 4:th argument + * An implementation class of a {@link Tuple5 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * + * @author Per Minborg */ public final class Tuple5Impl extends AbstractTuple implements Tuple5 { - - public Tuple5Impl(T0 v0, T1 v1, T2 v2, T3 v3, T4 v4) { - super(Tuple5Impl.class, v0, v1, v2, v3, v4); + + /** + * Constructs a {@link Tuple } of type {@link Tuple5 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + */ + public Tuple5Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4) { + super(Tuple5Impl.class, e0, e1, e2, e3, e4); } - + @SuppressWarnings("unchecked") @Override public T0 get0() { - return (T0) values[0]; + return ((T0) values[0]); } - + @SuppressWarnings("unchecked") @Override public T1 get1() { - return (T1) values[1]; + return ((T1) values[1]); } - + @SuppressWarnings("unchecked") @Override public T2 get2() { - return (T2) values[2]; + return ((T2) values[2]); } - + @SuppressWarnings("unchecked") @Override public T3 get3() { - return (T3) values[3]; + return ((T3) values[3]); } - + @SuppressWarnings("unchecked") @Override public T4 get4() { - return (T4) values[4]; + return ((T4) values[4]); } - -} +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple6Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple6Impl.java similarity index 50% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple6Impl.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple6Impl.java index 03f3bf99a5..b6dec15173 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple6Impl.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple6Impl.java @@ -1,73 +1,92 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple.internal; +package com.speedment.common.tuple.internal.nonnullable; -import com.speedment.common.tuple.Tuple6; +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple6; /** - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument - * @param Type of 2:nd argument - * @param Type of 3:rd argument - * @param Type of 4:th argument - * @param Type of 5:th argument + * An implementation class of a {@link Tuple6 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * + * @author Per Minborg */ public final class Tuple6Impl extends AbstractTuple implements Tuple6 { - - public Tuple6Impl(T0 v0, T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) { - super(Tuple6Impl.class, v0, v1, v2, v3, v4, v5); + + /** + * Constructs a {@link Tuple } of type {@link Tuple6 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + */ + public Tuple6Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5) { + super(Tuple6Impl.class, e0, e1, e2, e3, e4, e5); } - + @SuppressWarnings("unchecked") @Override public T0 get0() { - return (T0) values[0]; + return ((T0) values[0]); } - + @SuppressWarnings("unchecked") @Override public T1 get1() { - return (T1) values[1]; + return ((T1) values[1]); } - + @SuppressWarnings("unchecked") @Override public T2 get2() { - return (T2) values[2]; + return ((T2) values[2]); } - + @SuppressWarnings("unchecked") @Override public T3 get3() { - return (T3) values[3]; + return ((T3) values[3]); } - + @SuppressWarnings("unchecked") @Override public T4 get4() { - return (T4) values[4]; + return ((T4) values[4]); } - + @SuppressWarnings("unchecked") @Override public T5 get5() { - return (T5) values[5]; + return ((T5) values[5]); } - -} +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple7Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple7Impl.java new file mode 100644 index 0000000000..03841b6db8 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple7Impl.java @@ -0,0 +1,101 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple7; + +/** + * An implementation class of a {@link Tuple7 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * + * @author Per Minborg + */ +public final class Tuple7Impl extends AbstractTuple implements Tuple7 { + + /** + * Constructs a {@link Tuple } of type {@link Tuple7 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + */ + public Tuple7Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6) { + super(Tuple7Impl.class, e0, e1, e2, e3, e4, e5, e6); + } + + @SuppressWarnings("unchecked") + @Override + public T0 get0() { + return ((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public T1 get1() { + return ((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public T2 get2() { + return ((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public T3 get3() { + return ((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public T4 get4() { + return ((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public T5 get5() { + return ((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public T6 get6() { + return ((T6) values[6]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple8Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple8Impl.java new file mode 100644 index 0000000000..36b60c2920 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple8Impl.java @@ -0,0 +1,110 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple8; + +/** + * An implementation class of a {@link Tuple8 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * + * @author Per Minborg + */ +public final class Tuple8Impl extends AbstractTuple implements Tuple8 { + + /** + * Constructs a {@link Tuple } of type {@link Tuple8 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + */ + public Tuple8Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7) { + super(Tuple8Impl.class, e0, e1, e2, e3, e4, e5, e6, e7); + } + + @SuppressWarnings("unchecked") + @Override + public T0 get0() { + return ((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public T1 get1() { + return ((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public T2 get2() { + return ((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public T3 get3() { + return ((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public T4 get4() { + return ((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public T5 get5() { + return ((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public T6 get6() { + return ((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public T7 get7() { + return ((T7) values[7]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple9Impl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple9Impl.java new file mode 100644 index 0000000000..1b2cc8826a --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/Tuple9Impl.java @@ -0,0 +1,119 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.internal.AbstractTuple; +import com.speedment.common.tuple.nonnullable.Tuple9; + +/** + * An implementation class of a {@link Tuple9 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * + * @author Per Minborg + */ +public final class Tuple9Impl extends AbstractTuple implements Tuple9 { + + /** + * Constructs a {@link Tuple } of type {@link Tuple9 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + */ + public Tuple9Impl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8) { + super(Tuple9Impl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8); + } + + @SuppressWarnings("unchecked") + @Override + public T0 get0() { + return ((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public T1 get1() { + return ((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public T2 get2() { + return ((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public T3 get3() { + return ((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public T4 get4() { + return ((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public T5 get5() { + return ((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public T6 get6() { + return ((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public T7 get7() { + return ((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public T8 get8() { + return ((T8) values[8]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple0MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple0MapperImpl.java new file mode 100644 index 0000000000..3567a70754 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple0MapperImpl.java @@ -0,0 +1,62 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple0; +import java.util.function.Function; + +/** + * An implementation class of a {@link TupleMapper } of degree 0 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * + * @author Per Minborg + */ +public final class Tuple0MapperImpl implements TupleMapper { + + public final static Tuple0MapperImpl EMPTY_MAPPER = new Tuple0MapperImpl<>(); + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple0 }. + */ + private Tuple0MapperImpl() { + + } + + @Override + public Tuple0 apply(T t) { + return Tuples.of( + + ); + } + + @Override + public int degree() { + return 0; + } + + @Override + public Function get(int index) { + switch(index){ + + default : throw new IndexOutOfBoundsException(); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple10MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple10MapperImpl.java new file mode 100644 index 0000000000..91df7eb35c --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple10MapperImpl.java @@ -0,0 +1,170 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple10; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 10 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * + * @author Per Minborg + */ +public final class Tuple10MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple10 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + */ + public Tuple10MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + } + + @Override + public Tuple10 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t) + ); + } + + @Override + public int degree() { + return 10; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple11MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple11MapperImpl.java new file mode 100644 index 0000000000..789f907b36 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple11MapperImpl.java @@ -0,0 +1,181 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple11; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 11 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * + * @author Per Minborg + */ +public final class Tuple11MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple11 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + */ + public Tuple11MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + } + + @Override + public Tuple11 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t) + ); + } + + @Override + public int degree() { + return 11; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple12MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple12MapperImpl.java new file mode 100644 index 0000000000..59410b39e8 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple12MapperImpl.java @@ -0,0 +1,192 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple12; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 12 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * + * @author Per Minborg + */ +public final class Tuple12MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple12 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + */ + public Tuple12MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + } + + @Override + public Tuple12 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t) + ); + } + + @Override + public int degree() { + return 12; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple13MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple13MapperImpl.java new file mode 100644 index 0000000000..8165f2fbc3 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple13MapperImpl.java @@ -0,0 +1,203 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple13; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 13 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * + * @author Per Minborg + */ +public final class Tuple13MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple13 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + */ + public Tuple13MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + } + + @Override + public Tuple13 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t) + ); + } + + @Override + public int degree() { + return 13; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple14MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple14MapperImpl.java new file mode 100644 index 0000000000..42e0c210ad --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple14MapperImpl.java @@ -0,0 +1,214 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple14; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 14 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * + * @author Per Minborg + */ +public final class Tuple14MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple14 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + */ + public Tuple14MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + } + + @Override + public Tuple14 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t) + ); + } + + @Override + public int degree() { + return 14; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple15MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple15MapperImpl.java new file mode 100644 index 0000000000..6582c567a3 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple15MapperImpl.java @@ -0,0 +1,225 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple15; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 15 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * + * @author Per Minborg + */ +public final class Tuple15MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple15 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + */ + public Tuple15MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + } + + @Override + public Tuple15 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t) + ); + } + + @Override + public int degree() { + return 15; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple16MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple16MapperImpl.java new file mode 100644 index 0000000000..52e9c0c4f0 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple16MapperImpl.java @@ -0,0 +1,236 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple16; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 16 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * + * @author Per Minborg + */ +public final class Tuple16MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + private final Function m15; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple16 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + * @param m15 mapper to apply for element 15 + */ + public Tuple16MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + this.m15 = requireNonNull(m15); + } + + @Override + public Tuple16 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t), + m15.apply(t) + ); + } + + @Override + public int degree() { + return 16; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } + + public Function get15() { + return m15; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple17MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple17MapperImpl.java new file mode 100644 index 0000000000..b1c088ea9d --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple17MapperImpl.java @@ -0,0 +1,247 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple17; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 17 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * + * @author Per Minborg + */ +public final class Tuple17MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + private final Function m15; + private final Function m16; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple17 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + * @param m15 mapper to apply for element 15 + * @param m16 mapper to apply for element 16 + */ + public Tuple17MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + this.m15 = requireNonNull(m15); + this.m16 = requireNonNull(m16); + } + + @Override + public Tuple17 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t), + m15.apply(t), + m16.apply(t) + ); + } + + @Override + public int degree() { + return 17; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } + + public Function get15() { + return m15; + } + + public Function get16() { + return m16; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple18MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple18MapperImpl.java new file mode 100644 index 0000000000..ebdaefcd7a --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple18MapperImpl.java @@ -0,0 +1,258 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple18; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 18 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * + * @author Per Minborg + */ +public final class Tuple18MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + private final Function m15; + private final Function m16; + private final Function m17; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple18 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + * @param m15 mapper to apply for element 15 + * @param m16 mapper to apply for element 16 + * @param m17 mapper to apply for element 17 + */ + public Tuple18MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + this.m15 = requireNonNull(m15); + this.m16 = requireNonNull(m16); + this.m17 = requireNonNull(m17); + } + + @Override + public Tuple18 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t), + m15.apply(t), + m16.apply(t), + m17.apply(t) + ); + } + + @Override + public int degree() { + return 18; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } + + public Function get15() { + return m15; + } + + public Function get16() { + return m16; + } + + public Function get17() { + return m17; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple19MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple19MapperImpl.java new file mode 100644 index 0000000000..f0a8fe69c6 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple19MapperImpl.java @@ -0,0 +1,269 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple19; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 19 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * + * @author Per Minborg + */ +public final class Tuple19MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + private final Function m15; + private final Function m16; + private final Function m17; + private final Function m18; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple19 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + * @param m15 mapper to apply for element 15 + * @param m16 mapper to apply for element 16 + * @param m17 mapper to apply for element 17 + * @param m18 mapper to apply for element 18 + */ + public Tuple19MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + this.m15 = requireNonNull(m15); + this.m16 = requireNonNull(m16); + this.m17 = requireNonNull(m17); + this.m18 = requireNonNull(m18); + } + + @Override + public Tuple19 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t), + m15.apply(t), + m16.apply(t), + m17.apply(t), + m18.apply(t) + ); + } + + @Override + public int degree() { + return 19; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + case 18 : return get18(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } + + public Function get15() { + return m15; + } + + public Function get16() { + return m16; + } + + public Function get17() { + return m17; + } + + public Function get18() { + return m18; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple1MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple1MapperImpl.java new file mode 100644 index 0000000000..6d76bda2a0 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple1MapperImpl.java @@ -0,0 +1,70 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple1; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 1 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * + * @author Per Minborg + */ +public final class Tuple1MapperImpl implements TupleMapper> { + + private final Function m0; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple1 }. + * + * @param m0 mapper to apply for element 0 + */ + public Tuple1MapperImpl(Function m0) { + this.m0 = requireNonNull(m0); + } + + @Override + public Tuple1 apply(T t) { + return Tuples.of( + m0.apply(t) + ); + } + + @Override + public int degree() { + return 1; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple20MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple20MapperImpl.java new file mode 100644 index 0000000000..161ac49beb --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple20MapperImpl.java @@ -0,0 +1,280 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple20; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 20 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * + * @author Per Minborg + */ +public final class Tuple20MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + private final Function m15; + private final Function m16; + private final Function m17; + private final Function m18; + private final Function m19; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple20 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + * @param m15 mapper to apply for element 15 + * @param m16 mapper to apply for element 16 + * @param m17 mapper to apply for element 17 + * @param m18 mapper to apply for element 18 + * @param m19 mapper to apply for element 19 + */ + public Tuple20MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18, + Function m19) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + this.m15 = requireNonNull(m15); + this.m16 = requireNonNull(m16); + this.m17 = requireNonNull(m17); + this.m18 = requireNonNull(m18); + this.m19 = requireNonNull(m19); + } + + @Override + public Tuple20 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t), + m15.apply(t), + m16.apply(t), + m17.apply(t), + m18.apply(t), + m19.apply(t) + ); + } + + @Override + public int degree() { + return 20; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + case 18 : return get18(); + case 19 : return get19(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } + + public Function get15() { + return m15; + } + + public Function get16() { + return m16; + } + + public Function get17() { + return m17; + } + + public Function get18() { + return m18; + } + + public Function get19() { + return m19; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple21MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple21MapperImpl.java new file mode 100644 index 0000000000..d54e872c81 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple21MapperImpl.java @@ -0,0 +1,291 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple21; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 21 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * + * @author Per Minborg + */ +public final class Tuple21MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + private final Function m15; + private final Function m16; + private final Function m17; + private final Function m18; + private final Function m19; + private final Function m20; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple21 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + * @param m15 mapper to apply for element 15 + * @param m16 mapper to apply for element 16 + * @param m17 mapper to apply for element 17 + * @param m18 mapper to apply for element 18 + * @param m19 mapper to apply for element 19 + * @param m20 mapper to apply for element 20 + */ + public Tuple21MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18, + Function m19, + Function m20) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + this.m15 = requireNonNull(m15); + this.m16 = requireNonNull(m16); + this.m17 = requireNonNull(m17); + this.m18 = requireNonNull(m18); + this.m19 = requireNonNull(m19); + this.m20 = requireNonNull(m20); + } + + @Override + public Tuple21 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t), + m15.apply(t), + m16.apply(t), + m17.apply(t), + m18.apply(t), + m19.apply(t), + m20.apply(t) + ); + } + + @Override + public int degree() { + return 21; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + case 18 : return get18(); + case 19 : return get19(); + case 20 : return get20(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } + + public Function get15() { + return m15; + } + + public Function get16() { + return m16; + } + + public Function get17() { + return m17; + } + + public Function get18() { + return m18; + } + + public Function get19() { + return m19; + } + + public Function get20() { + return m20; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple22MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple22MapperImpl.java new file mode 100644 index 0000000000..2623587fa5 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple22MapperImpl.java @@ -0,0 +1,302 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple22; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 22 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param type of element 21 + * + * @author Per Minborg + */ +public final class Tuple22MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + private final Function m15; + private final Function m16; + private final Function m17; + private final Function m18; + private final Function m19; + private final Function m20; + private final Function m21; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple22 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + * @param m15 mapper to apply for element 15 + * @param m16 mapper to apply for element 16 + * @param m17 mapper to apply for element 17 + * @param m18 mapper to apply for element 18 + * @param m19 mapper to apply for element 19 + * @param m20 mapper to apply for element 20 + * @param m21 mapper to apply for element 21 + */ + public Tuple22MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18, + Function m19, + Function m20, + Function m21) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + this.m15 = requireNonNull(m15); + this.m16 = requireNonNull(m16); + this.m17 = requireNonNull(m17); + this.m18 = requireNonNull(m18); + this.m19 = requireNonNull(m19); + this.m20 = requireNonNull(m20); + this.m21 = requireNonNull(m21); + } + + @Override + public Tuple22 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t), + m15.apply(t), + m16.apply(t), + m17.apply(t), + m18.apply(t), + m19.apply(t), + m20.apply(t), + m21.apply(t) + ); + } + + @Override + public int degree() { + return 22; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + case 18 : return get18(); + case 19 : return get19(); + case 20 : return get20(); + case 21 : return get21(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } + + public Function get15() { + return m15; + } + + public Function get16() { + return m16; + } + + public Function get17() { + return m17; + } + + public Function get18() { + return m18; + } + + public Function get19() { + return m19; + } + + public Function get20() { + return m20; + } + + public Function get21() { + return m21; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple23MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple23MapperImpl.java new file mode 100644 index 0000000000..1bf88307d5 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple23MapperImpl.java @@ -0,0 +1,313 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple23; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 23 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param type of element 21 + * @param type of element 22 + * + * @author Per Minborg + */ +public final class Tuple23MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + private final Function m15; + private final Function m16; + private final Function m17; + private final Function m18; + private final Function m19; + private final Function m20; + private final Function m21; + private final Function m22; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple23 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + * @param m15 mapper to apply for element 15 + * @param m16 mapper to apply for element 16 + * @param m17 mapper to apply for element 17 + * @param m18 mapper to apply for element 18 + * @param m19 mapper to apply for element 19 + * @param m20 mapper to apply for element 20 + * @param m21 mapper to apply for element 21 + * @param m22 mapper to apply for element 22 + */ + public Tuple23MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18, + Function m19, + Function m20, + Function m21, + Function m22) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + this.m15 = requireNonNull(m15); + this.m16 = requireNonNull(m16); + this.m17 = requireNonNull(m17); + this.m18 = requireNonNull(m18); + this.m19 = requireNonNull(m19); + this.m20 = requireNonNull(m20); + this.m21 = requireNonNull(m21); + this.m22 = requireNonNull(m22); + } + + @Override + public Tuple23 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t), + m15.apply(t), + m16.apply(t), + m17.apply(t), + m18.apply(t), + m19.apply(t), + m20.apply(t), + m21.apply(t), + m22.apply(t) + ); + } + + @Override + public int degree() { + return 23; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + case 18 : return get18(); + case 19 : return get19(); + case 20 : return get20(); + case 21 : return get21(); + case 22 : return get22(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } + + public Function get15() { + return m15; + } + + public Function get16() { + return m16; + } + + public Function get17() { + return m17; + } + + public Function get18() { + return m18; + } + + public Function get19() { + return m19; + } + + public Function get20() { + return m20; + } + + public Function get21() { + return m21; + } + + public Function get22() { + return m22; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple2MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple2MapperImpl.java new file mode 100644 index 0000000000..807c67ba93 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple2MapperImpl.java @@ -0,0 +1,80 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple2; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 2 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * + * @author Per Minborg + */ +public final class Tuple2MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple2 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + */ + public Tuple2MapperImpl(Function m0, Function m1) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + } + + @Override + public Tuple2 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t) + ); + } + + @Override + public int degree() { + return 2; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple3MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple3MapperImpl.java new file mode 100644 index 0000000000..b01680d91e --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple3MapperImpl.java @@ -0,0 +1,90 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple3; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 3 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * + * @author Per Minborg + */ +public final class Tuple3MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple3 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + */ + public Tuple3MapperImpl(Function m0, Function m1, Function m2) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + } + + @Override + public Tuple3 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t) + ); + } + + @Override + public int degree() { + return 3; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple4MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple4MapperImpl.java new file mode 100644 index 0000000000..771e85bfb5 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple4MapperImpl.java @@ -0,0 +1,104 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple4; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 4 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * + * @author Per Minborg + */ +public final class Tuple4MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple4 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + */ + public Tuple4MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + } + + @Override + public Tuple4 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t) + ); + } + + @Override + public int degree() { + return 4; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple5MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple5MapperImpl.java new file mode 100644 index 0000000000..37cb1acf6e --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple5MapperImpl.java @@ -0,0 +1,115 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple5; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 5 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * + * @author Per Minborg + */ +public final class Tuple5MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple5 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + */ + public Tuple5MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + } + + @Override + public Tuple5 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t) + ); + } + + @Override + public int degree() { + return 5; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple6MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple6MapperImpl.java new file mode 100644 index 0000000000..5986a6eb4c --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple6MapperImpl.java @@ -0,0 +1,126 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple6; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 6 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * + * @author Per Minborg + */ +public final class Tuple6MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple6 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + */ + public Tuple6MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + } + + @Override + public Tuple6 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t) + ); + } + + @Override + public int degree() { + return 6; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple7MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple7MapperImpl.java new file mode 100644 index 0000000000..753ae16905 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple7MapperImpl.java @@ -0,0 +1,137 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple7; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 7 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * + * @author Per Minborg + */ +public final class Tuple7MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple7 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + */ + public Tuple7MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + } + + @Override + public Tuple7 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t) + ); + } + + @Override + public int degree() { + return 7; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple8MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple8MapperImpl.java new file mode 100644 index 0000000000..42313ba00e --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple8MapperImpl.java @@ -0,0 +1,148 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple8; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 8 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * + * @author Per Minborg + */ +public final class Tuple8MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple8 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + */ + public Tuple8MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + } + + @Override + public Tuple8 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t) + ); + } + + @Override + public int degree() { + return 8; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple9MapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple9MapperImpl.java new file mode 100644 index 0000000000..7a147d43a7 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nonnullable/mapper/Tuple9MapperImpl.java @@ -0,0 +1,159 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.Tuples; +import com.speedment.common.tuple.nonnullable.Tuple9; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 9 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * + * @author Per Minborg + */ +public final class Tuple9MapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple9 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + */ + public Tuple9MapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + } + + @Override + public Tuple9 apply(T t) { + return Tuples.of( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t) + ); + } + + @Override + public int degree() { + return 9; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple0OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple0OfNullablesImpl.java similarity index 58% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple0OfNullablesImpl.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple0OfNullablesImpl.java index af604ec590..02d913a9bc 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple0OfNullablesImpl.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple0OfNullablesImpl.java @@ -1,32 +1,39 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple.internal; +package com.speedment.common.tuple.internal.nullable; -import com.speedment.common.tuple.Tuple0OfNullables; +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple0; +import com.speedment.common.tuple.nullable.Tuple0OfNullables; +import java.util.Optional; /** - * - * @author pemi + * An implementation class of a {@link Tuple0 } + * + * @author Per Minborg */ public final class Tuple0OfNullablesImpl extends AbstractTupleOfNullables implements Tuple0OfNullables { - - public static final Tuple0OfNullables EMPTY_TUPLE = new Tuple0OfNullablesImpl(); - - @SuppressWarnings("rawtypes") + + public final static Tuple0OfNullables EMPTY_TUPLE = new Tuple0OfNullablesImpl(); + + /** + * Constructs a {@link Tuple } of type {@link Tuple0 }. + */ private Tuple0OfNullablesImpl() { super(Tuple0OfNullablesImpl.class); } diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple10OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple10OfNullablesImpl.java new file mode 100644 index 0000000000..9ac338313e --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple10OfNullablesImpl.java @@ -0,0 +1,130 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable; + +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple10; +import com.speedment.common.tuple.nullable.Tuple10OfNullables; +import java.util.Optional; + +/** + * An implementation class of a {@link Tuple10 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * + * @author Per Minborg + */ +public final class Tuple10OfNullablesImpl extends AbstractTupleOfNullables implements Tuple10OfNullables { + + /** + * Constructs a {@link Tuple } of type {@link Tuple10 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + */ + public Tuple10OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9) { + super(Tuple10OfNullablesImpl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get0() { + return Optional.ofNullable((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get1() { + return Optional.ofNullable((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get2() { + return Optional.ofNullable((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get3() { + return Optional.ofNullable((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get4() { + return Optional.ofNullable((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get5() { + return Optional.ofNullable((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get6() { + return Optional.ofNullable((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get7() { + return Optional.ofNullable((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get8() { + return Optional.ofNullable((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get9() { + return Optional.ofNullable((T9) values[9]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple11OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple11OfNullablesImpl.java new file mode 100644 index 0000000000..911b4c5399 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple11OfNullablesImpl.java @@ -0,0 +1,139 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable; + +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple11; +import com.speedment.common.tuple.nullable.Tuple11OfNullables; +import java.util.Optional; + +/** + * An implementation class of a {@link Tuple11 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * + * @author Per Minborg + */ +public final class Tuple11OfNullablesImpl extends AbstractTupleOfNullables implements Tuple11OfNullables { + + /** + * Constructs a {@link Tuple } of type {@link Tuple11 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + */ + public Tuple11OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10) { + super(Tuple11OfNullablesImpl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get0() { + return Optional.ofNullable((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get1() { + return Optional.ofNullable((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get2() { + return Optional.ofNullable((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get3() { + return Optional.ofNullable((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get4() { + return Optional.ofNullable((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get5() { + return Optional.ofNullable((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get6() { + return Optional.ofNullable((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get7() { + return Optional.ofNullable((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get8() { + return Optional.ofNullable((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get9() { + return Optional.ofNullable((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get10() { + return Optional.ofNullable((T10) values[10]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple12OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple12OfNullablesImpl.java new file mode 100644 index 0000000000..2297f6fb27 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple12OfNullablesImpl.java @@ -0,0 +1,148 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable; + +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple12; +import com.speedment.common.tuple.nullable.Tuple12OfNullables; +import java.util.Optional; + +/** + * An implementation class of a {@link Tuple12 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * + * @author Per Minborg + */ +public final class Tuple12OfNullablesImpl extends AbstractTupleOfNullables implements Tuple12OfNullables { + + /** + * Constructs a {@link Tuple } of type {@link Tuple12 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + */ + public Tuple12OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11) { + super(Tuple12OfNullablesImpl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get0() { + return Optional.ofNullable((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get1() { + return Optional.ofNullable((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get2() { + return Optional.ofNullable((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get3() { + return Optional.ofNullable((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get4() { + return Optional.ofNullable((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get5() { + return Optional.ofNullable((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get6() { + return Optional.ofNullable((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get7() { + return Optional.ofNullable((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get8() { + return Optional.ofNullable((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get9() { + return Optional.ofNullable((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get10() { + return Optional.ofNullable((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get11() { + return Optional.ofNullable((T11) values[11]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple13OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple13OfNullablesImpl.java new file mode 100644 index 0000000000..915d7ab269 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple13OfNullablesImpl.java @@ -0,0 +1,157 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable; + +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple13; +import com.speedment.common.tuple.nullable.Tuple13OfNullables; +import java.util.Optional; + +/** + * An implementation class of a {@link Tuple13 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * + * @author Per Minborg + */ +public final class Tuple13OfNullablesImpl extends AbstractTupleOfNullables implements Tuple13OfNullables { + + /** + * Constructs a {@link Tuple } of type {@link Tuple13 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + */ + public Tuple13OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12) { + super(Tuple13OfNullablesImpl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get0() { + return Optional.ofNullable((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get1() { + return Optional.ofNullable((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get2() { + return Optional.ofNullable((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get3() { + return Optional.ofNullable((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get4() { + return Optional.ofNullable((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get5() { + return Optional.ofNullable((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get6() { + return Optional.ofNullable((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get7() { + return Optional.ofNullable((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get8() { + return Optional.ofNullable((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get9() { + return Optional.ofNullable((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get10() { + return Optional.ofNullable((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get11() { + return Optional.ofNullable((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get12() { + return Optional.ofNullable((T12) values[12]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple14OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple14OfNullablesImpl.java new file mode 100644 index 0000000000..6af1abdc44 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple14OfNullablesImpl.java @@ -0,0 +1,166 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable; + +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple14; +import com.speedment.common.tuple.nullable.Tuple14OfNullables; +import java.util.Optional; + +/** + * An implementation class of a {@link Tuple14 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * + * @author Per Minborg + */ +public final class Tuple14OfNullablesImpl extends AbstractTupleOfNullables implements Tuple14OfNullables { + + /** + * Constructs a {@link Tuple } of type {@link Tuple14 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + */ + public Tuple14OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13) { + super(Tuple14OfNullablesImpl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get0() { + return Optional.ofNullable((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get1() { + return Optional.ofNullable((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get2() { + return Optional.ofNullable((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get3() { + return Optional.ofNullable((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get4() { + return Optional.ofNullable((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get5() { + return Optional.ofNullable((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get6() { + return Optional.ofNullable((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get7() { + return Optional.ofNullable((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get8() { + return Optional.ofNullable((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get9() { + return Optional.ofNullable((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get10() { + return Optional.ofNullable((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get11() { + return Optional.ofNullable((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get12() { + return Optional.ofNullable((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get13() { + return Optional.ofNullable((T13) values[13]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple15OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple15OfNullablesImpl.java new file mode 100644 index 0000000000..5f5fc1710e --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple15OfNullablesImpl.java @@ -0,0 +1,175 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable; + +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple15; +import com.speedment.common.tuple.nullable.Tuple15OfNullables; +import java.util.Optional; + +/** + * An implementation class of a {@link Tuple15 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * + * @author Per Minborg + */ +public final class Tuple15OfNullablesImpl extends AbstractTupleOfNullables implements Tuple15OfNullables { + + /** + * Constructs a {@link Tuple } of type {@link Tuple15 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + */ + public Tuple15OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14) { + super(Tuple15OfNullablesImpl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get0() { + return Optional.ofNullable((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get1() { + return Optional.ofNullable((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get2() { + return Optional.ofNullable((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get3() { + return Optional.ofNullable((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get4() { + return Optional.ofNullable((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get5() { + return Optional.ofNullable((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get6() { + return Optional.ofNullable((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get7() { + return Optional.ofNullable((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get8() { + return Optional.ofNullable((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get9() { + return Optional.ofNullable((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get10() { + return Optional.ofNullable((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get11() { + return Optional.ofNullable((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get12() { + return Optional.ofNullable((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get13() { + return Optional.ofNullable((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get14() { + return Optional.ofNullable((T14) values[14]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple16OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple16OfNullablesImpl.java new file mode 100644 index 0000000000..c0e4b95a6e --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple16OfNullablesImpl.java @@ -0,0 +1,184 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable; + +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple16; +import com.speedment.common.tuple.nullable.Tuple16OfNullables; +import java.util.Optional; + +/** + * An implementation class of a {@link Tuple16 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * + * @author Per Minborg + */ +public final class Tuple16OfNullablesImpl extends AbstractTupleOfNullables implements Tuple16OfNullables { + + /** + * Constructs a {@link Tuple } of type {@link Tuple16 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + */ + public Tuple16OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15) { + super(Tuple16OfNullablesImpl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get0() { + return Optional.ofNullable((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get1() { + return Optional.ofNullable((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get2() { + return Optional.ofNullable((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get3() { + return Optional.ofNullable((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get4() { + return Optional.ofNullable((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get5() { + return Optional.ofNullable((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get6() { + return Optional.ofNullable((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get7() { + return Optional.ofNullable((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get8() { + return Optional.ofNullable((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get9() { + return Optional.ofNullable((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get10() { + return Optional.ofNullable((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get11() { + return Optional.ofNullable((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get12() { + return Optional.ofNullable((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get13() { + return Optional.ofNullable((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get14() { + return Optional.ofNullable((T14) values[14]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get15() { + return Optional.ofNullable((T15) values[15]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple17OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple17OfNullablesImpl.java new file mode 100644 index 0000000000..ec8efb6c7f --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple17OfNullablesImpl.java @@ -0,0 +1,193 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable; + +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple17; +import com.speedment.common.tuple.nullable.Tuple17OfNullables; +import java.util.Optional; + +/** + * An implementation class of a {@link Tuple17 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * + * @author Per Minborg + */ +public final class Tuple17OfNullablesImpl extends AbstractTupleOfNullables implements Tuple17OfNullables { + + /** + * Constructs a {@link Tuple } of type {@link Tuple17 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + */ + public Tuple17OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16) { + super(Tuple17OfNullablesImpl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get0() { + return Optional.ofNullable((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get1() { + return Optional.ofNullable((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get2() { + return Optional.ofNullable((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get3() { + return Optional.ofNullable((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get4() { + return Optional.ofNullable((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get5() { + return Optional.ofNullable((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get6() { + return Optional.ofNullable((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get7() { + return Optional.ofNullable((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get8() { + return Optional.ofNullable((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get9() { + return Optional.ofNullable((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get10() { + return Optional.ofNullable((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get11() { + return Optional.ofNullable((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get12() { + return Optional.ofNullable((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get13() { + return Optional.ofNullable((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get14() { + return Optional.ofNullable((T14) values[14]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get15() { + return Optional.ofNullable((T15) values[15]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get16() { + return Optional.ofNullable((T16) values[16]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple18OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple18OfNullablesImpl.java new file mode 100644 index 0000000000..c9ed77d038 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple18OfNullablesImpl.java @@ -0,0 +1,202 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable; + +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple18; +import com.speedment.common.tuple.nullable.Tuple18OfNullables; +import java.util.Optional; + +/** + * An implementation class of a {@link Tuple18 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * + * @author Per Minborg + */ +public final class Tuple18OfNullablesImpl extends AbstractTupleOfNullables implements Tuple18OfNullables { + + /** + * Constructs a {@link Tuple } of type {@link Tuple18 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + */ + public Tuple18OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17) { + super(Tuple18OfNullablesImpl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get0() { + return Optional.ofNullable((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get1() { + return Optional.ofNullable((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get2() { + return Optional.ofNullable((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get3() { + return Optional.ofNullable((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get4() { + return Optional.ofNullable((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get5() { + return Optional.ofNullable((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get6() { + return Optional.ofNullable((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get7() { + return Optional.ofNullable((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get8() { + return Optional.ofNullable((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get9() { + return Optional.ofNullable((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get10() { + return Optional.ofNullable((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get11() { + return Optional.ofNullable((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get12() { + return Optional.ofNullable((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get13() { + return Optional.ofNullable((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get14() { + return Optional.ofNullable((T14) values[14]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get15() { + return Optional.ofNullable((T15) values[15]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get16() { + return Optional.ofNullable((T16) values[16]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get17() { + return Optional.ofNullable((T17) values[17]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple19OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple19OfNullablesImpl.java new file mode 100644 index 0000000000..a182fd4a62 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple19OfNullablesImpl.java @@ -0,0 +1,211 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable; + +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple19; +import com.speedment.common.tuple.nullable.Tuple19OfNullables; +import java.util.Optional; + +/** + * An implementation class of a {@link Tuple19 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * + * @author Per Minborg + */ +public final class Tuple19OfNullablesImpl extends AbstractTupleOfNullables implements Tuple19OfNullables { + + /** + * Constructs a {@link Tuple } of type {@link Tuple19 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + */ + public Tuple19OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18) { + super(Tuple19OfNullablesImpl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get0() { + return Optional.ofNullable((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get1() { + return Optional.ofNullable((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get2() { + return Optional.ofNullable((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get3() { + return Optional.ofNullable((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get4() { + return Optional.ofNullable((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get5() { + return Optional.ofNullable((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get6() { + return Optional.ofNullable((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get7() { + return Optional.ofNullable((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get8() { + return Optional.ofNullable((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get9() { + return Optional.ofNullable((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get10() { + return Optional.ofNullable((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get11() { + return Optional.ofNullable((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get12() { + return Optional.ofNullable((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get13() { + return Optional.ofNullable((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get14() { + return Optional.ofNullable((T14) values[14]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get15() { + return Optional.ofNullable((T15) values[15]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get16() { + return Optional.ofNullable((T16) values[16]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get17() { + return Optional.ofNullable((T17) values[17]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get18() { + return Optional.ofNullable((T18) values[18]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple1OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple1OfNullablesImpl.java similarity index 63% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple1OfNullablesImpl.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple1OfNullablesImpl.java index 377000cb29..54a634b116 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple1OfNullablesImpl.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple1OfNullablesImpl.java @@ -1,41 +1,48 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple.internal; - -import com.speedment.common.tuple.Tuple1OfNullables; +package com.speedment.common.tuple.internal.nullable; +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple1; +import com.speedment.common.tuple.nullable.Tuple1OfNullables; import java.util.Optional; /** - * - * @author pemi - * @param Type of 0:th argument + * An implementation class of a {@link Tuple1 } + * + * @param type of element 0 + * + * @author Per Minborg */ public final class Tuple1OfNullablesImpl extends AbstractTupleOfNullables implements Tuple1OfNullables { - - @SuppressWarnings("rawtypes") + + /** + * Constructs a {@link Tuple } of type {@link Tuple1 }. + * + * @param e0 element 0 + */ public Tuple1OfNullablesImpl(T0 e0) { super(Tuple1OfNullablesImpl.class, e0); } - + @SuppressWarnings("unchecked") @Override public Optional get0() { return Optional.ofNullable((T0) values[0]); } - -} +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple20OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple20OfNullablesImpl.java new file mode 100644 index 0000000000..6b52a019e8 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple20OfNullablesImpl.java @@ -0,0 +1,220 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable; + +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple20; +import com.speedment.common.tuple.nullable.Tuple20OfNullables; +import java.util.Optional; + +/** + * An implementation class of a {@link Tuple20 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * + * @author Per Minborg + */ +public final class Tuple20OfNullablesImpl extends AbstractTupleOfNullables implements Tuple20OfNullables { + + /** + * Constructs a {@link Tuple } of type {@link Tuple20 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @param e19 element 19 + */ + public Tuple20OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18, + T19 e19) { + super(Tuple20OfNullablesImpl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get0() { + return Optional.ofNullable((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get1() { + return Optional.ofNullable((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get2() { + return Optional.ofNullable((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get3() { + return Optional.ofNullable((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get4() { + return Optional.ofNullable((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get5() { + return Optional.ofNullable((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get6() { + return Optional.ofNullable((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get7() { + return Optional.ofNullable((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get8() { + return Optional.ofNullable((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get9() { + return Optional.ofNullable((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get10() { + return Optional.ofNullable((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get11() { + return Optional.ofNullable((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get12() { + return Optional.ofNullable((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get13() { + return Optional.ofNullable((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get14() { + return Optional.ofNullable((T14) values[14]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get15() { + return Optional.ofNullable((T15) values[15]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get16() { + return Optional.ofNullable((T16) values[16]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get17() { + return Optional.ofNullable((T17) values[17]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get18() { + return Optional.ofNullable((T18) values[18]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get19() { + return Optional.ofNullable((T19) values[19]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple21OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple21OfNullablesImpl.java new file mode 100644 index 0000000000..910d61e2b0 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple21OfNullablesImpl.java @@ -0,0 +1,229 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable; + +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple21; +import com.speedment.common.tuple.nullable.Tuple21OfNullables; +import java.util.Optional; + +/** + * An implementation class of a {@link Tuple21 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * + * @author Per Minborg + */ +public final class Tuple21OfNullablesImpl extends AbstractTupleOfNullables implements Tuple21OfNullables { + + /** + * Constructs a {@link Tuple } of type {@link Tuple21 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @param e19 element 19 + * @param e20 element 20 + */ + public Tuple21OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18, + T19 e19, + T20 e20) { + super(Tuple21OfNullablesImpl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get0() { + return Optional.ofNullable((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get1() { + return Optional.ofNullable((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get2() { + return Optional.ofNullable((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get3() { + return Optional.ofNullable((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get4() { + return Optional.ofNullable((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get5() { + return Optional.ofNullable((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get6() { + return Optional.ofNullable((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get7() { + return Optional.ofNullable((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get8() { + return Optional.ofNullable((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get9() { + return Optional.ofNullable((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get10() { + return Optional.ofNullable((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get11() { + return Optional.ofNullable((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get12() { + return Optional.ofNullable((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get13() { + return Optional.ofNullable((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get14() { + return Optional.ofNullable((T14) values[14]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get15() { + return Optional.ofNullable((T15) values[15]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get16() { + return Optional.ofNullable((T16) values[16]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get17() { + return Optional.ofNullable((T17) values[17]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get18() { + return Optional.ofNullable((T18) values[18]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get19() { + return Optional.ofNullable((T19) values[19]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get20() { + return Optional.ofNullable((T20) values[20]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple22OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple22OfNullablesImpl.java new file mode 100644 index 0000000000..74faf0c603 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple22OfNullablesImpl.java @@ -0,0 +1,238 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable; + +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple22; +import com.speedment.common.tuple.nullable.Tuple22OfNullables; +import java.util.Optional; + +/** + * An implementation class of a {@link Tuple22 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param type of element 21 + * + * @author Per Minborg + */ +public final class Tuple22OfNullablesImpl extends AbstractTupleOfNullables implements Tuple22OfNullables { + + /** + * Constructs a {@link Tuple } of type {@link Tuple22 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @param e19 element 19 + * @param e20 element 20 + * @param e21 element 21 + */ + public Tuple22OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18, + T19 e19, + T20 e20, + T21 e21) { + super(Tuple22OfNullablesImpl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get0() { + return Optional.ofNullable((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get1() { + return Optional.ofNullable((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get2() { + return Optional.ofNullable((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get3() { + return Optional.ofNullable((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get4() { + return Optional.ofNullable((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get5() { + return Optional.ofNullable((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get6() { + return Optional.ofNullable((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get7() { + return Optional.ofNullable((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get8() { + return Optional.ofNullable((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get9() { + return Optional.ofNullable((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get10() { + return Optional.ofNullable((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get11() { + return Optional.ofNullable((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get12() { + return Optional.ofNullable((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get13() { + return Optional.ofNullable((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get14() { + return Optional.ofNullable((T14) values[14]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get15() { + return Optional.ofNullable((T15) values[15]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get16() { + return Optional.ofNullable((T16) values[16]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get17() { + return Optional.ofNullable((T17) values[17]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get18() { + return Optional.ofNullable((T18) values[18]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get19() { + return Optional.ofNullable((T19) values[19]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get20() { + return Optional.ofNullable((T20) values[20]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get21() { + return Optional.ofNullable((T21) values[21]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple23OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple23OfNullablesImpl.java new file mode 100644 index 0000000000..e4a2aaae85 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple23OfNullablesImpl.java @@ -0,0 +1,247 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable; + +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple23; +import com.speedment.common.tuple.nullable.Tuple23OfNullables; +import java.util.Optional; + +/** + * An implementation class of a {@link Tuple23 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param type of element 21 + * @param type of element 22 + * + * @author Per Minborg + */ +public final class Tuple23OfNullablesImpl extends AbstractTupleOfNullables implements Tuple23OfNullables { + + /** + * Constructs a {@link Tuple } of type {@link Tuple23 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + * @param e9 element 9 + * @param e10 element 10 + * @param e11 element 11 + * @param e12 element 12 + * @param e13 element 13 + * @param e14 element 14 + * @param e15 element 15 + * @param e16 element 16 + * @param e17 element 17 + * @param e18 element 18 + * @param e19 element 19 + * @param e20 element 20 + * @param e21 element 21 + * @param e22 element 22 + */ + public Tuple23OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8, + T9 e9, + T10 e10, + T11 e11, + T12 e12, + T13 e13, + T14 e14, + T15 e15, + T16 e16, + T17 e17, + T18 e18, + T19 e19, + T20 e20, + T21 e21, + T22 e22) { + super(Tuple23OfNullablesImpl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get0() { + return Optional.ofNullable((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get1() { + return Optional.ofNullable((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get2() { + return Optional.ofNullable((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get3() { + return Optional.ofNullable((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get4() { + return Optional.ofNullable((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get5() { + return Optional.ofNullable((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get6() { + return Optional.ofNullable((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get7() { + return Optional.ofNullable((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get8() { + return Optional.ofNullable((T8) values[8]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get9() { + return Optional.ofNullable((T9) values[9]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get10() { + return Optional.ofNullable((T10) values[10]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get11() { + return Optional.ofNullable((T11) values[11]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get12() { + return Optional.ofNullable((T12) values[12]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get13() { + return Optional.ofNullable((T13) values[13]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get14() { + return Optional.ofNullable((T14) values[14]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get15() { + return Optional.ofNullable((T15) values[15]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get16() { + return Optional.ofNullable((T16) values[16]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get17() { + return Optional.ofNullable((T17) values[17]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get18() { + return Optional.ofNullable((T18) values[18]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get19() { + return Optional.ofNullable((T19) values[19]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get20() { + return Optional.ofNullable((T20) values[20]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get21() { + return Optional.ofNullable((T21) values[21]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get22() { + return Optional.ofNullable((T22) values[22]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple2OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple2OfNullablesImpl.java similarity index 64% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple2OfNullablesImpl.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple2OfNullablesImpl.java index dd4b8798c9..683ebd3bb6 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple2OfNullablesImpl.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple2OfNullablesImpl.java @@ -1,48 +1,56 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple.internal; - -import com.speedment.common.tuple.Tuple2OfNullables; +package com.speedment.common.tuple.internal.nullable; +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple2; +import com.speedment.common.tuple.nullable.Tuple2OfNullables; import java.util.Optional; /** - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument + * An implementation class of a {@link Tuple2 } + * + * @param type of element 0 + * @param type of element 1 + * + * @author Per Minborg */ public final class Tuple2OfNullablesImpl extends AbstractTupleOfNullables implements Tuple2OfNullables { - - @SuppressWarnings("rawtypes") + + /** + * Constructs a {@link Tuple } of type {@link Tuple2 }. + * + * @param e0 element 0 + * @param e1 element 1 + */ public Tuple2OfNullablesImpl(T0 e0, T1 e1) { super(Tuple2OfNullablesImpl.class, e0, e1); } - + @SuppressWarnings("unchecked") @Override public Optional get0() { return Optional.ofNullable((T0) values[0]); } - + @SuppressWarnings("unchecked") @Override public Optional get1() { return Optional.ofNullable((T1) values[1]); } - -} +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple3OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple3OfNullablesImpl.java similarity index 65% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple3OfNullablesImpl.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple3OfNullablesImpl.java index d36fbee824..5e1460253a 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple3OfNullablesImpl.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple3OfNullablesImpl.java @@ -1,55 +1,64 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple.internal; - -import com.speedment.common.tuple.Tuple3OfNullables; +package com.speedment.common.tuple.internal.nullable; +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple3; +import com.speedment.common.tuple.nullable.Tuple3OfNullables; import java.util.Optional; /** - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument - * @param Type of 2:nd argument + * An implementation class of a {@link Tuple3 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * + * @author Per Minborg */ public final class Tuple3OfNullablesImpl extends AbstractTupleOfNullables implements Tuple3OfNullables { - - @SuppressWarnings("rawtypes") + + /** + * Constructs a {@link Tuple } of type {@link Tuple3 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + */ public Tuple3OfNullablesImpl(T0 e0, T1 e1, T2 e2) { super(Tuple3OfNullablesImpl.class, e0, e1, e2); } - + @SuppressWarnings("unchecked") @Override public Optional get0() { return Optional.ofNullable((T0) values[0]); } - + @SuppressWarnings("unchecked") @Override public Optional get1() { return Optional.ofNullable((T1) values[1]); } - + @SuppressWarnings("unchecked") @Override public Optional get2() { return Optional.ofNullable((T2) values[2]); } - -} +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple4OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple4OfNullablesImpl.java similarity index 61% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple4OfNullablesImpl.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple4OfNullablesImpl.java index 1782dcfa48..6e45da0b5e 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple4OfNullablesImpl.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple4OfNullablesImpl.java @@ -1,62 +1,76 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple.internal; - -import com.speedment.common.tuple.Tuple4OfNullables; +package com.speedment.common.tuple.internal.nullable; +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple4; +import com.speedment.common.tuple.nullable.Tuple4OfNullables; import java.util.Optional; /** - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument - * @param Type of 2:nd argument - * @param Type of 3:rd argument + * An implementation class of a {@link Tuple4 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * + * @author Per Minborg */ public final class Tuple4OfNullablesImpl extends AbstractTupleOfNullables implements Tuple4OfNullables { - - @SuppressWarnings("rawtypes") - public Tuple4OfNullablesImpl(T0 e0, T1 e1, T2 e2, T3 e3) { + + /** + * Constructs a {@link Tuple } of type {@link Tuple4 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + */ + public Tuple4OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3) { super(Tuple4OfNullablesImpl.class, e0, e1, e2, e3); } - + @SuppressWarnings("unchecked") @Override public Optional get0() { return Optional.ofNullable((T0) values[0]); } - + @SuppressWarnings("unchecked") @Override public Optional get1() { return Optional.ofNullable((T1) values[1]); } - + @SuppressWarnings("unchecked") @Override public Optional get2() { return Optional.ofNullable((T2) values[2]); } - + @SuppressWarnings("unchecked") @Override public Optional get3() { return Optional.ofNullable((T3) values[3]); } - -} +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple5OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple5OfNullablesImpl.java similarity index 61% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple5OfNullablesImpl.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple5OfNullablesImpl.java index 02ecc1fff4..69a4abc69b 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple5OfNullablesImpl.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple5OfNullablesImpl.java @@ -1,69 +1,85 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple.internal; - -import com.speedment.common.tuple.Tuple5OfNullables; +package com.speedment.common.tuple.internal.nullable; +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple5; +import com.speedment.common.tuple.nullable.Tuple5OfNullables; import java.util.Optional; /** - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument - * @param Type of 2:nd argument - * @param Type of 3:rd argument - * @param Type of 4:th argument + * An implementation class of a {@link Tuple5 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * + * @author Per Minborg */ public final class Tuple5OfNullablesImpl extends AbstractTupleOfNullables implements Tuple5OfNullables { - - @SuppressWarnings("rawtypes") - public Tuple5OfNullablesImpl(T0 e0, T1 e1, T2 e2, T3 e3, T4 e4) { + + /** + * Constructs a {@link Tuple } of type {@link Tuple5 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + */ + public Tuple5OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4) { super(Tuple5OfNullablesImpl.class, e0, e1, e2, e3, e4); } - + @SuppressWarnings("unchecked") @Override public Optional get0() { return Optional.ofNullable((T0) values[0]); } - + @SuppressWarnings("unchecked") @Override public Optional get1() { return Optional.ofNullable((T1) values[1]); } - + @SuppressWarnings("unchecked") @Override public Optional get2() { return Optional.ofNullable((T2) values[2]); } - + @SuppressWarnings("unchecked") @Override public Optional get3() { return Optional.ofNullable((T3) values[3]); } - + @SuppressWarnings("unchecked") @Override public Optional get4() { return Optional.ofNullable((T4) values[4]); } - -} +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple6OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple6OfNullablesImpl.java similarity index 62% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple6OfNullablesImpl.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple6OfNullablesImpl.java index 8605d85c09..ec410968e1 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/Tuple6OfNullablesImpl.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple6OfNullablesImpl.java @@ -1,75 +1,94 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple.internal; - -import com.speedment.common.tuple.Tuple6OfNullables; +package com.speedment.common.tuple.internal.nullable; +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple6; +import com.speedment.common.tuple.nullable.Tuple6OfNullables; import java.util.Optional; /** - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument - * @param Type of 2:nd argument - * @param Type of 3:rd argument - * @param Type of 4:th argument + * An implementation class of a {@link Tuple6 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * + * @author Per Minborg */ public final class Tuple6OfNullablesImpl extends AbstractTupleOfNullables implements Tuple6OfNullables { - - @SuppressWarnings("rawtypes") - public Tuple6OfNullablesImpl(T0 e0, T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) { + + /** + * Constructs a {@link Tuple } of type {@link Tuple6 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + */ + public Tuple6OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5) { super(Tuple6OfNullablesImpl.class, e0, e1, e2, e3, e4, e5); } - + @SuppressWarnings("unchecked") @Override public Optional get0() { return Optional.ofNullable((T0) values[0]); } - + @SuppressWarnings("unchecked") @Override public Optional get1() { return Optional.ofNullable((T1) values[1]); } - + @SuppressWarnings("unchecked") @Override public Optional get2() { return Optional.ofNullable((T2) values[2]); } - + @SuppressWarnings("unchecked") @Override public Optional get3() { return Optional.ofNullable((T3) values[3]); } - + @SuppressWarnings("unchecked") @Override public Optional get4() { return Optional.ofNullable((T4) values[4]); } - + @SuppressWarnings("unchecked") @Override public Optional get5() { return Optional.ofNullable((T5) values[5]); } - -} +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple7OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple7OfNullablesImpl.java new file mode 100644 index 0000000000..04e4309408 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple7OfNullablesImpl.java @@ -0,0 +1,103 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable; + +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple7; +import com.speedment.common.tuple.nullable.Tuple7OfNullables; +import java.util.Optional; + +/** + * An implementation class of a {@link Tuple7 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * + * @author Per Minborg + */ +public final class Tuple7OfNullablesImpl extends AbstractTupleOfNullables implements Tuple7OfNullables { + + /** + * Constructs a {@link Tuple } of type {@link Tuple7 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + */ + public Tuple7OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6) { + super(Tuple7OfNullablesImpl.class, e0, e1, e2, e3, e4, e5, e6); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get0() { + return Optional.ofNullable((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get1() { + return Optional.ofNullable((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get2() { + return Optional.ofNullable((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get3() { + return Optional.ofNullable((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get4() { + return Optional.ofNullable((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get5() { + return Optional.ofNullable((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get6() { + return Optional.ofNullable((T6) values[6]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple8OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple8OfNullablesImpl.java new file mode 100644 index 0000000000..b04a0b0dcc --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple8OfNullablesImpl.java @@ -0,0 +1,112 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable; + +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple8; +import com.speedment.common.tuple.nullable.Tuple8OfNullables; +import java.util.Optional; + +/** + * An implementation class of a {@link Tuple8 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * + * @author Per Minborg + */ +public final class Tuple8OfNullablesImpl extends AbstractTupleOfNullables implements Tuple8OfNullables { + + /** + * Constructs a {@link Tuple } of type {@link Tuple8 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + */ + public Tuple8OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7) { + super(Tuple8OfNullablesImpl.class, e0, e1, e2, e3, e4, e5, e6, e7); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get0() { + return Optional.ofNullable((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get1() { + return Optional.ofNullable((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get2() { + return Optional.ofNullable((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get3() { + return Optional.ofNullable((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get4() { + return Optional.ofNullable((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get5() { + return Optional.ofNullable((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get6() { + return Optional.ofNullable((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get7() { + return Optional.ofNullable((T7) values[7]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple9OfNullablesImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple9OfNullablesImpl.java new file mode 100644 index 0000000000..3df7adae36 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/Tuple9OfNullablesImpl.java @@ -0,0 +1,121 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable; + +import com.speedment.common.tuple.TupleOfNullables; +import com.speedment.common.tuple.internal.AbstractTupleOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple9; +import com.speedment.common.tuple.nullable.Tuple9OfNullables; +import java.util.Optional; + +/** + * An implementation class of a {@link Tuple9 } + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * + * @author Per Minborg + */ +public final class Tuple9OfNullablesImpl extends AbstractTupleOfNullables implements Tuple9OfNullables { + + /** + * Constructs a {@link Tuple } of type {@link Tuple9 }. + * + * @param e0 element 0 + * @param e1 element 1 + * @param e2 element 2 + * @param e3 element 3 + * @param e4 element 4 + * @param e5 element 5 + * @param e6 element 6 + * @param e7 element 7 + * @param e8 element 8 + */ + public Tuple9OfNullablesImpl( + T0 e0, + T1 e1, + T2 e2, + T3 e3, + T4 e4, + T5 e5, + T6 e6, + T7 e7, + T8 e8) { + super(Tuple9OfNullablesImpl.class, e0, e1, e2, e3, e4, e5, e6, e7, e8); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get0() { + return Optional.ofNullable((T0) values[0]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get1() { + return Optional.ofNullable((T1) values[1]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get2() { + return Optional.ofNullable((T2) values[2]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get3() { + return Optional.ofNullable((T3) values[3]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get4() { + return Optional.ofNullable((T4) values[4]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get5() { + return Optional.ofNullable((T5) values[5]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get6() { + return Optional.ofNullable((T6) values[6]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get7() { + return Optional.ofNullable((T7) values[7]); + } + + @SuppressWarnings("unchecked") + @Override + public Optional get8() { + return Optional.ofNullable((T8) values[8]); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple0OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple0OfNullablesMapperImpl.java new file mode 100644 index 0000000000..159284c79c --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple0OfNullablesMapperImpl.java @@ -0,0 +1,63 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple0; +import com.speedment.common.tuple.nullable.Tuple0OfNullables; +import java.util.function.Function; + +/** + * An implementation class of a {@link TupleMapper } of degree 0 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * + * @author Per Minborg + */ +public final class Tuple0OfNullablesMapperImpl implements TupleMapper { + + public final static Tuple0OfNullablesMapperImpl EMPTY_MAPPER = new Tuple0OfNullablesMapperImpl<>(); + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple0 }. + */ + private Tuple0OfNullablesMapperImpl() { + + } + + @Override + public Tuple0OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + + ); + } + + @Override + public int degree() { + return 0; + } + + @Override + public Function get(int index) { + switch(index){ + + default : throw new IndexOutOfBoundsException(); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple10OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple10OfNullablesMapperImpl.java new file mode 100644 index 0000000000..67587b0c2b --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple10OfNullablesMapperImpl.java @@ -0,0 +1,171 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple10; +import com.speedment.common.tuple.nullable.Tuple10OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 10 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * + * @author Per Minborg + */ +public final class Tuple10OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple10 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + */ + public Tuple10OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + } + + @Override + public Tuple10OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t) + ); + } + + @Override + public int degree() { + return 10; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple11OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple11OfNullablesMapperImpl.java new file mode 100644 index 0000000000..537f296b0c --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple11OfNullablesMapperImpl.java @@ -0,0 +1,182 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple11; +import com.speedment.common.tuple.nullable.Tuple11OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 11 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * + * @author Per Minborg + */ +public final class Tuple11OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple11 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + */ + public Tuple11OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + } + + @Override + public Tuple11OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t) + ); + } + + @Override + public int degree() { + return 11; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple12OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple12OfNullablesMapperImpl.java new file mode 100644 index 0000000000..140069ed38 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple12OfNullablesMapperImpl.java @@ -0,0 +1,193 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple12; +import com.speedment.common.tuple.nullable.Tuple12OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 12 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * + * @author Per Minborg + */ +public final class Tuple12OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple12 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + */ + public Tuple12OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + } + + @Override + public Tuple12OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t) + ); + } + + @Override + public int degree() { + return 12; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple13OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple13OfNullablesMapperImpl.java new file mode 100644 index 0000000000..47db08d917 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple13OfNullablesMapperImpl.java @@ -0,0 +1,204 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple13; +import com.speedment.common.tuple.nullable.Tuple13OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 13 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * + * @author Per Minborg + */ +public final class Tuple13OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple13 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + */ + public Tuple13OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + } + + @Override + public Tuple13OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t) + ); + } + + @Override + public int degree() { + return 13; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple14OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple14OfNullablesMapperImpl.java new file mode 100644 index 0000000000..339f9b5b71 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple14OfNullablesMapperImpl.java @@ -0,0 +1,215 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple14; +import com.speedment.common.tuple.nullable.Tuple14OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 14 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * + * @author Per Minborg + */ +public final class Tuple14OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple14 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + */ + public Tuple14OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + } + + @Override + public Tuple14OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t) + ); + } + + @Override + public int degree() { + return 14; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple15OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple15OfNullablesMapperImpl.java new file mode 100644 index 0000000000..0716257dad --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple15OfNullablesMapperImpl.java @@ -0,0 +1,226 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple15; +import com.speedment.common.tuple.nullable.Tuple15OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 15 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * + * @author Per Minborg + */ +public final class Tuple15OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple15 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + */ + public Tuple15OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + } + + @Override + public Tuple15OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t) + ); + } + + @Override + public int degree() { + return 15; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple16OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple16OfNullablesMapperImpl.java new file mode 100644 index 0000000000..236a3b833c --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple16OfNullablesMapperImpl.java @@ -0,0 +1,237 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple16; +import com.speedment.common.tuple.nullable.Tuple16OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 16 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * + * @author Per Minborg + */ +public final class Tuple16OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + private final Function m15; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple16 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + * @param m15 mapper to apply for element 15 + */ + public Tuple16OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + this.m15 = requireNonNull(m15); + } + + @Override + public Tuple16OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t), + m15.apply(t) + ); + } + + @Override + public int degree() { + return 16; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } + + public Function get15() { + return m15; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple17OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple17OfNullablesMapperImpl.java new file mode 100644 index 0000000000..962087635a --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple17OfNullablesMapperImpl.java @@ -0,0 +1,248 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple17; +import com.speedment.common.tuple.nullable.Tuple17OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 17 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * + * @author Per Minborg + */ +public final class Tuple17OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + private final Function m15; + private final Function m16; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple17 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + * @param m15 mapper to apply for element 15 + * @param m16 mapper to apply for element 16 + */ + public Tuple17OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + this.m15 = requireNonNull(m15); + this.m16 = requireNonNull(m16); + } + + @Override + public Tuple17OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t), + m15.apply(t), + m16.apply(t) + ); + } + + @Override + public int degree() { + return 17; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } + + public Function get15() { + return m15; + } + + public Function get16() { + return m16; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple18OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple18OfNullablesMapperImpl.java new file mode 100644 index 0000000000..be873045b0 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple18OfNullablesMapperImpl.java @@ -0,0 +1,259 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple18; +import com.speedment.common.tuple.nullable.Tuple18OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 18 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * + * @author Per Minborg + */ +public final class Tuple18OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + private final Function m15; + private final Function m16; + private final Function m17; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple18 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + * @param m15 mapper to apply for element 15 + * @param m16 mapper to apply for element 16 + * @param m17 mapper to apply for element 17 + */ + public Tuple18OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + this.m15 = requireNonNull(m15); + this.m16 = requireNonNull(m16); + this.m17 = requireNonNull(m17); + } + + @Override + public Tuple18OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t), + m15.apply(t), + m16.apply(t), + m17.apply(t) + ); + } + + @Override + public int degree() { + return 18; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } + + public Function get15() { + return m15; + } + + public Function get16() { + return m16; + } + + public Function get17() { + return m17; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple19OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple19OfNullablesMapperImpl.java new file mode 100644 index 0000000000..4a46837682 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple19OfNullablesMapperImpl.java @@ -0,0 +1,270 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple19; +import com.speedment.common.tuple.nullable.Tuple19OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 19 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * + * @author Per Minborg + */ +public final class Tuple19OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + private final Function m15; + private final Function m16; + private final Function m17; + private final Function m18; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple19 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + * @param m15 mapper to apply for element 15 + * @param m16 mapper to apply for element 16 + * @param m17 mapper to apply for element 17 + * @param m18 mapper to apply for element 18 + */ + public Tuple19OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + this.m15 = requireNonNull(m15); + this.m16 = requireNonNull(m16); + this.m17 = requireNonNull(m17); + this.m18 = requireNonNull(m18); + } + + @Override + public Tuple19OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t), + m15.apply(t), + m16.apply(t), + m17.apply(t), + m18.apply(t) + ); + } + + @Override + public int degree() { + return 19; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + case 18 : return get18(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } + + public Function get15() { + return m15; + } + + public Function get16() { + return m16; + } + + public Function get17() { + return m17; + } + + public Function get18() { + return m18; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple1OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple1OfNullablesMapperImpl.java new file mode 100644 index 0000000000..cd542fa164 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple1OfNullablesMapperImpl.java @@ -0,0 +1,71 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple1; +import com.speedment.common.tuple.nullable.Tuple1OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 1 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * + * @author Per Minborg + */ +public final class Tuple1OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple1 }. + * + * @param m0 mapper to apply for element 0 + */ + public Tuple1OfNullablesMapperImpl(Function m0) { + this.m0 = requireNonNull(m0); + } + + @Override + public Tuple1OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t) + ); + } + + @Override + public int degree() { + return 1; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple20OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple20OfNullablesMapperImpl.java new file mode 100644 index 0000000000..defdc7f402 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple20OfNullablesMapperImpl.java @@ -0,0 +1,281 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple20; +import com.speedment.common.tuple.nullable.Tuple20OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 20 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * + * @author Per Minborg + */ +public final class Tuple20OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + private final Function m15; + private final Function m16; + private final Function m17; + private final Function m18; + private final Function m19; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple20 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + * @param m15 mapper to apply for element 15 + * @param m16 mapper to apply for element 16 + * @param m17 mapper to apply for element 17 + * @param m18 mapper to apply for element 18 + * @param m19 mapper to apply for element 19 + */ + public Tuple20OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18, + Function m19) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + this.m15 = requireNonNull(m15); + this.m16 = requireNonNull(m16); + this.m17 = requireNonNull(m17); + this.m18 = requireNonNull(m18); + this.m19 = requireNonNull(m19); + } + + @Override + public Tuple20OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t), + m15.apply(t), + m16.apply(t), + m17.apply(t), + m18.apply(t), + m19.apply(t) + ); + } + + @Override + public int degree() { + return 20; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + case 18 : return get18(); + case 19 : return get19(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } + + public Function get15() { + return m15; + } + + public Function get16() { + return m16; + } + + public Function get17() { + return m17; + } + + public Function get18() { + return m18; + } + + public Function get19() { + return m19; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple21OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple21OfNullablesMapperImpl.java new file mode 100644 index 0000000000..0ee49d1873 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple21OfNullablesMapperImpl.java @@ -0,0 +1,292 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple21; +import com.speedment.common.tuple.nullable.Tuple21OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 21 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * + * @author Per Minborg + */ +public final class Tuple21OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + private final Function m15; + private final Function m16; + private final Function m17; + private final Function m18; + private final Function m19; + private final Function m20; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple21 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + * @param m15 mapper to apply for element 15 + * @param m16 mapper to apply for element 16 + * @param m17 mapper to apply for element 17 + * @param m18 mapper to apply for element 18 + * @param m19 mapper to apply for element 19 + * @param m20 mapper to apply for element 20 + */ + public Tuple21OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18, + Function m19, + Function m20) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + this.m15 = requireNonNull(m15); + this.m16 = requireNonNull(m16); + this.m17 = requireNonNull(m17); + this.m18 = requireNonNull(m18); + this.m19 = requireNonNull(m19); + this.m20 = requireNonNull(m20); + } + + @Override + public Tuple21OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t), + m15.apply(t), + m16.apply(t), + m17.apply(t), + m18.apply(t), + m19.apply(t), + m20.apply(t) + ); + } + + @Override + public int degree() { + return 21; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + case 18 : return get18(); + case 19 : return get19(); + case 20 : return get20(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } + + public Function get15() { + return m15; + } + + public Function get16() { + return m16; + } + + public Function get17() { + return m17; + } + + public Function get18() { + return m18; + } + + public Function get19() { + return m19; + } + + public Function get20() { + return m20; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple22OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple22OfNullablesMapperImpl.java new file mode 100644 index 0000000000..cbaaf2a5d8 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple22OfNullablesMapperImpl.java @@ -0,0 +1,303 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple22; +import com.speedment.common.tuple.nullable.Tuple22OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 22 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param type of element 21 + * + * @author Per Minborg + */ +public final class Tuple22OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + private final Function m15; + private final Function m16; + private final Function m17; + private final Function m18; + private final Function m19; + private final Function m20; + private final Function m21; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple22 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + * @param m15 mapper to apply for element 15 + * @param m16 mapper to apply for element 16 + * @param m17 mapper to apply for element 17 + * @param m18 mapper to apply for element 18 + * @param m19 mapper to apply for element 19 + * @param m20 mapper to apply for element 20 + * @param m21 mapper to apply for element 21 + */ + public Tuple22OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18, + Function m19, + Function m20, + Function m21) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + this.m15 = requireNonNull(m15); + this.m16 = requireNonNull(m16); + this.m17 = requireNonNull(m17); + this.m18 = requireNonNull(m18); + this.m19 = requireNonNull(m19); + this.m20 = requireNonNull(m20); + this.m21 = requireNonNull(m21); + } + + @Override + public Tuple22OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t), + m15.apply(t), + m16.apply(t), + m17.apply(t), + m18.apply(t), + m19.apply(t), + m20.apply(t), + m21.apply(t) + ); + } + + @Override + public int degree() { + return 22; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + case 18 : return get18(); + case 19 : return get19(); + case 20 : return get20(); + case 21 : return get21(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } + + public Function get15() { + return m15; + } + + public Function get16() { + return m16; + } + + public Function get17() { + return m17; + } + + public Function get18() { + return m18; + } + + public Function get19() { + return m19; + } + + public Function get20() { + return m20; + } + + public Function get21() { + return m21; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple23OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple23OfNullablesMapperImpl.java new file mode 100644 index 0000000000..e1578bb4af --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple23OfNullablesMapperImpl.java @@ -0,0 +1,314 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple23; +import com.speedment.common.tuple.nullable.Tuple23OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 23 + * + * @param Type of the original object for the mapper to use when creating + * a {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param type of element 21 + * @param type of element 22 + * + * @author Per Minborg + */ +public final class Tuple23OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + private final Function m9; + private final Function m10; + private final Function m11; + private final Function m12; + private final Function m13; + private final Function m14; + private final Function m15; + private final Function m16; + private final Function m17; + private final Function m18; + private final Function m19; + private final Function m20; + private final Function m21; + private final Function m22; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple23 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + * @param m9 mapper to apply for element 9 + * @param m10 mapper to apply for element 10 + * @param m11 mapper to apply for element 11 + * @param m12 mapper to apply for element 12 + * @param m13 mapper to apply for element 13 + * @param m14 mapper to apply for element 14 + * @param m15 mapper to apply for element 15 + * @param m16 mapper to apply for element 16 + * @param m17 mapper to apply for element 17 + * @param m18 mapper to apply for element 18 + * @param m19 mapper to apply for element 19 + * @param m20 mapper to apply for element 20 + * @param m21 mapper to apply for element 21 + * @param m22 mapper to apply for element 22 + */ + public Tuple23OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8, + Function m9, + Function m10, + Function m11, + Function m12, + Function m13, + Function m14, + Function m15, + Function m16, + Function m17, + Function m18, + Function m19, + Function m20, + Function m21, + Function m22) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + this.m9 = requireNonNull(m9); + this.m10 = requireNonNull(m10); + this.m11 = requireNonNull(m11); + this.m12 = requireNonNull(m12); + this.m13 = requireNonNull(m13); + this.m14 = requireNonNull(m14); + this.m15 = requireNonNull(m15); + this.m16 = requireNonNull(m16); + this.m17 = requireNonNull(m17); + this.m18 = requireNonNull(m18); + this.m19 = requireNonNull(m19); + this.m20 = requireNonNull(m20); + this.m21 = requireNonNull(m21); + this.m22 = requireNonNull(m22); + } + + @Override + public Tuple23OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t), + m9.apply(t), + m10.apply(t), + m11.apply(t), + m12.apply(t), + m13.apply(t), + m14.apply(t), + m15.apply(t), + m16.apply(t), + m17.apply(t), + m18.apply(t), + m19.apply(t), + m20.apply(t), + m21.apply(t), + m22.apply(t) + ); + } + + @Override + public int degree() { + return 23; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + case 18 : return get18(); + case 19 : return get19(); + case 20 : return get20(); + case 21 : return get21(); + case 22 : return get22(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } + + public Function get9() { + return m9; + } + + public Function get10() { + return m10; + } + + public Function get11() { + return m11; + } + + public Function get12() { + return m12; + } + + public Function get13() { + return m13; + } + + public Function get14() { + return m14; + } + + public Function get15() { + return m15; + } + + public Function get16() { + return m16; + } + + public Function get17() { + return m17; + } + + public Function get18() { + return m18; + } + + public Function get19() { + return m19; + } + + public Function get20() { + return m20; + } + + public Function get21() { + return m21; + } + + public Function get22() { + return m22; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple2OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple2OfNullablesMapperImpl.java new file mode 100644 index 0000000000..13a3c294ab --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple2OfNullablesMapperImpl.java @@ -0,0 +1,81 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple2; +import com.speedment.common.tuple.nullable.Tuple2OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 2 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * + * @author Per Minborg + */ +public final class Tuple2OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple2 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + */ + public Tuple2OfNullablesMapperImpl(Function m0, Function m1) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + } + + @Override + public Tuple2OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t) + ); + } + + @Override + public int degree() { + return 2; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple3OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple3OfNullablesMapperImpl.java new file mode 100644 index 0000000000..f3f8f5d776 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple3OfNullablesMapperImpl.java @@ -0,0 +1,91 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple3; +import com.speedment.common.tuple.nullable.Tuple3OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 3 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * + * @author Per Minborg + */ +public final class Tuple3OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple3 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + */ + public Tuple3OfNullablesMapperImpl(Function m0, Function m1, Function m2) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + } + + @Override + public Tuple3OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t) + ); + } + + @Override + public int degree() { + return 3; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple4OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple4OfNullablesMapperImpl.java new file mode 100644 index 0000000000..0d319fa020 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple4OfNullablesMapperImpl.java @@ -0,0 +1,105 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple4; +import com.speedment.common.tuple.nullable.Tuple4OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 4 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * + * @author Per Minborg + */ +public final class Tuple4OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple4 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + */ + public Tuple4OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + } + + @Override + public Tuple4OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t) + ); + } + + @Override + public int degree() { + return 4; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple5OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple5OfNullablesMapperImpl.java new file mode 100644 index 0000000000..603051f0a0 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple5OfNullablesMapperImpl.java @@ -0,0 +1,116 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple5; +import com.speedment.common.tuple.nullable.Tuple5OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 5 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * + * @author Per Minborg + */ +public final class Tuple5OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple5 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + */ + public Tuple5OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + } + + @Override + public Tuple5OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t) + ); + } + + @Override + public int degree() { + return 5; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple6OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple6OfNullablesMapperImpl.java new file mode 100644 index 0000000000..19116e7737 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple6OfNullablesMapperImpl.java @@ -0,0 +1,127 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple6; +import com.speedment.common.tuple.nullable.Tuple6OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 6 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * + * @author Per Minborg + */ +public final class Tuple6OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple6 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + */ + public Tuple6OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + } + + @Override + public Tuple6OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t) + ); + } + + @Override + public int degree() { + return 6; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple7OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple7OfNullablesMapperImpl.java new file mode 100644 index 0000000000..25fe7858f1 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple7OfNullablesMapperImpl.java @@ -0,0 +1,138 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple7; +import com.speedment.common.tuple.nullable.Tuple7OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 7 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * + * @author Per Minborg + */ +public final class Tuple7OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple7 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + */ + public Tuple7OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + } + + @Override + public Tuple7OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t) + ); + } + + @Override + public int degree() { + return 7; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple8OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple8OfNullablesMapperImpl.java new file mode 100644 index 0000000000..be3a9c19b5 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple8OfNullablesMapperImpl.java @@ -0,0 +1,149 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple8; +import com.speedment.common.tuple.nullable.Tuple8OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 8 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * + * @author Per Minborg + */ +public final class Tuple8OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple8 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + */ + public Tuple8OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + } + + @Override + public Tuple8OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t) + ); + } + + @Override + public int degree() { + return 8; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple9OfNullablesMapperImpl.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple9OfNullablesMapperImpl.java new file mode 100644 index 0000000000..f2ee128464 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/internal/nullable/mapper/Tuple9OfNullablesMapperImpl.java @@ -0,0 +1,160 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nullable.mapper; + +import com.speedment.common.tuple.TupleMapper; +import com.speedment.common.tuple.TuplesOfNullables; +import com.speedment.common.tuple.nonnullable.Tuple9; +import com.speedment.common.tuple.nullable.Tuple9OfNullables; +import java.util.function.Function; +import static java.util.Objects.requireNonNull; + +/** + * An implementation class of a {@link TupleMapper } of degree 9 + * + * @param Type of the original object for the mapper to use when creating a + * {@code Tuple } + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * + * @author Per Minborg + */ +public final class Tuple9OfNullablesMapperImpl implements TupleMapper> { + + private final Function m0; + private final Function m1; + private final Function m2; + private final Function m3; + private final Function m4; + private final Function m5; + private final Function m6; + private final Function m7; + private final Function m8; + + /** + * Constructs a {@link TupleMapper } that can create {@link Tuple9 }. + * + * @param m0 mapper to apply for element 0 + * @param m1 mapper to apply for element 1 + * @param m2 mapper to apply for element 2 + * @param m3 mapper to apply for element 3 + * @param m4 mapper to apply for element 4 + * @param m5 mapper to apply for element 5 + * @param m6 mapper to apply for element 6 + * @param m7 mapper to apply for element 7 + * @param m8 mapper to apply for element 8 + */ + public Tuple9OfNullablesMapperImpl( + Function m0, + Function m1, + Function m2, + Function m3, + Function m4, + Function m5, + Function m6, + Function m7, + Function m8) { + this.m0 = requireNonNull(m0); + this.m1 = requireNonNull(m1); + this.m2 = requireNonNull(m2); + this.m3 = requireNonNull(m3); + this.m4 = requireNonNull(m4); + this.m5 = requireNonNull(m5); + this.m6 = requireNonNull(m6); + this.m7 = requireNonNull(m7); + this.m8 = requireNonNull(m8); + } + + @Override + public Tuple9OfNullables apply(T t) { + return TuplesOfNullables.ofNullables( + m0.apply(t), + m1.apply(t), + m2.apply(t), + m3.apply(t), + m4.apply(t), + m5.apply(t), + m6.apply(t), + m7.apply(t), + m8.apply(t) + ); + } + + @Override + public int degree() { + return 9; + } + + @Override + public Function get(int index) { + switch(index){ + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + default : throw new IndexOutOfBoundsException(); + } + } + + public Function get0() { + return m0; + } + + public Function get1() { + return m1; + } + + public Function get2() { + return m2; + } + + public Function get3() { + return m3; + } + + public Function get4() { + return m4; + } + + public Function get5() { + return m5; + } + + public Function get6() { + return m6; + } + + public Function get7() { + return m7; + } + + public Function get8() { + return m8; + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple0.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple0.java similarity index 54% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple0.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple0.java index 5600c47210..93fe889769 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple0.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple0.java @@ -1,46 +1,43 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple; +package com.speedment.common.tuple.nonnullable; -import java.util.stream.Stream; +import com.speedment.common.tuple.Tuple; /** - * {@inheritDoc} + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 0 * - * This {@link Tuple} with no elements. - * - * @author pemi + * @author Per Minborg */ public interface Tuple0 extends Tuple { - + @Override - default Stream stream() { - return Stream.empty(); - } - - @Override - default int length() { + default int degree() { return 0; } - - @Override + default Object get(int index) { - throw new IllegalArgumentException(String.format( - "Index %d is outside bounds of tuple of length %s", index, length() - )); + switch (index) { + + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } } } \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple1.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple1.java similarity index 54% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple1.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple1.java index ac2e4d59f4..6af9adb760 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple1.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple1.java @@ -1,52 +1,46 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple; +package com.speedment.common.tuple.nonnullable; -import java.util.stream.Stream; +import com.speedment.common.tuple.Tuple; /** - * {@inheritDoc} + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 1 * - * This {@link Tuple} holds one non-null element. - * - * @author pemi - * @param Type of 0:th argument + * @param type of element 0 + * + * @author Per Minborg */ public interface Tuple1 extends Tuple { - + T0 get0(); @Override - default Stream stream() { - return Stream.of(get0()); - } - - @Override - default int length() { + default int degree() { return 1; } - - @Override + default Object get(int index) { - if (index == 0) { - return get0(); - } else { - throw new IllegalArgumentException(String.format( - "Index %d is outside bounds of tuple of length %s", index, length() + switch (index) { + case 0 : return get0(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() )); } } diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple10.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple10.java new file mode 100644 index 0000000000..1a787acc29 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple10.java @@ -0,0 +1,83 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nonnullable; + +import com.speedment.common.tuple.Tuple; + +/** + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 10 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * + * @author Per Minborg + */ +public interface Tuple10 extends Tuple { + + T0 get0(); + + T1 get1(); + + T2 get2(); + + T3 get3(); + + T4 get4(); + + T5 get5(); + + T6 get6(); + + T7 get7(); + + T8 get8(); + + T9 get9(); + + @Override + default int degree() { + return 10; + } + + default Object get(int index) { + switch (index) { + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple11.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple11.java new file mode 100644 index 0000000000..fdcf6a1fee --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple11.java @@ -0,0 +1,87 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nonnullable; + +import com.speedment.common.tuple.Tuple; + +/** + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 11 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * + * @author Per Minborg + */ +public interface Tuple11 extends Tuple { + + T0 get0(); + + T1 get1(); + + T2 get2(); + + T3 get3(); + + T4 get4(); + + T5 get5(); + + T6 get6(); + + T7 get7(); + + T8 get8(); + + T9 get9(); + + T10 get10(); + + @Override + default int degree() { + return 11; + } + + default Object get(int index) { + switch (index) { + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple12.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple12.java new file mode 100644 index 0000000000..40a517e95f --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple12.java @@ -0,0 +1,91 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nonnullable; + +import com.speedment.common.tuple.Tuple; + +/** + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 12 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * + * @author Per Minborg + */ +public interface Tuple12 extends Tuple { + + T0 get0(); + + T1 get1(); + + T2 get2(); + + T3 get3(); + + T4 get4(); + + T5 get5(); + + T6 get6(); + + T7 get7(); + + T8 get8(); + + T9 get9(); + + T10 get10(); + + T11 get11(); + + @Override + default int degree() { + return 12; + } + + default Object get(int index) { + switch (index) { + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple13.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple13.java new file mode 100644 index 0000000000..dd60add65a --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple13.java @@ -0,0 +1,95 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nonnullable; + +import com.speedment.common.tuple.Tuple; + +/** + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 13 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * + * @author Per Minborg + */ +public interface Tuple13 extends Tuple { + + T0 get0(); + + T1 get1(); + + T2 get2(); + + T3 get3(); + + T4 get4(); + + T5 get5(); + + T6 get6(); + + T7 get7(); + + T8 get8(); + + T9 get9(); + + T10 get10(); + + T11 get11(); + + T12 get12(); + + @Override + default int degree() { + return 13; + } + + default Object get(int index) { + switch (index) { + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple14.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple14.java new file mode 100644 index 0000000000..524bb4a6ae --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple14.java @@ -0,0 +1,99 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nonnullable; + +import com.speedment.common.tuple.Tuple; + +/** + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 14 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * + * @author Per Minborg + */ +public interface Tuple14 extends Tuple { + + T0 get0(); + + T1 get1(); + + T2 get2(); + + T3 get3(); + + T4 get4(); + + T5 get5(); + + T6 get6(); + + T7 get7(); + + T8 get8(); + + T9 get9(); + + T10 get10(); + + T11 get11(); + + T12 get12(); + + T13 get13(); + + @Override + default int degree() { + return 14; + } + + default Object get(int index) { + switch (index) { + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple15.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple15.java new file mode 100644 index 0000000000..de2b62e81a --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple15.java @@ -0,0 +1,103 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nonnullable; + +import com.speedment.common.tuple.Tuple; + +/** + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 15 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * + * @author Per Minborg + */ +public interface Tuple15 extends Tuple { + + T0 get0(); + + T1 get1(); + + T2 get2(); + + T3 get3(); + + T4 get4(); + + T5 get5(); + + T6 get6(); + + T7 get7(); + + T8 get8(); + + T9 get9(); + + T10 get10(); + + T11 get11(); + + T12 get12(); + + T13 get13(); + + T14 get14(); + + @Override + default int degree() { + return 15; + } + + default Object get(int index) { + switch (index) { + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple16.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple16.java new file mode 100644 index 0000000000..1a3d8a323e --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple16.java @@ -0,0 +1,107 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nonnullable; + +import com.speedment.common.tuple.Tuple; + +/** + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 16 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * + * @author Per Minborg + */ +public interface Tuple16 extends Tuple { + + T0 get0(); + + T1 get1(); + + T2 get2(); + + T3 get3(); + + T4 get4(); + + T5 get5(); + + T6 get6(); + + T7 get7(); + + T8 get8(); + + T9 get9(); + + T10 get10(); + + T11 get11(); + + T12 get12(); + + T13 get13(); + + T14 get14(); + + T15 get15(); + + @Override + default int degree() { + return 16; + } + + default Object get(int index) { + switch (index) { + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple17.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple17.java new file mode 100644 index 0000000000..ef47219c0f --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple17.java @@ -0,0 +1,111 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nonnullable; + +import com.speedment.common.tuple.Tuple; + +/** + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 17 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * + * @author Per Minborg + */ +public interface Tuple17 extends Tuple { + + T0 get0(); + + T1 get1(); + + T2 get2(); + + T3 get3(); + + T4 get4(); + + T5 get5(); + + T6 get6(); + + T7 get7(); + + T8 get8(); + + T9 get9(); + + T10 get10(); + + T11 get11(); + + T12 get12(); + + T13 get13(); + + T14 get14(); + + T15 get15(); + + T16 get16(); + + @Override + default int degree() { + return 17; + } + + default Object get(int index) { + switch (index) { + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple18.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple18.java new file mode 100644 index 0000000000..80253ce6cf --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple18.java @@ -0,0 +1,115 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nonnullable; + +import com.speedment.common.tuple.Tuple; + +/** + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 18 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * + * @author Per Minborg + */ +public interface Tuple18 extends Tuple { + + T0 get0(); + + T1 get1(); + + T2 get2(); + + T3 get3(); + + T4 get4(); + + T5 get5(); + + T6 get6(); + + T7 get7(); + + T8 get8(); + + T9 get9(); + + T10 get10(); + + T11 get11(); + + T12 get12(); + + T13 get13(); + + T14 get14(); + + T15 get15(); + + T16 get16(); + + T17 get17(); + + @Override + default int degree() { + return 18; + } + + default Object get(int index) { + switch (index) { + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple19.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple19.java new file mode 100644 index 0000000000..b2e3075900 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple19.java @@ -0,0 +1,119 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nonnullable; + +import com.speedment.common.tuple.Tuple; + +/** + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 19 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * + * @author Per Minborg + */ +public interface Tuple19 extends Tuple { + + T0 get0(); + + T1 get1(); + + T2 get2(); + + T3 get3(); + + T4 get4(); + + T5 get5(); + + T6 get6(); + + T7 get7(); + + T8 get8(); + + T9 get9(); + + T10 get10(); + + T11 get11(); + + T12 get12(); + + T13 get13(); + + T14 get14(); + + T15 get15(); + + T16 get16(); + + T17 get17(); + + T18 get18(); + + @Override + default int degree() { + return 19; + } + + default Object get(int index) { + switch (index) { + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + case 18 : return get18(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple2.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple2.java similarity index 63% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple2.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple2.java index dfdade77d9..fc3412cc7d 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple2.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple2.java @@ -1,55 +1,50 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple; +package com.speedment.common.tuple.nonnullable; -import java.util.stream.Stream; +import com.speedment.common.tuple.Tuple; /** - * {@inheritDoc} - * - * This {@link Tuple} holds two non-null elements. - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 2 + * + * @param type of element 0 + * @param type of element 1 + * + * @author Per Minborg */ public interface Tuple2 extends Tuple { - + T0 get0(); - - T1 get1(); - @Override - default Stream stream() { - return Stream.of(get0(), get1()); - } + T1 get1(); @Override - default int length() { + default int degree() { return 2; } - - @Override + default Object get(int index) { switch (index) { case 0 : return get0(); case 1 : return get1(); - default : throw new IllegalArgumentException(String.format( - "Index %d is outside bounds of tuple of length %s", index, length() + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() )); } } diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple20.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple20.java new file mode 100644 index 0000000000..ff35dac9f8 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple20.java @@ -0,0 +1,123 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nonnullable; + +import com.speedment.common.tuple.Tuple; + +/** + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 20 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * + * @author Per Minborg + */ +public interface Tuple20 extends Tuple { + + T0 get0(); + + T1 get1(); + + T2 get2(); + + T3 get3(); + + T4 get4(); + + T5 get5(); + + T6 get6(); + + T7 get7(); + + T8 get8(); + + T9 get9(); + + T10 get10(); + + T11 get11(); + + T12 get12(); + + T13 get13(); + + T14 get14(); + + T15 get15(); + + T16 get16(); + + T17 get17(); + + T18 get18(); + + T19 get19(); + + @Override + default int degree() { + return 20; + } + + default Object get(int index) { + switch (index) { + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + case 18 : return get18(); + case 19 : return get19(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple21.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple21.java new file mode 100644 index 0000000000..db786a7d5f --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple21.java @@ -0,0 +1,127 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nonnullable; + +import com.speedment.common.tuple.Tuple; + +/** + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 21 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * + * @author Per Minborg + */ +public interface Tuple21 extends Tuple { + + T0 get0(); + + T1 get1(); + + T2 get2(); + + T3 get3(); + + T4 get4(); + + T5 get5(); + + T6 get6(); + + T7 get7(); + + T8 get8(); + + T9 get9(); + + T10 get10(); + + T11 get11(); + + T12 get12(); + + T13 get13(); + + T14 get14(); + + T15 get15(); + + T16 get16(); + + T17 get17(); + + T18 get18(); + + T19 get19(); + + T20 get20(); + + @Override + default int degree() { + return 21; + } + + default Object get(int index) { + switch (index) { + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + case 18 : return get18(); + case 19 : return get19(); + case 20 : return get20(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple22.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple22.java new file mode 100644 index 0000000000..3943744a79 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple22.java @@ -0,0 +1,131 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nonnullable; + +import com.speedment.common.tuple.Tuple; + +/** + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 22 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param type of element 21 + * + * @author Per Minborg + */ +public interface Tuple22 extends Tuple { + + T0 get0(); + + T1 get1(); + + T2 get2(); + + T3 get3(); + + T4 get4(); + + T5 get5(); + + T6 get6(); + + T7 get7(); + + T8 get8(); + + T9 get9(); + + T10 get10(); + + T11 get11(); + + T12 get12(); + + T13 get13(); + + T14 get14(); + + T15 get15(); + + T16 get16(); + + T17 get17(); + + T18 get18(); + + T19 get19(); + + T20 get20(); + + T21 get21(); + + @Override + default int degree() { + return 22; + } + + default Object get(int index) { + switch (index) { + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + case 18 : return get18(); + case 19 : return get19(); + case 20 : return get20(); + case 21 : return get21(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple23.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple23.java new file mode 100644 index 0000000000..b90d6f1ba8 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple23.java @@ -0,0 +1,135 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nonnullable; + +import com.speedment.common.tuple.Tuple; + +/** + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 23 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param type of element 21 + * @param type of element 22 + * + * @author Per Minborg + */ +public interface Tuple23 extends Tuple { + + T0 get0(); + + T1 get1(); + + T2 get2(); + + T3 get3(); + + T4 get4(); + + T5 get5(); + + T6 get6(); + + T7 get7(); + + T8 get8(); + + T9 get9(); + + T10 get10(); + + T11 get11(); + + T12 get12(); + + T13 get13(); + + T14 get14(); + + T15 get15(); + + T16 get16(); + + T17 get17(); + + T18 get18(); + + T19 get19(); + + T20 get20(); + + T21 get21(); + + T22 get22(); + + @Override + default int degree() { + return 23; + } + + default Object get(int index) { + switch (index) { + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + case 9 : return get9(); + case 10 : return get10(); + case 11 : return get11(); + case 12 : return get12(); + case 13 : return get13(); + case 14 : return get14(); + case 15 : return get15(); + case 16 : return get16(); + case 17 : return get17(); + case 18 : return get18(); + case 19 : return get19(); + case 20 : return get20(); + case 21 : return get21(); + case 22 : return get22(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple3.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple3.java similarity index 62% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple3.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple3.java index 12fe1db01c..e5998be983 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple3.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple3.java @@ -1,59 +1,54 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple; +package com.speedment.common.tuple.nonnullable; -import java.util.stream.Stream; +import com.speedment.common.tuple.Tuple; /** - * {@inheritDoc} - * - * This {@link Tuple} holds three non-null elements. - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument - * @param Type of 2:nd argument + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 3 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * + * @author Per Minborg */ public interface Tuple3 extends Tuple { - + T0 get0(); - + T1 get1(); - - T2 get2(); - @Override - default Stream stream() { - return Stream.of(get0(), get1(), get2()); - } + T2 get2(); @Override - default int length() { + default int degree() { return 3; } - - @Override + default Object get(int index) { switch (index) { case 0 : return get0(); case 1 : return get1(); case 2 : return get2(); - default : throw new IllegalArgumentException(String.format( - "Index %d is outside bounds of tuple of length %s", index, length() + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() )); } } diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple4.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple4.java similarity index 62% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple4.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple4.java index 793f33f91a..bc5de33d2f 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple4.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple4.java @@ -1,63 +1,58 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple; +package com.speedment.common.tuple.nonnullable; -import java.util.stream.Stream; +import com.speedment.common.tuple.Tuple; /** - * {@inheritDoc} - * - * This {@link Tuple} holds four non-null elements. - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument - * @param Type of 2:nd argument - * @param Type of 3:rd argument + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 4 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * + * @author Per Minborg */ public interface Tuple4 extends Tuple { - + T0 get0(); - + T1 get1(); - + T2 get2(); T3 get3(); @Override - default Stream stream() { - return Stream.of(get0(), get1(), get2(), get3()); - } - - @Override - default int length() { + default int degree() { return 4; } - - @Override + default Object get(int index) { switch (index) { case 0 : return get0(); case 1 : return get1(); case 2 : return get2(); case 3 : return get3(); - default : throw new IllegalArgumentException(String.format( - "Index %d is outside bounds of tuple of length %s", index, length() + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() )); } } diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple5.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple5.java similarity index 63% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple5.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple5.java index 88415abaf5..1a68c3b5b0 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple5.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple5.java @@ -1,41 +1,43 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple; +package com.speedment.common.tuple.nonnullable; -import java.util.stream.Stream; +import com.speedment.common.tuple.Tuple; /** - * {@inheritDoc} - * - * This {@link Tuple} holds four non-null elements. - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument - * @param Type of 2:nd argument - * @param Type of 3:rd argument - * @param Type of 4:th argument + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 5 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * + * @author Per Minborg */ public interface Tuple5 extends Tuple { - + T0 get0(); - + T1 get1(); - + T2 get2(); T3 get3(); @@ -43,16 +45,10 @@ public interface Tuple5 extends Tuple { T4 get4(); @Override - default Stream stream() { - return Stream.of(get0(), get1(), get2(), get3(), get4()); - } - - @Override - default int length() { + default int degree() { return 5; } - - @Override + default Object get(int index) { switch (index) { case 0 : return get0(); @@ -60,8 +56,7 @@ default Object get(int index) { case 2 : return get2(); case 3 : return get3(); case 4 : return get4(); - default : throw new IllegalArgumentException(String.format( - "Index %d is outside bounds of tuple of length %s", index, length() + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() )); } } diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple6.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple6.java similarity index 62% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple6.java rename to common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple6.java index 6118afdcd3..66d874e598 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple6.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple6.java @@ -1,61 +1,57 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple; +package com.speedment.common.tuple.nonnullable; -import java.util.stream.Stream; +import com.speedment.common.tuple.Tuple; /** - * {@inheritDoc} - * - * This {@link Tuple} holds four non-null elements. - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument - * @param Type of 2:nd argument - * @param Type of 3:rd argument - * @param Type of 4:th argument - * @param Type of 5:th argument + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 6 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * + * @author Per Minborg */ public interface Tuple6 extends Tuple { - + T0 get0(); - + T1 get1(); - + T2 get2(); - + T3 get3(); - + T4 get4(); - - T5 get5(); - @Override - default Stream stream() { - return Stream.of(get0(), get1(), get2(), get3(), get4(), get5()); - } + T5 get5(); @Override - default int length() { + default int degree() { return 6; } - - @Override + default Object get(int index) { switch (index) { case 0 : return get0(); @@ -64,8 +60,7 @@ default Object get(int index) { case 3 : return get3(); case 4 : return get4(); case 5 : return get5(); - default : throw new IllegalArgumentException(String.format( - "Index %d is outside bounds of tuple of length %s", index, length() + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() )); } } diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple7.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple7.java new file mode 100644 index 0000000000..c6f04d62db --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple7.java @@ -0,0 +1,71 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nonnullable; + +import com.speedment.common.tuple.Tuple; + +/** + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 7 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * + * @author Per Minborg + */ +public interface Tuple7 extends Tuple { + + T0 get0(); + + T1 get1(); + + T2 get2(); + + T3 get3(); + + T4 get4(); + + T5 get5(); + + T6 get6(); + + @Override + default int degree() { + return 7; + } + + default Object get(int index) { + switch (index) { + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple8.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple8.java new file mode 100644 index 0000000000..42fb3306f3 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple8.java @@ -0,0 +1,75 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nonnullable; + +import com.speedment.common.tuple.Tuple; + +/** + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 8 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * + * @author Per Minborg + */ +public interface Tuple8 extends Tuple { + + T0 get0(); + + T1 get1(); + + T2 get2(); + + T3 get3(); + + T4 get4(); + + T5 get5(); + + T6 get6(); + + T7 get7(); + + @Override + default int degree() { + return 8; + } + + default Object get(int index) { + switch (index) { + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple9.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple9.java new file mode 100644 index 0000000000..c49a5f0e1b --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/Tuple9.java @@ -0,0 +1,79 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nonnullable; + +import com.speedment.common.tuple.Tuple; + +/** + * This interface defines a generic Tuple of any order that can hold null + * values. A Tuple is type safe, immutable and thread safe. For pure non-null + * value elements see {@link Tuple} + * This {@link Tuple } has a degree of 9 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * + * @author Per Minborg + */ +public interface Tuple9 extends Tuple { + + T0 get0(); + + T1 get1(); + + T2 get2(); + + T3 get3(); + + T4 get4(); + + T5 get5(); + + T6 get6(); + + T7 get7(); + + T8 get8(); + + @Override + default int degree() { + return 9; + } + + default Object get(int index) { + switch (index) { + case 0 : return get0(); + case 1 : return get1(); + case 2 : return get2(); + case 3 : return get3(); + case 4 : return get4(); + case 5 : return get5(); + case 6 : return get6(); + case 7 : return get7(); + case 8 : return get8(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/package-info.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/package-info.java new file mode 100644 index 0000000000..5897520053 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nonnullable/package-info.java @@ -0,0 +1,7 @@ +/** + * Tuples of various sizes are located in this package. + *

+ * This package is part of the API. Modifications to classes here should only + * (if ever) be done in major releases. + */ +package com.speedment.common.tuple; diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple0OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple0OfNullables.java new file mode 100644 index 0000000000..58cbbfb367 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple0OfNullables.java @@ -0,0 +1,48 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 0 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 0 + * + * @author Per Minborg + */ +public interface Tuple0OfNullables extends TupleOfNullables { + + @Override + default int degree() { + return 0; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple10OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple10OfNullables.java new file mode 100644 index 0000000000..dd9030b5d4 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple10OfNullables.java @@ -0,0 +1,88 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 10 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 10 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * + * @author Per Minborg + */ +public interface Tuple10OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + Optional get6(); + + Optional get7(); + + Optional get8(); + + Optional get9(); + + @Override + default int degree() { + return 10; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + case 6 : return (Optional)get6(); + case 7 : return (Optional)get7(); + case 8 : return (Optional)get8(); + case 9 : return (Optional)get9(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple11OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple11OfNullables.java new file mode 100644 index 0000000000..400df1e8b4 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple11OfNullables.java @@ -0,0 +1,92 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 11 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 11 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * + * @author Per Minborg + */ +public interface Tuple11OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + Optional get6(); + + Optional get7(); + + Optional get8(); + + Optional get9(); + + Optional get10(); + + @Override + default int degree() { + return 11; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + case 6 : return (Optional)get6(); + case 7 : return (Optional)get7(); + case 8 : return (Optional)get8(); + case 9 : return (Optional)get9(); + case 10 : return (Optional)get10(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple12OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple12OfNullables.java new file mode 100644 index 0000000000..6987cacbbd --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple12OfNullables.java @@ -0,0 +1,96 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 12 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 12 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * + * @author Per Minborg + */ +public interface Tuple12OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + Optional get6(); + + Optional get7(); + + Optional get8(); + + Optional get9(); + + Optional get10(); + + Optional get11(); + + @Override + default int degree() { + return 12; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + case 6 : return (Optional)get6(); + case 7 : return (Optional)get7(); + case 8 : return (Optional)get8(); + case 9 : return (Optional)get9(); + case 10 : return (Optional)get10(); + case 11 : return (Optional)get11(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple13OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple13OfNullables.java new file mode 100644 index 0000000000..4593d5d27c --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple13OfNullables.java @@ -0,0 +1,100 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 13 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 13 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * + * @author Per Minborg + */ +public interface Tuple13OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + Optional get6(); + + Optional get7(); + + Optional get8(); + + Optional get9(); + + Optional get10(); + + Optional get11(); + + Optional get12(); + + @Override + default int degree() { + return 13; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + case 6 : return (Optional)get6(); + case 7 : return (Optional)get7(); + case 8 : return (Optional)get8(); + case 9 : return (Optional)get9(); + case 10 : return (Optional)get10(); + case 11 : return (Optional)get11(); + case 12 : return (Optional)get12(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple14OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple14OfNullables.java new file mode 100644 index 0000000000..221c761d13 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple14OfNullables.java @@ -0,0 +1,104 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 14 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 14 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * + * @author Per Minborg + */ +public interface Tuple14OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + Optional get6(); + + Optional get7(); + + Optional get8(); + + Optional get9(); + + Optional get10(); + + Optional get11(); + + Optional get12(); + + Optional get13(); + + @Override + default int degree() { + return 14; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + case 6 : return (Optional)get6(); + case 7 : return (Optional)get7(); + case 8 : return (Optional)get8(); + case 9 : return (Optional)get9(); + case 10 : return (Optional)get10(); + case 11 : return (Optional)get11(); + case 12 : return (Optional)get12(); + case 13 : return (Optional)get13(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple15OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple15OfNullables.java new file mode 100644 index 0000000000..f85e20268e --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple15OfNullables.java @@ -0,0 +1,108 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 15 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 15 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * + * @author Per Minborg + */ +public interface Tuple15OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + Optional get6(); + + Optional get7(); + + Optional get8(); + + Optional get9(); + + Optional get10(); + + Optional get11(); + + Optional get12(); + + Optional get13(); + + Optional get14(); + + @Override + default int degree() { + return 15; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + case 6 : return (Optional)get6(); + case 7 : return (Optional)get7(); + case 8 : return (Optional)get8(); + case 9 : return (Optional)get9(); + case 10 : return (Optional)get10(); + case 11 : return (Optional)get11(); + case 12 : return (Optional)get12(); + case 13 : return (Optional)get13(); + case 14 : return (Optional)get14(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple16OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple16OfNullables.java new file mode 100644 index 0000000000..d28a9587f3 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple16OfNullables.java @@ -0,0 +1,112 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 16 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 16 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * + * @author Per Minborg + */ +public interface Tuple16OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + Optional get6(); + + Optional get7(); + + Optional get8(); + + Optional get9(); + + Optional get10(); + + Optional get11(); + + Optional get12(); + + Optional get13(); + + Optional get14(); + + Optional get15(); + + @Override + default int degree() { + return 16; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + case 6 : return (Optional)get6(); + case 7 : return (Optional)get7(); + case 8 : return (Optional)get8(); + case 9 : return (Optional)get9(); + case 10 : return (Optional)get10(); + case 11 : return (Optional)get11(); + case 12 : return (Optional)get12(); + case 13 : return (Optional)get13(); + case 14 : return (Optional)get14(); + case 15 : return (Optional)get15(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple17OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple17OfNullables.java new file mode 100644 index 0000000000..d3245cd29d --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple17OfNullables.java @@ -0,0 +1,116 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 17 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 17 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * + * @author Per Minborg + */ +public interface Tuple17OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + Optional get6(); + + Optional get7(); + + Optional get8(); + + Optional get9(); + + Optional get10(); + + Optional get11(); + + Optional get12(); + + Optional get13(); + + Optional get14(); + + Optional get15(); + + Optional get16(); + + @Override + default int degree() { + return 17; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + case 6 : return (Optional)get6(); + case 7 : return (Optional)get7(); + case 8 : return (Optional)get8(); + case 9 : return (Optional)get9(); + case 10 : return (Optional)get10(); + case 11 : return (Optional)get11(); + case 12 : return (Optional)get12(); + case 13 : return (Optional)get13(); + case 14 : return (Optional)get14(); + case 15 : return (Optional)get15(); + case 16 : return (Optional)get16(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple18OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple18OfNullables.java new file mode 100644 index 0000000000..f2d5bcebf6 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple18OfNullables.java @@ -0,0 +1,120 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 18 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 18 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * + * @author Per Minborg + */ +public interface Tuple18OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + Optional get6(); + + Optional get7(); + + Optional get8(); + + Optional get9(); + + Optional get10(); + + Optional get11(); + + Optional get12(); + + Optional get13(); + + Optional get14(); + + Optional get15(); + + Optional get16(); + + Optional get17(); + + @Override + default int degree() { + return 18; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + case 6 : return (Optional)get6(); + case 7 : return (Optional)get7(); + case 8 : return (Optional)get8(); + case 9 : return (Optional)get9(); + case 10 : return (Optional)get10(); + case 11 : return (Optional)get11(); + case 12 : return (Optional)get12(); + case 13 : return (Optional)get13(); + case 14 : return (Optional)get14(); + case 15 : return (Optional)get15(); + case 16 : return (Optional)get16(); + case 17 : return (Optional)get17(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple19OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple19OfNullables.java new file mode 100644 index 0000000000..aeba6f9b20 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple19OfNullables.java @@ -0,0 +1,124 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 19 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 19 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * + * @author Per Minborg + */ +public interface Tuple19OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + Optional get6(); + + Optional get7(); + + Optional get8(); + + Optional get9(); + + Optional get10(); + + Optional get11(); + + Optional get12(); + + Optional get13(); + + Optional get14(); + + Optional get15(); + + Optional get16(); + + Optional get17(); + + Optional get18(); + + @Override + default int degree() { + return 19; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + case 6 : return (Optional)get6(); + case 7 : return (Optional)get7(); + case 8 : return (Optional)get8(); + case 9 : return (Optional)get9(); + case 10 : return (Optional)get10(); + case 11 : return (Optional)get11(); + case 12 : return (Optional)get12(); + case 13 : return (Optional)get13(); + case 14 : return (Optional)get14(); + case 15 : return (Optional)get15(); + case 16 : return (Optional)get16(); + case 17 : return (Optional)get17(); + case 18 : return (Optional)get18(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple1OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple1OfNullables.java new file mode 100644 index 0000000000..9b432c6e30 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple1OfNullables.java @@ -0,0 +1,52 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 1 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 1 + * + * @param type of element 0 + * + * @author Per Minborg + */ +public interface Tuple1OfNullables extends TupleOfNullables { + + Optional get0(); + + @Override + default int degree() { + return 1; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple20OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple20OfNullables.java new file mode 100644 index 0000000000..65235d66cf --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple20OfNullables.java @@ -0,0 +1,128 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 20 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 20 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * + * @author Per Minborg + */ +public interface Tuple20OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + Optional get6(); + + Optional get7(); + + Optional get8(); + + Optional get9(); + + Optional get10(); + + Optional get11(); + + Optional get12(); + + Optional get13(); + + Optional get14(); + + Optional get15(); + + Optional get16(); + + Optional get17(); + + Optional get18(); + + Optional get19(); + + @Override + default int degree() { + return 20; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + case 6 : return (Optional)get6(); + case 7 : return (Optional)get7(); + case 8 : return (Optional)get8(); + case 9 : return (Optional)get9(); + case 10 : return (Optional)get10(); + case 11 : return (Optional)get11(); + case 12 : return (Optional)get12(); + case 13 : return (Optional)get13(); + case 14 : return (Optional)get14(); + case 15 : return (Optional)get15(); + case 16 : return (Optional)get16(); + case 17 : return (Optional)get17(); + case 18 : return (Optional)get18(); + case 19 : return (Optional)get19(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple21OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple21OfNullables.java new file mode 100644 index 0000000000..326e2a9b6d --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple21OfNullables.java @@ -0,0 +1,132 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 21 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 21 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * + * @author Per Minborg + */ +public interface Tuple21OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + Optional get6(); + + Optional get7(); + + Optional get8(); + + Optional get9(); + + Optional get10(); + + Optional get11(); + + Optional get12(); + + Optional get13(); + + Optional get14(); + + Optional get15(); + + Optional get16(); + + Optional get17(); + + Optional get18(); + + Optional get19(); + + Optional get20(); + + @Override + default int degree() { + return 21; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + case 6 : return (Optional)get6(); + case 7 : return (Optional)get7(); + case 8 : return (Optional)get8(); + case 9 : return (Optional)get9(); + case 10 : return (Optional)get10(); + case 11 : return (Optional)get11(); + case 12 : return (Optional)get12(); + case 13 : return (Optional)get13(); + case 14 : return (Optional)get14(); + case 15 : return (Optional)get15(); + case 16 : return (Optional)get16(); + case 17 : return (Optional)get17(); + case 18 : return (Optional)get18(); + case 19 : return (Optional)get19(); + case 20 : return (Optional)get20(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple22OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple22OfNullables.java new file mode 100644 index 0000000000..12b0f2da94 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple22OfNullables.java @@ -0,0 +1,136 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 22 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 22 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param type of element 21 + * + * @author Per Minborg + */ +public interface Tuple22OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + Optional get6(); + + Optional get7(); + + Optional get8(); + + Optional get9(); + + Optional get10(); + + Optional get11(); + + Optional get12(); + + Optional get13(); + + Optional get14(); + + Optional get15(); + + Optional get16(); + + Optional get17(); + + Optional get18(); + + Optional get19(); + + Optional get20(); + + Optional get21(); + + @Override + default int degree() { + return 22; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + case 6 : return (Optional)get6(); + case 7 : return (Optional)get7(); + case 8 : return (Optional)get8(); + case 9 : return (Optional)get9(); + case 10 : return (Optional)get10(); + case 11 : return (Optional)get11(); + case 12 : return (Optional)get12(); + case 13 : return (Optional)get13(); + case 14 : return (Optional)get14(); + case 15 : return (Optional)get15(); + case 16 : return (Optional)get16(); + case 17 : return (Optional)get17(); + case 18 : return (Optional)get18(); + case 19 : return (Optional)get19(); + case 20 : return (Optional)get20(); + case 21 : return (Optional)get21(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple23OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple23OfNullables.java new file mode 100644 index 0000000000..adb35f17f4 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple23OfNullables.java @@ -0,0 +1,140 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 23 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 23 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * @param type of element 9 + * @param type of element 10 + * @param type of element 11 + * @param type of element 12 + * @param type of element 13 + * @param type of element 14 + * @param type of element 15 + * @param type of element 16 + * @param type of element 17 + * @param type of element 18 + * @param type of element 19 + * @param type of element 20 + * @param type of element 21 + * @param type of element 22 + * + * @author Per Minborg + */ +public interface Tuple23OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + Optional get6(); + + Optional get7(); + + Optional get8(); + + Optional get9(); + + Optional get10(); + + Optional get11(); + + Optional get12(); + + Optional get13(); + + Optional get14(); + + Optional get15(); + + Optional get16(); + + Optional get17(); + + Optional get18(); + + Optional get19(); + + Optional get20(); + + Optional get21(); + + Optional get22(); + + @Override + default int degree() { + return 23; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + case 6 : return (Optional)get6(); + case 7 : return (Optional)get7(); + case 8 : return (Optional)get8(); + case 9 : return (Optional)get9(); + case 10 : return (Optional)get10(); + case 11 : return (Optional)get11(); + case 12 : return (Optional)get12(); + case 13 : return (Optional)get13(); + case 14 : return (Optional)get14(); + case 15 : return (Optional)get15(); + case 16 : return (Optional)get16(); + case 17 : return (Optional)get17(); + case 18 : return (Optional)get18(); + case 19 : return (Optional)get19(); + case 20 : return (Optional)get20(); + case 21 : return (Optional)get21(); + case 22 : return (Optional)get22(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple2OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple2OfNullables.java new file mode 100644 index 0000000000..5f25bcbdec --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple2OfNullables.java @@ -0,0 +1,56 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 2 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 2 + * + * @param type of element 0 + * @param type of element 1 + * + * @author Per Minborg + */ +public interface Tuple2OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + @Override + default int degree() { + return 2; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple3OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple3OfNullables.java new file mode 100644 index 0000000000..8cc69b2468 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple3OfNullables.java @@ -0,0 +1,60 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 3 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 3 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * + * @author Per Minborg + */ +public interface Tuple3OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + @Override + default int degree() { + return 3; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple4OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple4OfNullables.java new file mode 100644 index 0000000000..63f024527b --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple4OfNullables.java @@ -0,0 +1,64 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 4 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 4 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * + * @author Per Minborg + */ +public interface Tuple4OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + @Override + default int degree() { + return 4; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple5OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple5OfNullables.java new file mode 100644 index 0000000000..e2b9b757b2 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple5OfNullables.java @@ -0,0 +1,68 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 5 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 5 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * + * @author Per Minborg + */ +public interface Tuple5OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + @Override + default int degree() { + return 5; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple6OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple6OfNullables.java new file mode 100644 index 0000000000..b3c98ebaa4 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple6OfNullables.java @@ -0,0 +1,72 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 6 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 6 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * + * @author Per Minborg + */ +public interface Tuple6OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + @Override + default int degree() { + return 6; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple7OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple7OfNullables.java new file mode 100644 index 0000000000..5df85a1fbf --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple7OfNullables.java @@ -0,0 +1,76 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 7 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 7 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * + * @author Per Minborg + */ +public interface Tuple7OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + Optional get6(); + + @Override + default int degree() { + return 7; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + case 6 : return (Optional)get6(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple8OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple8OfNullables.java new file mode 100644 index 0000000000..6869fbb927 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple8OfNullables.java @@ -0,0 +1,80 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 8 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 8 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * + * @author Per Minborg + */ +public interface Tuple8OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + Optional get6(); + + Optional get7(); + + @Override + default int degree() { + return 8; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + case 6 : return (Optional)get6(); + case 7 : return (Optional)get7(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple9OfNullables.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple9OfNullables.java new file mode 100644 index 0000000000..8cdad5d425 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/Tuple9OfNullables.java @@ -0,0 +1,84 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.nullable; + +import com.speedment.common.tuple.Tuple; +import com.speedment.common.tuple.TupleOfNullables; +import java.util.Optional; + +/** + * This interface defines a generic Tuple of degree 9 that can hold non-null + * values. A Tuple is type safe, immutable and thread safe. For Tuples that can + * hold + * null elements see {@link TupleOfNullables} + * + * This {@link Tuple } has a degree of 9 + * + * @param type of element 0 + * @param type of element 1 + * @param type of element 2 + * @param type of element 3 + * @param type of element 4 + * @param type of element 5 + * @param type of element 6 + * @param type of element 7 + * @param type of element 8 + * + * @author Per Minborg + */ +public interface Tuple9OfNullables extends TupleOfNullables { + + Optional get0(); + + Optional get1(); + + Optional get2(); + + Optional get3(); + + Optional get4(); + + Optional get5(); + + Optional get6(); + + Optional get7(); + + Optional get8(); + + @Override + default int degree() { + return 9; + } + + @SuppressWarnings("unchecked") + default Optional get(int index) { + switch (index) { + case 0 : return (Optional)get0(); + case 1 : return (Optional)get1(); + case 2 : return (Optional)get2(); + case 3 : return (Optional)get3(); + case 4 : return (Optional)get4(); + case 5 : return (Optional)get5(); + case 6 : return (Optional)get6(); + case 7 : return (Optional)get7(); + case 8 : return (Optional)get8(); + default : throw new IllegalArgumentException(String.format("Index %d is outside bounds of tuple of degree %s", index, degree() + )); + } + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/package-info.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/package-info.java new file mode 100644 index 0000000000..5897520053 --- /dev/null +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/nullable/package-info.java @@ -0,0 +1,7 @@ +/** + * Tuples of various sizes are located in this package. + *

+ * This package is part of the API. Modifications to classes here should only + * (if ever) be done in major releases. + */ +package com.speedment.common.tuple; diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/package-info.java b/common-parent/tuple/src/main/java/com/speedment/common/tuple/package-info.java index 5897520053..8cd9a86972 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/package-info.java +++ b/common-parent/tuple/src/main/java/com/speedment/common/tuple/package-info.java @@ -1,5 +1,5 @@ /** - * Tuples of various sizes are located in this package. + * Immutable Tuples of various sizes are located in this package. *

* This package is part of the API. Modifications to classes here should only * (if ever) be done in major releases. diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/MappingTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/MappingTest.java new file mode 100644 index 0000000000..61c9110580 --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/MappingTest.java @@ -0,0 +1,86 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package com.speedment.common.tuple; + +import com.speedment.common.tuple.nonnullable.Tuple2; +import com.speedment.common.tuple.nonnullable.Tuple4; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; +import static java.util.stream.Collectors.toList; +import java.util.stream.Stream; +import org.junit.Assert; +import org.junit.Test; + +/** + * + * @author Per Minborg + */ +public class MappingTest { + + @Test + public void testTuple2() { + + final List> expected = Arrays.asList( + Tuples.of("Arne", "Arne".length()), + Tuples.of("Tryggve", "tryggve".length()) + ); + + final List> actual = Stream.of("Arne", "Tryggve") + .map(Tuples.toTuple(Function.identity(), String::length)) + .collect(toList()); + + Assert.assertEquals(expected, actual); + } + + @Test + public void testTuple4() { + Tuple4 t4 = Tuples.of(1, 2, 3, 4); + System.out.println(t4); + } + + @Test + public void testTuple1() { + Stream.of("Arne", "Tryggve") + .map(Tuples.toTuple(String::length)) + .forEach(System.out::println); + + } + + @Test + public void testTuple2b() { + Stream.of("Arne", "Tryggve") + .map(Tuples.toTuple(Function.identity(), String::length)) + .forEach(System.out::println); + + } + + @Test + public void testTuple2Variant() { + Stream.of("Arne", "Tryggve") + .map(Tuples.toTuple(Function.identity(), String::length)) + .map(Tuples.toTuple(Tuple2::get0, t2 -> t2.get1() + 10)) + .forEach(System.out::println); + + } + +} diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/TupleBuilderTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/TupleBuilderTest.java new file mode 100644 index 0000000000..26197dde53 --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/TupleBuilderTest.java @@ -0,0 +1,25 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package com.speedment.common.tuple; + +import com.speedment.common.tuple.nonnullable.Tuple3; +import static org.junit.Assert.assertEquals; +import org.junit.Test; + +/** + * + * @author Per Minborg + */ +public class TupleBuilderTest { + + @Test + public void testBuilder() { + final Tuple3 expected = Tuples.of(1, "Olle", Long.MAX_VALUE); + final Tuple3 actual = TupleBuilder.builder().add(1).add("Olle").add(Long.MAX_VALUE).build(); + assertEquals(expected, actual); + } + +} diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/Tuple2ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/Tuple2ImplTest.java index d71d821ec7..ef839191ae 100644 --- a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/Tuple2ImplTest.java +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/Tuple2ImplTest.java @@ -21,7 +21,8 @@ */ package com.speedment.common.tuple.internal; -import com.speedment.common.tuple.Tuple2; +import com.speedment.common.tuple.internal.nonnullable.Tuple2Impl; +import com.speedment.common.tuple.nonnullable.Tuple2; import java.util.Arrays; import java.util.List; import static java.util.stream.Collectors.toList; @@ -66,7 +67,7 @@ public void testGetIndex1() { @Test public void testLength() { - assertEquals(2, t2.length()); + assertEquals(2, t2.degree()); } @Test diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/AbstractTupleImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/AbstractTupleImplTest.java new file mode 100644 index 0000000000..3d54814f34 --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/AbstractTupleImplTest.java @@ -0,0 +1,64 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import com.speedment.common.tuple.Tuple; +import java.util.List; +import static java.util.Objects.requireNonNull; +import java.util.function.Supplier; +import static java.util.stream.Collectors.toList; +import java.util.stream.IntStream; +import static org.junit.Assert.*; +import org.junit.Before; +import org.junit.Test; + +/** + * + * @author Per Minborg + * @param tuple type + */ +public abstract class AbstractTupleImplTest { + + private final Supplier constructor; + private final int degree; + protected T instance; + + public AbstractTupleImplTest(Supplier constructor, int degree) { + this.constructor = requireNonNull(constructor); + this.degree = degree; + } + + @Before + public void before() { + instance = constructor.get(); + } + + @Test + public void testDegree() { + assertEquals(degree, instance.degree()); + } + + @Test + public void testGet() { + IntStream.range(0, degree).forEachOrdered(i -> { + assertEquals(i, (int) instance.get(i)); + }); + } + + @Test + public void testStream() { + final List expected = IntStream.range(0, degree).boxed().collect(toList()); + final List actual = instance.stream().collect(toList()); + assertEquals(expected, actual); + } + + @Test + public void testStreamOfType() { + assertEquals(0, instance.streamOf(String.class).count()); + assertEquals(degree, instance.streamOf(Integer.class).count()); + } + +} diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple0OfNullables.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple0ImplTest.java similarity index 66% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple0OfNullables.java rename to common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple0ImplTest.java index 1283ee34d5..089b8485f6 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple0OfNullables.java +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple0ImplTest.java @@ -1,28 +1,26 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple; +package com.speedment.common.tuple.internal.nonnullable; -/** - * {@inheritDoc} - * - * This {@link Tuple} holds no elements. - * - * @author pemi - */ -public interface Tuple0OfNullables extends TupleOfNullables { +import static org.junit.Assert.*; -} +public final class Tuple0ImplTest extends AbstractTupleImplTest { + + public Tuple0ImplTest() { + super(() -> (Tuple0Impl) Tuple0Impl.EMPTY_TUPLE, 0); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple10ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple10ImplTest.java new file mode 100644 index 0000000000..4b00bf45ed --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple10ImplTest.java @@ -0,0 +1,77 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple10ImplTest extends AbstractTupleImplTest> { + + public Tuple10ImplTest() { + super(() -> new Tuple10Impl<>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9), 10); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } + + @Test + public void get6Test() { + assertEquals(6, (int) instance.get6()); + } + + @Test + public void get7Test() { + assertEquals(7, (int) instance.get7()); + } + + @Test + public void get8Test() { + assertEquals(8, (int) instance.get8()); + } + + @Test + public void get9Test() { + assertEquals(9, (int) instance.get9()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple11ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple11ImplTest.java new file mode 100644 index 0000000000..bb6579b500 --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple11ImplTest.java @@ -0,0 +1,82 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple11ImplTest extends AbstractTupleImplTest> { + + public Tuple11ImplTest() { + super(() -> new Tuple11Impl<>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10), 11); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } + + @Test + public void get6Test() { + assertEquals(6, (int) instance.get6()); + } + + @Test + public void get7Test() { + assertEquals(7, (int) instance.get7()); + } + + @Test + public void get8Test() { + assertEquals(8, (int) instance.get8()); + } + + @Test + public void get9Test() { + assertEquals(9, (int) instance.get9()); + } + + @Test + public void get10Test() { + assertEquals(10, (int) instance.get10()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple12ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple12ImplTest.java new file mode 100644 index 0000000000..d4b203f970 --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple12ImplTest.java @@ -0,0 +1,87 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple12ImplTest extends AbstractTupleImplTest> { + + public Tuple12ImplTest() { + super(() -> new Tuple12Impl<>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11), 12); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } + + @Test + public void get6Test() { + assertEquals(6, (int) instance.get6()); + } + + @Test + public void get7Test() { + assertEquals(7, (int) instance.get7()); + } + + @Test + public void get8Test() { + assertEquals(8, (int) instance.get8()); + } + + @Test + public void get9Test() { + assertEquals(9, (int) instance.get9()); + } + + @Test + public void get10Test() { + assertEquals(10, (int) instance.get10()); + } + + @Test + public void get11Test() { + assertEquals(11, (int) instance.get11()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple13ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple13ImplTest.java new file mode 100644 index 0000000000..893416c5a8 --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple13ImplTest.java @@ -0,0 +1,92 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple13ImplTest extends AbstractTupleImplTest> { + + public Tuple13ImplTest() { + super(() -> new Tuple13Impl<>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), 13); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } + + @Test + public void get6Test() { + assertEquals(6, (int) instance.get6()); + } + + @Test + public void get7Test() { + assertEquals(7, (int) instance.get7()); + } + + @Test + public void get8Test() { + assertEquals(8, (int) instance.get8()); + } + + @Test + public void get9Test() { + assertEquals(9, (int) instance.get9()); + } + + @Test + public void get10Test() { + assertEquals(10, (int) instance.get10()); + } + + @Test + public void get11Test() { + assertEquals(11, (int) instance.get11()); + } + + @Test + public void get12Test() { + assertEquals(12, (int) instance.get12()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple14ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple14ImplTest.java new file mode 100644 index 0000000000..f6bba607a0 --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple14ImplTest.java @@ -0,0 +1,97 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple14ImplTest extends AbstractTupleImplTest> { + + public Tuple14ImplTest() { + super(() -> new Tuple14Impl<>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13), 14); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } + + @Test + public void get6Test() { + assertEquals(6, (int) instance.get6()); + } + + @Test + public void get7Test() { + assertEquals(7, (int) instance.get7()); + } + + @Test + public void get8Test() { + assertEquals(8, (int) instance.get8()); + } + + @Test + public void get9Test() { + assertEquals(9, (int) instance.get9()); + } + + @Test + public void get10Test() { + assertEquals(10, (int) instance.get10()); + } + + @Test + public void get11Test() { + assertEquals(11, (int) instance.get11()); + } + + @Test + public void get12Test() { + assertEquals(12, (int) instance.get12()); + } + + @Test + public void get13Test() { + assertEquals(13, (int) instance.get13()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple15ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple15ImplTest.java new file mode 100644 index 0000000000..0ca1d5cd24 --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple15ImplTest.java @@ -0,0 +1,102 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple15ImplTest extends AbstractTupleImplTest> { + + public Tuple15ImplTest() { + super(() -> new Tuple15Impl<>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14), 15); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } + + @Test + public void get6Test() { + assertEquals(6, (int) instance.get6()); + } + + @Test + public void get7Test() { + assertEquals(7, (int) instance.get7()); + } + + @Test + public void get8Test() { + assertEquals(8, (int) instance.get8()); + } + + @Test + public void get9Test() { + assertEquals(9, (int) instance.get9()); + } + + @Test + public void get10Test() { + assertEquals(10, (int) instance.get10()); + } + + @Test + public void get11Test() { + assertEquals(11, (int) instance.get11()); + } + + @Test + public void get12Test() { + assertEquals(12, (int) instance.get12()); + } + + @Test + public void get13Test() { + assertEquals(13, (int) instance.get13()); + } + + @Test + public void get14Test() { + assertEquals(14, (int) instance.get14()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple16ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple16ImplTest.java new file mode 100644 index 0000000000..0c7681599f --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple16ImplTest.java @@ -0,0 +1,107 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple16ImplTest extends AbstractTupleImplTest> { + + public Tuple16ImplTest() { + super(() -> new Tuple16Impl<>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15), 16); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } + + @Test + public void get6Test() { + assertEquals(6, (int) instance.get6()); + } + + @Test + public void get7Test() { + assertEquals(7, (int) instance.get7()); + } + + @Test + public void get8Test() { + assertEquals(8, (int) instance.get8()); + } + + @Test + public void get9Test() { + assertEquals(9, (int) instance.get9()); + } + + @Test + public void get10Test() { + assertEquals(10, (int) instance.get10()); + } + + @Test + public void get11Test() { + assertEquals(11, (int) instance.get11()); + } + + @Test + public void get12Test() { + assertEquals(12, (int) instance.get12()); + } + + @Test + public void get13Test() { + assertEquals(13, (int) instance.get13()); + } + + @Test + public void get14Test() { + assertEquals(14, (int) instance.get14()); + } + + @Test + public void get15Test() { + assertEquals(15, (int) instance.get15()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple17ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple17ImplTest.java new file mode 100644 index 0000000000..b34e0473a8 --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple17ImplTest.java @@ -0,0 +1,112 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple17ImplTest extends AbstractTupleImplTest> { + + public Tuple17ImplTest() { + super(() -> new Tuple17Impl<>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), 17); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } + + @Test + public void get6Test() { + assertEquals(6, (int) instance.get6()); + } + + @Test + public void get7Test() { + assertEquals(7, (int) instance.get7()); + } + + @Test + public void get8Test() { + assertEquals(8, (int) instance.get8()); + } + + @Test + public void get9Test() { + assertEquals(9, (int) instance.get9()); + } + + @Test + public void get10Test() { + assertEquals(10, (int) instance.get10()); + } + + @Test + public void get11Test() { + assertEquals(11, (int) instance.get11()); + } + + @Test + public void get12Test() { + assertEquals(12, (int) instance.get12()); + } + + @Test + public void get13Test() { + assertEquals(13, (int) instance.get13()); + } + + @Test + public void get14Test() { + assertEquals(14, (int) instance.get14()); + } + + @Test + public void get15Test() { + assertEquals(15, (int) instance.get15()); + } + + @Test + public void get16Test() { + assertEquals(16, (int) instance.get16()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple18ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple18ImplTest.java new file mode 100644 index 0000000000..57dcad8c76 --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple18ImplTest.java @@ -0,0 +1,117 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple18ImplTest extends AbstractTupleImplTest> { + + public Tuple18ImplTest() { + super(() -> new Tuple18Impl<>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17), 18); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } + + @Test + public void get6Test() { + assertEquals(6, (int) instance.get6()); + } + + @Test + public void get7Test() { + assertEquals(7, (int) instance.get7()); + } + + @Test + public void get8Test() { + assertEquals(8, (int) instance.get8()); + } + + @Test + public void get9Test() { + assertEquals(9, (int) instance.get9()); + } + + @Test + public void get10Test() { + assertEquals(10, (int) instance.get10()); + } + + @Test + public void get11Test() { + assertEquals(11, (int) instance.get11()); + } + + @Test + public void get12Test() { + assertEquals(12, (int) instance.get12()); + } + + @Test + public void get13Test() { + assertEquals(13, (int) instance.get13()); + } + + @Test + public void get14Test() { + assertEquals(14, (int) instance.get14()); + } + + @Test + public void get15Test() { + assertEquals(15, (int) instance.get15()); + } + + @Test + public void get16Test() { + assertEquals(16, (int) instance.get16()); + } + + @Test + public void get17Test() { + assertEquals(17, (int) instance.get17()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple19ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple19ImplTest.java new file mode 100644 index 0000000000..549a0e7067 --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple19ImplTest.java @@ -0,0 +1,122 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple19ImplTest extends AbstractTupleImplTest> { + + public Tuple19ImplTest() { + super(() -> new Tuple19Impl<>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18), 19); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } + + @Test + public void get6Test() { + assertEquals(6, (int) instance.get6()); + } + + @Test + public void get7Test() { + assertEquals(7, (int) instance.get7()); + } + + @Test + public void get8Test() { + assertEquals(8, (int) instance.get8()); + } + + @Test + public void get9Test() { + assertEquals(9, (int) instance.get9()); + } + + @Test + public void get10Test() { + assertEquals(10, (int) instance.get10()); + } + + @Test + public void get11Test() { + assertEquals(11, (int) instance.get11()); + } + + @Test + public void get12Test() { + assertEquals(12, (int) instance.get12()); + } + + @Test + public void get13Test() { + assertEquals(13, (int) instance.get13()); + } + + @Test + public void get14Test() { + assertEquals(14, (int) instance.get14()); + } + + @Test + public void get15Test() { + assertEquals(15, (int) instance.get15()); + } + + @Test + public void get16Test() { + assertEquals(16, (int) instance.get16()); + } + + @Test + public void get17Test() { + assertEquals(17, (int) instance.get17()); + } + + @Test + public void get18Test() { + assertEquals(18, (int) instance.get18()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple2OfNullables.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple1ImplTest.java similarity index 58% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple2OfNullables.java rename to common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple1ImplTest.java index af7ffecc0d..fef9e5bba4 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple2OfNullables.java +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple1ImplTest.java @@ -1,33 +1,32 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple; +package com.speedment.common.tuple.internal.nonnullable; -import java.util.Optional; +import org.junit.Test; +import static org.junit.Assert.*; -/** - * - * @author pemi - * @param Type of 0:th argument - * @param Type of 1:st argument - */ -public interface Tuple2OfNullables extends TupleOfNullables { - - Optional get0(); - - Optional get1(); - -} +public final class Tuple1ImplTest extends AbstractTupleImplTest> { + + public Tuple1ImplTest() { + super(() -> new Tuple1Impl<>(0), 1); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple20ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple20ImplTest.java new file mode 100644 index 0000000000..ad5977970e --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple20ImplTest.java @@ -0,0 +1,127 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple20ImplTest extends AbstractTupleImplTest> { + + public Tuple20ImplTest() { + super(() -> new Tuple20Impl<>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19), 20); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } + + @Test + public void get6Test() { + assertEquals(6, (int) instance.get6()); + } + + @Test + public void get7Test() { + assertEquals(7, (int) instance.get7()); + } + + @Test + public void get8Test() { + assertEquals(8, (int) instance.get8()); + } + + @Test + public void get9Test() { + assertEquals(9, (int) instance.get9()); + } + + @Test + public void get10Test() { + assertEquals(10, (int) instance.get10()); + } + + @Test + public void get11Test() { + assertEquals(11, (int) instance.get11()); + } + + @Test + public void get12Test() { + assertEquals(12, (int) instance.get12()); + } + + @Test + public void get13Test() { + assertEquals(13, (int) instance.get13()); + } + + @Test + public void get14Test() { + assertEquals(14, (int) instance.get14()); + } + + @Test + public void get15Test() { + assertEquals(15, (int) instance.get15()); + } + + @Test + public void get16Test() { + assertEquals(16, (int) instance.get16()); + } + + @Test + public void get17Test() { + assertEquals(17, (int) instance.get17()); + } + + @Test + public void get18Test() { + assertEquals(18, (int) instance.get18()); + } + + @Test + public void get19Test() { + assertEquals(19, (int) instance.get19()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple21ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple21ImplTest.java new file mode 100644 index 0000000000..43d8db7e0e --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple21ImplTest.java @@ -0,0 +1,132 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple21ImplTest extends AbstractTupleImplTest> { + + public Tuple21ImplTest() { + super(() -> new Tuple21Impl<>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20), 21); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } + + @Test + public void get6Test() { + assertEquals(6, (int) instance.get6()); + } + + @Test + public void get7Test() { + assertEquals(7, (int) instance.get7()); + } + + @Test + public void get8Test() { + assertEquals(8, (int) instance.get8()); + } + + @Test + public void get9Test() { + assertEquals(9, (int) instance.get9()); + } + + @Test + public void get10Test() { + assertEquals(10, (int) instance.get10()); + } + + @Test + public void get11Test() { + assertEquals(11, (int) instance.get11()); + } + + @Test + public void get12Test() { + assertEquals(12, (int) instance.get12()); + } + + @Test + public void get13Test() { + assertEquals(13, (int) instance.get13()); + } + + @Test + public void get14Test() { + assertEquals(14, (int) instance.get14()); + } + + @Test + public void get15Test() { + assertEquals(15, (int) instance.get15()); + } + + @Test + public void get16Test() { + assertEquals(16, (int) instance.get16()); + } + + @Test + public void get17Test() { + assertEquals(17, (int) instance.get17()); + } + + @Test + public void get18Test() { + assertEquals(18, (int) instance.get18()); + } + + @Test + public void get19Test() { + assertEquals(19, (int) instance.get19()); + } + + @Test + public void get20Test() { + assertEquals(20, (int) instance.get20()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple22ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple22ImplTest.java new file mode 100644 index 0000000000..dd5e298d2f --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple22ImplTest.java @@ -0,0 +1,137 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple22ImplTest extends AbstractTupleImplTest> { + + public Tuple22ImplTest() { + super(() -> new Tuple22Impl<>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21), 22); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } + + @Test + public void get6Test() { + assertEquals(6, (int) instance.get6()); + } + + @Test + public void get7Test() { + assertEquals(7, (int) instance.get7()); + } + + @Test + public void get8Test() { + assertEquals(8, (int) instance.get8()); + } + + @Test + public void get9Test() { + assertEquals(9, (int) instance.get9()); + } + + @Test + public void get10Test() { + assertEquals(10, (int) instance.get10()); + } + + @Test + public void get11Test() { + assertEquals(11, (int) instance.get11()); + } + + @Test + public void get12Test() { + assertEquals(12, (int) instance.get12()); + } + + @Test + public void get13Test() { + assertEquals(13, (int) instance.get13()); + } + + @Test + public void get14Test() { + assertEquals(14, (int) instance.get14()); + } + + @Test + public void get15Test() { + assertEquals(15, (int) instance.get15()); + } + + @Test + public void get16Test() { + assertEquals(16, (int) instance.get16()); + } + + @Test + public void get17Test() { + assertEquals(17, (int) instance.get17()); + } + + @Test + public void get18Test() { + assertEquals(18, (int) instance.get18()); + } + + @Test + public void get19Test() { + assertEquals(19, (int) instance.get19()); + } + + @Test + public void get20Test() { + assertEquals(20, (int) instance.get20()); + } + + @Test + public void get21Test() { + assertEquals(21, (int) instance.get21()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple23ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple23ImplTest.java new file mode 100644 index 0000000000..1e62df6d91 --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple23ImplTest.java @@ -0,0 +1,142 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple23ImplTest extends AbstractTupleImplTest> { + + public Tuple23ImplTest() { + super(() -> new Tuple23Impl<>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22), 23); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } + + @Test + public void get6Test() { + assertEquals(6, (int) instance.get6()); + } + + @Test + public void get7Test() { + assertEquals(7, (int) instance.get7()); + } + + @Test + public void get8Test() { + assertEquals(8, (int) instance.get8()); + } + + @Test + public void get9Test() { + assertEquals(9, (int) instance.get9()); + } + + @Test + public void get10Test() { + assertEquals(10, (int) instance.get10()); + } + + @Test + public void get11Test() { + assertEquals(11, (int) instance.get11()); + } + + @Test + public void get12Test() { + assertEquals(12, (int) instance.get12()); + } + + @Test + public void get13Test() { + assertEquals(13, (int) instance.get13()); + } + + @Test + public void get14Test() { + assertEquals(14, (int) instance.get14()); + } + + @Test + public void get15Test() { + assertEquals(15, (int) instance.get15()); + } + + @Test + public void get16Test() { + assertEquals(16, (int) instance.get16()); + } + + @Test + public void get17Test() { + assertEquals(17, (int) instance.get17()); + } + + @Test + public void get18Test() { + assertEquals(18, (int) instance.get18()); + } + + @Test + public void get19Test() { + assertEquals(19, (int) instance.get19()); + } + + @Test + public void get20Test() { + assertEquals(20, (int) instance.get20()); + } + + @Test + public void get21Test() { + assertEquals(21, (int) instance.get21()); + } + + @Test + public void get22Test() { + assertEquals(22, (int) instance.get22()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple1OfNullables.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple2ImplTest.java similarity index 52% rename from common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple1OfNullables.java rename to common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple2ImplTest.java index dd512c3312..91438e5e1f 100644 --- a/common-parent/tuple/src/main/java/com/speedment/common/tuple/Tuple1OfNullables.java +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple2ImplTest.java @@ -1,33 +1,37 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ -package com.speedment.common.tuple; +package com.speedment.common.tuple.internal.nonnullable; -import java.util.Optional; +import org.junit.Test; +import static org.junit.Assert.*; -/** - * {@inheritDoc} - * - * This {@link Tuple} holds two elements that can be null. - * - * @author pemi - * @param Type of 0:th argument - */ -public interface Tuple1OfNullables extends TupleOfNullables { - - Optional get0(); - -} +public final class Tuple2ImplTest extends AbstractTupleImplTest> { + + public Tuple2ImplTest() { + super(() -> new Tuple2Impl<>(0, 1), 2); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple3ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple3ImplTest.java new file mode 100644 index 0000000000..aec2c2722b --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple3ImplTest.java @@ -0,0 +1,42 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple3ImplTest extends AbstractTupleImplTest> { + + public Tuple3ImplTest() { + super(() -> new Tuple3Impl<>(0, 1, 2), 3); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple4ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple4ImplTest.java new file mode 100644 index 0000000000..c7e891211e --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple4ImplTest.java @@ -0,0 +1,47 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple4ImplTest extends AbstractTupleImplTest> { + + public Tuple4ImplTest() { + super(() -> new Tuple4Impl<>(0, 1, 2, 3), 4); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple5ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple5ImplTest.java new file mode 100644 index 0000000000..33cad7ae90 --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple5ImplTest.java @@ -0,0 +1,52 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple5ImplTest extends AbstractTupleImplTest> { + + public Tuple5ImplTest() { + super(() -> new Tuple5Impl<>(0, 1, 2, 3, 4), 5); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple6ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple6ImplTest.java new file mode 100644 index 0000000000..867132ddeb --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple6ImplTest.java @@ -0,0 +1,57 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple6ImplTest extends AbstractTupleImplTest> { + + public Tuple6ImplTest() { + super(() -> new Tuple6Impl<>(0, 1, 2, 3, 4, 5), 6); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple7ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple7ImplTest.java new file mode 100644 index 0000000000..4f33192eac --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple7ImplTest.java @@ -0,0 +1,62 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple7ImplTest extends AbstractTupleImplTest> { + + public Tuple7ImplTest() { + super(() -> new Tuple7Impl<>(0, 1, 2, 3, 4, 5, 6), 7); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } + + @Test + public void get6Test() { + assertEquals(6, (int) instance.get6()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple8ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple8ImplTest.java new file mode 100644 index 0000000000..db22eff0f4 --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple8ImplTest.java @@ -0,0 +1,67 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple8ImplTest extends AbstractTupleImplTest> { + + public Tuple8ImplTest() { + super(() -> new Tuple8Impl<>(0, 1, 2, 3, 4, 5, 6, 7), 8); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } + + @Test + public void get6Test() { + assertEquals(6, (int) instance.get6()); + } + + @Test + public void get7Test() { + assertEquals(7, (int) instance.get7()); + } +} \ No newline at end of file diff --git a/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple9ImplTest.java b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple9ImplTest.java new file mode 100644 index 0000000000..85cdb0e181 --- /dev/null +++ b/common-parent/tuple/src/test/java/com/speedment/common/tuple/internal/nonnullable/Tuple9ImplTest.java @@ -0,0 +1,72 @@ +/** + * + * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); You may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.speedment.common.tuple.internal.nonnullable; + +import org.junit.Test; +import static org.junit.Assert.*; + +public final class Tuple9ImplTest extends AbstractTupleImplTest> { + + public Tuple9ImplTest() { + super(() -> new Tuple9Impl<>(0, 1, 2, 3, 4, 5, 6, 7, 8), 9); + } + + @Test + public void get0Test() { + assertEquals(0, (int) instance.get0()); + } + + @Test + public void get1Test() { + assertEquals(1, (int) instance.get1()); + } + + @Test + public void get2Test() { + assertEquals(2, (int) instance.get2()); + } + + @Test + public void get3Test() { + assertEquals(3, (int) instance.get3()); + } + + @Test + public void get4Test() { + assertEquals(4, (int) instance.get4()); + } + + @Test + public void get5Test() { + assertEquals(5, (int) instance.get5()); + } + + @Test + public void get6Test() { + assertEquals(6, (int) instance.get6()); + } + + @Test + public void get7Test() { + assertEquals(7, (int) instance.get7()); + } + + @Test + public void get8Test() { + assertEquals(8, (int) instance.get8()); + } +} \ No newline at end of file diff --git a/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/BooleanGetter.java b/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/BooleanGetter.java index 20c1611fbb..a742b545bf 100644 --- a/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/BooleanGetter.java +++ b/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/BooleanGetter.java @@ -1,13 +1,13 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the @@ -24,38 +24,38 @@ * A short-cut functional reference to the {@code getXXX(value)} method for a * particular field in an entity. *

- * A {@code BooleanGetter} has the following signature: {@code + * A {@code BooleanGetter} has the following signature: + * {@code * interface ENTITY { * boolean getXXX(); + * } * } - * } - * + * * @param the entity - * + * * @author Emil Forslund - * @since 3.0.0 + * @since 3.0.0 */ @GeneratedCode(value = "Speedment") @FunctionalInterface public interface BooleanGetter extends Getter, ToBooleanFunction { - + /** * Returns the member represented by this getter in the specified instance. - * + * * @param instance the instance to get from - * @return the value + * @return the value */ @Override boolean applyAsBoolean(ENTITY instance); - + @Override default Boolean apply(ENTITY instance) { return applyAsBoolean(instance); } - + @Override default Function asFunction() { return this::apply; - } - -} + } +} \ No newline at end of file diff --git a/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/ByteGetter.java b/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/ByteGetter.java index 6d7e6fd0db..686f16e51f 100644 --- a/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/ByteGetter.java +++ b/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/ByteGetter.java @@ -51,10 +51,9 @@ public interface ByteGetter extends Getter { default Byte apply(ENTITY instance) { return applyAsByte(instance); } - + @Override - default Function asFunction() { + default Function asFunction() { return this::apply; - } - + } } \ No newline at end of file diff --git a/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/CharGetter.java b/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/CharGetter.java index b067f5380a..4f3f8fee4a 100644 --- a/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/CharGetter.java +++ b/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/CharGetter.java @@ -1,13 +1,13 @@ /** - * + * * Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved. - * + * * Licensed under the Apache License, Version 2.0 (the "License"); You may not * use this file except in compliance with the License. You may obtain a copy of - * the License at: - * + * the License at: + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the @@ -23,37 +23,37 @@ * A short-cut functional reference to the {@code getXXX(value)} method for a * particular field in an entity. *

- * A {@code CharacterGetter} has the following signature: {@code + * A {@code CharacterGetter} has the following signature: + * {@code * interface ENTITY { * char getXXX(); + * } * } - * } - * + * * @param the entity - * + * * @author Emil Forslund - * @since 3.0.0 + * @since 3.0.0 */ @GeneratedCode(value = "Speedment") @FunctionalInterface public interface CharGetter extends Getter { - + /** * Returns the member represented by this getter in the specified instance. - * + * * @param instance the instance to get from - * @return the value + * @return the value */ char applyAsChar(ENTITY instance); - + @Override default Character apply(ENTITY instance) { return applyAsChar(instance); } - + @Override default Function asFunction() { return this::apply; } - -} +} \ No newline at end of file diff --git a/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/DoubleGetter.java b/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/DoubleGetter.java index 0cf0527bac..623e50c74d 100644 --- a/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/DoubleGetter.java +++ b/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/DoubleGetter.java @@ -58,5 +58,4 @@ default Double apply(ENTITY instance) { default Function asFunction() { return this::apply; } - } \ No newline at end of file diff --git a/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/FloatGetter.java b/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/FloatGetter.java index 8260c681d6..ba5c26f07a 100644 --- a/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/FloatGetter.java +++ b/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/FloatGetter.java @@ -56,5 +56,4 @@ default Float apply(ENTITY instance) { default Function asFunction() { return this::apply; } - } \ No newline at end of file diff --git a/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/IntGetter.java b/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/IntGetter.java index d07ba009e6..19539dc75e 100644 --- a/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/IntGetter.java +++ b/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/IntGetter.java @@ -39,7 +39,7 @@ @GeneratedCode(value = "Speedment") @FunctionalInterface public interface IntGetter extends Getter, ToIntFunction { - + /** * Returns the member represented by this getter in the specified instance. * @@ -53,10 +53,9 @@ public interface IntGetter extends Getter, ToIntFunction default Integer apply(ENTITY instance) { return applyAsInt(instance); } - + @Override default Function asFunction() { return this::apply; - } - + } } \ No newline at end of file diff --git a/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/LongGetter.java b/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/LongGetter.java index d3a214c965..716fb3b5cb 100644 --- a/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/LongGetter.java +++ b/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/LongGetter.java @@ -57,6 +57,5 @@ default Long apply(ENTITY instance) { @Override default Function asFunction() { return this::apply; - } - + } } \ No newline at end of file diff --git a/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/ShortGetter.java b/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/ShortGetter.java index c8fc65fa98..9a19a432e2 100644 --- a/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/ShortGetter.java +++ b/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/method/ShortGetter.java @@ -55,6 +55,5 @@ default Short apply(ENTITY instance) { @Override default Function asFunction() { return this::apply; - } - + } } \ No newline at end of file