Common Reactive

// specify an event propagating
// a String as the event data
Event<String> event = Event.event();

// an observer manages the listeners
// for an Event but can not trigger it
Observer<String> observer = event.observer();

// add a listener if you're not
// interested in the event data
observer.addListener(() -> System.out.println("Event occurred"));

event.run();//output: 'Event occurred'

// or a consumer if you're
// interested in the event data
observer.addConsumer(data -> System.out.println("Event: " + data));

event.accept("info");//output: 'Event: info'

// Event implements Observer so
// listeneres can be added directly without
// referring to the Observer
event.addConsumer(System.out::println);

private void observer() {
  // React to a specific value or predicate
  Value<Integer> value = Value.nullable();

  value.when(1)
          .addListener(() -> System.out.println("Value is one"));

  value.when(2)
          .addConsumer(System.out::println);

  value.when(Objects::isNull)
          .addListener(() -> System.out.println("Value is null"));

  value.when(1)
          .addListener(() -> System.out.println("one"));
  value.when(2)
          .addListener(() -> System.out.println("two"));
  value.when(v -> v > 10)
          .addConsumer(v -> System.out.println("Large value: " + v));

  // React to boolean states
  State enabled = State.builder()
          .when(true, () -> System.out.println("Enabled"))
          .when(false, () -> System.out.println("Disabled"))
          .build();
}

// a nullable value with 2 as the initial value
Value<Integer> value =
        Value.nullable(2);

value.set(4);

// a non-null value using 0 as null substitute
Value<Integer> otherValue =
        Value.nonNull(0);

// linked to the value above
value.link(otherValue);

System.out.println(otherValue.get());// output: 0

otherValue.set(3);

System.out.println(value.get());// output: 3

System.out.println(value.is(3));// output: true

value.set(null);

System.out.println(otherValue.get());// output: 0

value.addConsumer(System.out::println);

otherValue.addListener(() ->
        System.out.println("Value changed: " + otherValue.get()));

Integer initialValue = 42;
Integer nullValue = 0;

Value<Integer> value =
        Value.builder()
                .nonNull(nullValue)
                .value(initialValue)
                .build();

System.out.println(value.isNullable());//output: false

System.out.println(value.get());// output: 42

value.set(null); //or value.clear();

value.isNull(); //output: false;

System.out.println(value.get());//output: 0

// a boolean state, false by default
State state = State.state();

// an observable manages the listeners for a State but can not modify it
ObservableState observable = state.observable();
// a not observable is always available, which is
// always the reverse of the original state
ObservableState not = state.not();

// add a listener notified each time the state changes
observable.addListener(() -> System.out.println("State changed"));

state.set(true);//output: 'State changed'

observable.addConsumer(value -> System.out.println("State: " + value));

state.set(false);//output: 'State: false'

// State extends ObservableState so listeners can be added
// directly without referring to the ObservableState
state.addListener(() -> System.out.println("State changed"));

private static final class IntegerValue {

  private final State negative = State.state(false);
  private final Value<Integer> integer = Value.builder()
          .nonNull(0)
          .consumer(value -> negative.set(value < 0))
          .build();

  /**
   * Increment the value by one
   */
  public void increment() {
    integer.update(value -> value + 1);
  }

  /**
   * Decrement the value by one
   */
  public void decrement() {
    integer.update(value -> value - 1);
  }

  /**
   * @return an observer notified each time the value changes
   */
  public Observer<Integer> changed() {
    return integer.observable();
  }

  /**
   * @return a state observer indicating whether the value is negative
   */
  public ObservableState negative() {
    return negative.observable();
  }
}