com.oath.cyclops.util.box

Class MutableByte

java.lang.Object

com.oath.cyclops.util.box.MutableByte

Type Parameters:

T - Type held inside closed var

All Implemented Interfaces:

To<MutableByte>, java.util.function.Consumer<java.lang.Byte>, java.util.function.Supplier<java.lang.Byte>

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

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.

 byte 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.

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

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	MutableByte.ByteFunction

Constructor Summary

Constructors

Constructor and Description
MutableByte()

Method Summary

Modifier and Type	Method and Description
void	accept(java.lang.Byte t)
static MutableByte	fromExternal(java.util.function.Supplier<java.lang.Byte> s, java.util.function.Consumer<java.lang.Byte> c) Construct a MutableByte that gets and sets an external value using the provided Supplier and Consumer e.g.
java.lang.Byte	get()
byte	getAsByte()
<T1> Mutable<T1>	mapInputToObj(java.util.function.Function<T1,java.lang.Byte> fn) Use the supplied function to perform a lazy transform operation when getValue is called
<R> Mutable<R>	mapOutputToObj(java.util.function.Function<java.lang.Byte,R> fn) Use the supplied function to perform a lazy transform operation when getValue is called
MutableByte	mutate(MutableByte.ByteFunction varFn)
static <T> MutableByte	of(byte var) Create a Mutable variable, which can be mutated inside a Closure e.g.
MutableByte	set(byte var)

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.oath.cyclops.types.foldable.To

to

Methods inherited from interface java.util.function.Consumer

andThen

Constructor Detail

MutableByte

public MutableByte()

Method Detail

of

public static <T> MutableByte of(byte var)

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

   MutableByte num = MutableByte.of(true);

    num.mutate(n->!n))

   System.out.println(num.getAsByte());
   //prints false
  

Parameters:

var - Initial value of Mutable

Returns:

New Mutable instance

fromExternal

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

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

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

Parameters:

s - Supplier of an external value

c - Consumer that sets an external value

Returns:

MutableByte that gets / sets an external (mutable) value

mapOutputToObj

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

Use the supplied function to perform a lazy transform operation when getValue is called

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

 
 

Parameters:

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

Returns:

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

mapInputToObj

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

Use the supplied function to perform a lazy transform operation when getValue is called

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

getAsByte

public byte getAsByte()

Returns:

Current value

set

public MutableByte set(byte var)

Parameters:

var - New value

Returns:

this object with mutated value

mutate

public MutableByte mutate(MutableByte.ByteFunction varFn)

Parameters:

varFn - New value

Returns:

this object with mutated value

accept

public void accept(java.lang.Byte t)

Specified by:

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

get

public java.lang.Byte get()

Specified by:

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