com.aol.cyclops.closures.mutable

Class MutableInt

java.lang.Object

com.aol.cyclops.closures.mutable.MutableInt

Type Parameters:

T - Type held inside closed var

All Implemented Interfaces:

Convertable<java.lang.Integer>, java.lang.Iterable<java.lang.Integer>, java.util.function.IntConsumer, java.util.function.IntSupplier, java.util.function.Supplier<java.lang.Integer>

public class MutableInt
extends java.lang.Object
implements java.util.function.IntSupplier, java.util.function.IntConsumer, Convertable<java.lang.Integer>

Class that represents a Closed Variable In Java 8 because of the effectively final rule references to captured variables can't be changed. e.g.

 
 String var = "hello";
 Runnable r = () -> var ="world";
 

Won't compile because var is treated as if it is final. This can be 'worked around' by using a wrapping object or array. e.g.

 Mutable<String> var =  Mutable.of("hello");
 Runnable r = () -> var.set("world");
 

Nested Class Summary

Nested classes/interfaces inherited from interface com.aol.cyclops.closures.Convertable

Convertable.SupplierToConvertable<T>

Constructor Summary

Constructors

Constructor and Description
MutableInt()

Method Summary

Modifier and Type	Method and Description
void	accept(int value)
static MutableInt	fromExternal(java.util.function.IntSupplier s, java.util.function.IntConsumer c) Construct a MutableInt that gets and sets an external value using the provided Supplier and Consumer e.g.
java.lang.Integer	get()
int	getAsInt()
MutableInt	mapInput(java.util.function.IntUnaryOperator fn) Use the supplied function to perform a lazy map operation when get is called
<T1> Mutable<T1>	mapInputToObj(java.util.function.Function<T1,java.lang.Integer> fn) Use the supplied function to perform a lazy map operation when get is called
MutableInt	mapOutput(java.util.function.IntUnaryOperator fn) Use the supplied function to perform a lazy map operation when get is called
<R> Mutable<R>	mapOutputToObj(java.util.function.Function<java.lang.Integer,R> fn) Use the supplied function to perform a lazy map operation when get is called
MutableInt	mutate(java.util.function.IntFunction<java.lang.Integer> varFn)
static MutableInt	of(int var) Create a Mutable variable, which can be mutated inside a Closure e.g.
MutableInt	set(int var)
java.util.stream.IntStream	toIntStream()
java.util.OptionalInt	toOptionalInt()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.util.function.IntConsumer

andThen

Methods inherited from interface com.aol.cyclops.closures.Convertable

fromSupplier, iterator, orElse, orElseGet, orElseThrow, toAtomicReference, toCompletableFuture, toCompletableFutureAsync, toCompletableFutureAsync, toList, toOptional, toOptionalAtomicReference, toStream, when, when, whenOrElse

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Constructor Detail

MutableInt

public MutableInt()

Method Detail

of

public static MutableInt of(int var)

Create a Mutable variable, which can be mutated inside a Closure e.g.

   MutableInt num = MutableInt.of(20);
   
   Stream.of(1,2,3,4).map(i->i*10).peek(i-> num.mutate(n->n+i)).foreach(System.out::println);
   
   System.out.println(num.get());
   //prints 120
  

Parameters:

var - Initial value of Mutable

Returns:

New Mutable instance

fromExternal

public static MutableInt fromExternal(java.util.function.IntSupplier s,
                                      java.util.function.IntConsumer c)

Construct a MutableInt that gets and sets an external value using the provided Supplier and Consumer e.g.

  
    MutableInt mutable = MutableInt.fromExternal(()->!this.value,val->!this.value);
 
 

Parameters:

s - Supplier of an external value

c - Consumer that sets an external value

Returns:

MutableInt that gets / sets an external (mutable) value

mapOutputToObj

public <R> Mutable<R> mapOutputToObj(java.util.function.Function<java.lang.Integer,R> fn)

Use the supplied function to perform a lazy map operation when get is called

  
  MutableInt mutable = MutableInt.fromExternal(()->!this.value,val->!this.value);
  Mutable<Int> withOverride = mutable.mapOutputToObj(b->{ 
                                                        if(override)
                                                             return 10.0;
                                                         return b;
                                                         });
          
 
 

Parameters:

fn - Map function to be applied to the result when get is called

Returns:

Mutable that lazily applies the provided function when get is called to the return value

mapInputToObj

public <T1> Mutable<T1> mapInputToObj(java.util.function.Function<T1,java.lang.Integer> fn)

Use the supplied function to perform a lazy map operation when get is called

  
  MutableInt mutable = MutableInt.fromExternal(()->!this.value,val->!this.value);
  Mutable<Int> withOverride = mutable.mapInputToObj(b->{ 
                                                        if(override)
                                                             return 10;
                                                         return b;
                                                         });
          
 
 

Parameters:

fn - Map function to be applied to the input when set is called

Returns:

Mutable that lazily applies the provided function when set is called to the input value

mapOutput

public MutableInt mapOutput(java.util.function.IntUnaryOperator fn)

Use the supplied function to perform a lazy map operation when get is called

  
  MutableInt mutable = MutableInt.fromExternal(()->!this.value,val->!this.value);
  MutableInt withOverride = mutable.mapOutput(b->{ 
                                                        if(override)
                                                             return 10;
                                                         return b;
                                                         });
          
 
 

Parameters:

fn - Map function to be applied to the result when get is called

Returns:

Mutable that lazily applies the provided function when get is called to the return value

mapInput

public MutableInt mapInput(java.util.function.IntUnaryOperator fn)

Use the supplied function to perform a lazy map operation when get is called

  
  MutableInt mutable = MutableInt.fromExternal(()->!this.value,val->!this.value);
  MutableInt withOverride = mutable.mapInput(b->{ 
                                                        if(override)
                                                             return 10;
                                                         return b;
                                                         });
          
 
 

Parameters:

fn - Map function to be applied to the input when set is called

Returns:

Mutable that lazily applies the provided function when set is called to the input value

getAsInt

public int getAsInt()

Specified by:

getAsInt in interface java.util.function.IntSupplier

Returns:

Current value

set

public MutableInt set(int var)

Parameters:

var - New value

Returns:

this object with mutated value

mutate

public MutableInt mutate(java.util.function.IntFunction<java.lang.Integer> varFn)

Parameters:

varFn - New value

Returns:

this object with mutated value

toOptionalInt

public java.util.OptionalInt toOptionalInt()

toIntStream

public java.util.stream.IntStream toIntStream()

get

public java.lang.Integer get()

Specified by:

get in interface Convertable<java.lang.Integer>

Specified by:

get in interface java.util.function.Supplier<java.lang.Integer>

Returns:

Contained value, maybe null

accept

public void accept(int value)

Specified by:

accept in interface java.util.function.IntConsumer