no.digipost.tuple.Septuple Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of digg Show documentation
Show all versions of digg Show documentation
Some stellar general purpose utils.
The newest version!
/*
* Copyright (C) Posten Norge AS
*
* 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 no.digipost.tuple;
import no.digipost.function.SeptiFunction;
import java.util.function.Function;
import static no.digipost.tuple.XTuple.TERMINATOR;
/**
* A septuple is a simple composition of seven arbitrary values (objects). A septuple
* captures no semantics of the seven values, and they are only referred to as
* "the first", "the second", "the third", "the fourth", "the fifth", "the sixth", and "the seventh" value.
*
* @param The type of the first value
* @param The type of the second value
* @param The type of the third value
* @param The type of the fourth value
* @param The type of the fifth value
* @param The type of the sixth value
* @param The type of the seventh value
*/
public interface Septuple extends ViewableAsSeptuple {
static Septuple of(T1 first, T2 second, T3 third, T4 fourth, T5 fifth, T6 sixth, T7 seventh) {
return new XTuple<>(first, second, third, fourth, fifth, sixth, seventh, TERMINATOR, null, null);
}
static Septuple flatten(Tuple, T3>, T4>, T5>, T6>, T7> nestedTuple) {
return Septuple.of(nestedTuple.first().first().first().first().first().first(),
nestedTuple.first().first().first().first().first().second(),
nestedTuple.first().first().first().first().second(),
nestedTuple.first().first().first().second(),
nestedTuple.first().first().second(),
nestedTuple.first().second(),
nestedTuple.second());
}
/**
* @return the first value
*/
T1 first();
/**
* @return the second value
*/
T2 second();
/**
* @return the third value
*/
T3 third();
/**
* @return the fourth value
*/
T4 fourth();
/**
* @return the fifth value
*/
T5 fifth();
/**
* @return the sixth value
*/
T6 sixth();
/**
* @return the seventh value
*/
T7 seventh();
/**
* Create a new septuple by applying a function to the first element, and putting the
* result as the first element of the new septuple.
*
* @param mapper the function to apply to the first element
* @return the new septuple
*/
Septuple mapFirst(Function mapper);
/**
* Create a new septuple by applying a function to the second element, and putting the
* result as the second element of the new septuple.
*
* @param mapper the function to apply to the second element
* @return the new septuple
*/
Septuple mapSecond(Function mapper);
/**
* Create a new septuple by applying a function to the third element, and putting the
* result as the third element of the new septuple.
*
* @param mapper the function to apply to the third element
* @return the new septuple
*/
Septuple mapThird(Function mapper);
/**
* Create a new septuple by applying a function to the fourth element, and putting the
* result as the fourth element of the new septuple.
*
* @param mapper the function to apply to the fourth element
* @return the new septuple
*/
Septuple mapFourth(Function mapper);
/**
* Create a new septuple by applying a function to the fifth element, and putting the
* result as the fifth element of the new septuple.
*
* @param mapper the function to apply to the fifth element
* @return the new septuple
*/
Septuple mapFifth(Function mapper);
/**
* Create a new septuple by applying a function to the sixth element, and putting the
* result as the sixth element of the new septuple.
*
* @param mapper the function to apply to the sixth element
* @return the new septuple
*/
Septuple mapSixth(Function mapper);
/**
* Create a new septuple by applying a function to the seventh element, and putting the
* result as the seventh element of the new septuple.
*
* @param mapper the function to apply to the seventh element
* @return the new septuple
*/
Septuple mapSeventh(Function mapper);
/**
* Create a new septuple by applying a function to each element, and putting the
* results into a new septuple.
*
* @param firstMapper the function to apply to the first element
* @param secondMapper the function to apply to the second element
* @param thirdMapper the function to apply to the third element
* @param fourthMapper the function to apply to the fourth element
* @param fifthMapper the function to apply to the fifth element
* @param sixthMapper the function to apply to the sixth element
* @param seventhMapper the function to apply to the seventh element
* @return the new septuple
*/
Septuple map(Function firstMapper,
Function secondMapper,
Function thirdMapper,
Function fourthMapper,
Function fifthMapper,
Function sixthMapper,
Function seventhMapper);
/**
* @return this septuple instance
*/
@Override
Septuple asSeptuple();
/**
* Convert this septuple to an instance of an arbitrary type.
*
* @param The type of the resulting instance
* @param convertor the function used to convert the contained
* values to a resulting compound instance.
* @return the result from the given function
*/
R to(SeptiFunction convertor);
}