Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.aol.cyclops.lambda.tuple.PTuple6 Maven / Gradle / Ivy
package com.aol.cyclops.lambda.tuple;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executor;
import java.util.function.Function;
import com.aol.cyclops.functions.HexFunction;
import com.aol.cyclops.lambda.tuple.lazymap.LazyMap1PTuple8;
import com.aol.cyclops.lambda.tuple.lazymap.LazyMap2PTuple8;
import com.aol.cyclops.lambda.tuple.lazymap.LazyMap3PTuple8;
import com.aol.cyclops.lambda.tuple.lazymap.LazyMap4PTuple8;
import com.aol.cyclops.lambda.tuple.lazymap.LazyMap5PTuple8;
import com.aol.cyclops.lambda.tuple.lazymap.LazyMap6PTuple8;
public interface PTuple6 extends PTuple5 {
default T6 v6(){
if(arity()<6)
throw new ClassCastException("Attempt to upscale to " + PTuple6.class.getCanonicalName() + " from com.aol.cyclops.lambda.tuple.Tuple"+arity());
return (T6)getCachedValues().get(5);
}
default T6 _6(){
return v6();
}
default T6 getT6(){
return v6();
}
default int arity(){
return 6;
}
default R apply6(Function>>>>> fn){
return fn.apply(v1()).apply(v2()).apply(v3()).apply(v4()).apply(v5()).apply(v6());
}
default R call(HexFunction fn){
return fn.apply(v1(),v2(),v3(),v4(),v5(),v6());
}
default CompletableFuture callAsync(HexFunction fn){
return CompletableFuture.completedFuture(this).thenApplyAsync(i->fn.apply(i.v1(),
i.v2(),i.v3(),i.v4(),i.v5(),i.v6()));
}
default CompletableFuture applyAsync6(Function>>>>> fn){
return CompletableFuture.completedFuture(v6())
.thenApplyAsync(fn.apply(v1()).apply(v2()).apply(v3()).apply(v4()).apply(v5()));
}
default CompletableFuture callAsync(HexFunction fn, Executor e){
return CompletableFuture.completedFuture(this).thenApplyAsync(i->fn.apply(i.v1(),
i.v2(),i.v3(),i.v4(),i.v5(),i.v6()),e);
}
default CompletableFuture applyAsync6(Function>>>>> fn, Executor e){
return CompletableFuture.completedFuture(v6())
.thenApplyAsync(fn.apply(v1()).apply(v2()).apply(v3()).apply(v4()).apply(v5()),e);
}
default PTuple5 tuple5(){
return (PTuple5)withArity(5);
}
default PTuple6 swap6(){
return of(v6(),v5(),v4(),v3(),v2(),v1());
}
public static PTuple6 ofTuple(Object tuple6){
return (PTuple6)new TupleImpl(tuple6,6);
}
public static PTuple6 of(T1 t1, T2 t2,T3 t3,T4 t4,T5 t5, T6 t6){
return (PTuple6)new TupleImpl(Arrays.asList(t1,t2,t3,t4,t5,t6),6);
}
/**Strict mapping of the first element
*
* @param fn Mapping function
* @return Tuple6
*/
default PTuple6 map1(Function fn){
if(arity()!=6)
return (PTuple6)PTuple5.super.map1(fn);
else
return PowerTuples.tuple(fn.apply(v1()),v2(),v3(),v4(),v5(),v6());
}
/**
* Lazily Map 1st element and memoise the result
* @param fn Map function
* @return
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
default PTuple6 lazyMap1(Function fn){
if(arity()!=6)
return (PTuple6)PTuple5.super.lazyMap1(fn);
return new LazyMap1PTuple8(fn,(PTuple8)this);
}
/**
* Lazily Map 2nd element and memoise the result
* @param fn Map function
* @return
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
default PTuple6 lazyMap2(Function fn){
if(arity()!=6)
return (PTuple6)PTuple5.super.lazyMap2(fn);
return new LazyMap2PTuple8(fn,(PTuple8)this);
}
/** Map the second element in this Tuple
* @param fn mapper function
* @return new Tuple3
*/
default PTuple6 map2(Function fn){
if(arity()!=6)
return (PTuple6)PTuple5.super.map2(fn);
return of(v1(),fn.apply(v2()),v3(),v4(),v5(),v6());
}
/**
* Lazily Map 3rd element and memoise the result
* @param fn Map function
* @return
*/
default PTuple6 lazyMap3(Function fn){
if(arity()!=6)
return (PTuple6)PTuple5.super.lazyMap3(fn);
return new LazyMap3PTuple8(fn,(PTuple8)this);
}
/*
* @see com.aol.cyclops.lambda.tuple.Tuple4#map3(java.util.function.Function)
*/
default PTuple6 map3(Function fn){
if(arity()!=6)
return (PTuple6)PTuple5.super.map3(fn);
return of(v1(),v2(),fn.apply(v3()),v4(),v5(),v6());
}
/**
* Lazily Map 4th element and memoise the result
* @param fn Map function
* @return
*/
default PTuple6 lazyMap4(Function fn){
if(arity()!=6)
return (PTuple6)PTuple5.super.lazyMap4(fn);
return new LazyMap4PTuple8(fn,(PTuple8)this);
}
/*
* Map element 4
* @see com.aol.cyclops.lambda.tuple.Tuple4#map4(java.util.function.Function)
*/
default PTuple6 map4(Function fn){
if(arity()!=6)
return (PTuple6)PTuple5.super.map4(fn);
return of(v1(),v2(),v3(),fn.apply(v4()),v5(),v6());
}
/*
* Lazily Map 5th element and memoise the result
* @param fn Map function
* @return
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
default PTuple6 lazyMap5(Function fn){
if(arity()!=6)
return (PTuple6)PTuple5.super.lazyMap5(fn);
return new LazyMap5PTuple8(fn,(PTuple8)this);
}
/**
* Map the 6th element in a tuple to a different value
*
* @param fn Mapper function
* @return new Tuple5
*/
default PTuple6 map5(Function fn){
if(arity()!=6)
return (PTuple6)PTuple5.super.map5(fn);
return of(v1(),v2(),v3(),v4(),fn.apply(v5()),v6());
}
/*
* Lazily Map 5th element and memoise the result
* @param fn Map function
* @return
*/
default PTuple6 lazyMap6(Function fn){
return new LazyMap6PTuple8(fn,(PTuple8)this);
}
/**
*
* Map the 6th element in a tuple to a different value
*
* @param fn Mapper function
* @return new Tuple6
*/
default PTuple6 map6(Function fn){
return of(v1(),v2(),v3(),v4(),v5(),fn.apply(v6()));
}
/**
* Lazily reorder a PTuple6 or both a narrow and reorder a larger Tuple
*
* @param v1S Function that determines new first element
* @param v2S Function that determines new second element
* @param v3S Function that determines new third element
* @param v4S Function that determines new fourth element
* @param v5S Function that determines new fifth element
* @param v6S Function that determines new sixth element
* @return reordered PTuple6
*/
default PTuple6 reorder(
Function, NT1> v1S,
Function, NT2> v2S,
Function, NT3> v3S,
Function, NT4> v4S,
Function, NT5> v5S,
Function, NT6> v6S) {
PTuple6 host = this;
return new TupleImpl(Arrays.asList(), 5) {
public NT1 v1() {
return v1S.apply(host);
}
public NT2 v2() {
return v2S.apply(host);
}
public NT3 v3() {
return v3S.apply(host);
}
public NT4 v4() {
return v4S.apply(host);
}
public NT5 v5() {
return v5S.apply(host);
}
public NT6 v6() {
return v6S.apply(host);
}
@Override
public List getCachedValues() {
return Arrays.asList(v1(), v2(), v3(), v4(),v5(),v6());
}
@Override
public Iterator iterator() {
return getCachedValues().iterator();
}
};
}
default PTuple6 memo(){
if(arity()!=6)
return (PTuple6)PTuple5.super.memo();
PTuple6 host = this;
Map values = new ConcurrentHashMap<>();
return new TupleImpl(Arrays.asList(),6){
public T1 v1(){
return ( T1)values.computeIfAbsent(new Integer(0), key -> host.v1());
}
public T2 v2(){
return ( T2)values.computeIfAbsent(new Integer(1), key -> host.v2());
}
public T3 v3(){
return ( T3)values.computeIfAbsent(new Integer(2), key -> host.v3());
}
public T4 v4(){
return ( T4)values.computeIfAbsent(new Integer(3), key -> host.v4());
}
public T5 v5(){
return ( T5)values.computeIfAbsent(new Integer(4), key -> host.v5());
}
public T6 v6(){
return ( T6)values.computeIfAbsent(new Integer(5), key -> host.v6());
}
@Override
public List getCachedValues() {
return Arrays.asList(v1(),v2(),v3(),v4(),v5(),v6());
}
@Override
public Iterator iterator() {
return getCachedValues().iterator();
}
};
}
}
