BooleanEvent.java

// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
 
package org.wpilib.event;
 
import static org.wpilib.units.Units.Seconds;
import static org.wpilib.util.ErrorMessages.requireNonNullParam;
 
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.BiFunction;
import java.util.function.BooleanSupplier;
import org.wpilib.math.filter.Debouncer;
import org.wpilib.units.measure.Time;

public class BooleanEvent implements BooleanSupplier {
  protected final EventLoop m_loop;
 
  private final BooleanSupplier m_signal;

  private final AtomicBoolean m_state = new AtomicBoolean(false);

  public BooleanEvent(EventLoop loop, BooleanSupplier signal) {
    m_loop = requireNonNullParam(loop, "loop", "BooleanEvent");
    m_signal = requireNonNullParam(signal, "signal", "BooleanEvent");
    m_state.set(m_signal.getAsBoolean());
    m_loop.bind(() -> m_state.set(m_signal.getAsBoolean()));
  }

  @Override
  public final boolean getAsBoolean() {
    return m_state.get();
  }

  public final void ifHigh(Runnable action) {
    m_loop.bind(
        () -> {
          if (m_state.get()) {
            action.run();
          }
        });
  }

  public <T extends BooleanSupplier> T castTo(BiFunction<EventLoop, BooleanSupplier, T> ctor) {
    return ctor.apply(m_loop, m_state::get);
  }

  public BooleanEvent negate() {
    return new BooleanEvent(m_loop, () -> !m_state.get());
  }

  public BooleanEvent and(BooleanSupplier other) {
    requireNonNullParam(other, "other", "and");
    return new BooleanEvent(m_loop, () -> m_state.get() && other.getAsBoolean());
  }

  public BooleanEvent or(BooleanSupplier other) {
    requireNonNullParam(other, "other", "or");
    return new BooleanEvent(m_loop, () -> m_state.get() || other.getAsBoolean());
  }

  public BooleanEvent rising() {
    return new BooleanEvent(
        m_loop,
        new BooleanSupplier() {
          private boolean m_previous = m_state.get();
 
          @Override
          public boolean getAsBoolean() {
            boolean present = m_state.get();
            boolean ret = !m_previous && present;
            m_previous = present;
            return ret;
          }
        });
  }

  public BooleanEvent falling() {
    return new BooleanEvent(
        m_loop,
        new BooleanSupplier() {
          private boolean m_previous = m_state.get();
 
          @Override
          public boolean getAsBoolean() {
            boolean present = m_state.get();
            boolean ret = m_previous && !present;
            m_previous = present;
            return ret;
          }
        });
  }

  public BooleanEvent debounce(Time period) {
    return debounce(period.in(Seconds));
  }

  public BooleanEvent debounce(double seconds) {
    return debounce(seconds, Debouncer.DebounceType.RISING);
  }

  public BooleanEvent debounce(Time period, Debouncer.DebounceType type) {
    return debounce(period.in(Seconds), type);
  }

  public BooleanEvent debounce(double seconds, Debouncer.DebounceType type) {
    return new BooleanEvent(
        m_loop,
        new BooleanSupplier() {
          private final Debouncer m_debouncer = new Debouncer(seconds, type);
 
          @Override
          public boolean getAsBoolean() {
            return m_debouncer.calculate(m_state.get());
          }
        });
  }
}