cyclops.box

Class MutableShort

java.lang.Object

cyclops.box.MutableShort

Type Parameters:

T - Type held inside closed var

All Implemented Interfaces:

To<MutableShort>, java.util.function.Consumer<java.lang.Short>, java.util.function.Supplier<java.lang.Short>

public class MutableShort
extends java.lang.Object
implements To<MutableShort>, java.util.function.Supplier<java.lang.Short>, java.util.function.Consumer<java.lang.Short>

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.

 
 short var = true;
 Runnable r = () -> var =false;
 

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.

 MutableShort var =  MutableShort.of(true);
 Runnable r = () -> var.set(false);
 

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	MutableShort.ShortFunction

Constructor Summary

Constructors

Constructor and Description
MutableShort()

Method Summary

Modifier and Type	Method and Description
void	accept(java.lang.Short t)
static MutableShort	fromExternal(java.util.function.Supplier<java.lang.Short> s, java.util.function.Consumer<java.lang.Short> c) Construct a MutableShort that gets and sets an external value using the provided Supplier and Consumer e.g.
java.lang.Short	get()
short	getAsShort()
<T1> Mutable<T1>	mapInputToObj(java.util.function.Function<T1,java.lang.Short> 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.Short,R> fn) Use the supplied function to perform a lazy map operation when get is called
MutableShort	mutate(MutableShort.ShortFunction varFn)
static <T> MutableShort	of(short var) Create a Mutable variable, which can be mutated inside a Closure e.g.
MutableShort	set(short var)

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.aol.cyclops2.types.To

to

Methods inherited from interface java.util.function.Consumer

andThen

Constructor Detail

MutableShort

public MutableShort()

Method Detail

of

public static <T> MutableShort of(short var)

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

   MutableShort num = MutableShort.of(true);
   
    num.mutate(n->!n))
   
   System.out.println(num.getAsShort());
   //prints false
  

Parameters:

var - Initial value of Mutable

Returns:

New Mutable instance

fromExternal

public static MutableShort fromExternal(java.util.function.Supplier<java.lang.Short> s,
                                        java.util.function.Consumer<java.lang.Short> c)

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

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

Parameters:

s - Supplier of an external value

c - Consumer that sets an external value

Returns:

MutableShort that gets / sets an external (mutable) value

mapOutputToObj

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

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

  
  MutableShort mutable = MutableShort.fromExternal(()->!this.value,val->!this.value);
  Mutable<Short> withOverride = mutable.mapOutputToObj(b->{ 
                                                        if(override)
                                                             return 3s;
                                                         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.Short> fn)

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

  
  MutableShort mutable = MutableShort.fromExternal(()->!this.value,val->!this.value);
  Mutable<Short> withOverride = mutable.mapInputToObj(b->{ 
                                                        if(override)
                                                             return 1s;
                                                         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

getAsShort

public short getAsShort()

Returns:

Current value

set

public MutableShort set(short var)

Parameters:

var - New value

Returns:

this object with mutated value

mutate

public MutableShort mutate(MutableShort.ShortFunction varFn)

Parameters:

varFn - New value

Returns:

this object with mutated value

get

public java.lang.Short get()

Specified by:

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

accept

public void accept(java.lang.Short t)

Specified by:

accept in interface java.util.function.Consumer<java.lang.Short>