timed_latch.hpp

#pragma once
 
#include <utility>
 
#include "vipra/types/time.hpp"
 
#include "vipra/vipra_behaviors/values/numeric_value.hpp"
 
namespace VIPRA::Behaviors {

class TimedLatchCollection {
 public:
  explicit TimedLatchCollection(Behaviors::NumericValue value)
      : _duration(std::move(value))
  {
  }

  void resize(VIPRA::size latchCnt) { _startTimes.resize(latchCnt, -1); }

  void latch(VIPRA::time_s startTime, VIPRA::idx pedIdx)
  {
    if ( _startTimes[pedIdx] == -1 ) {
      _startTimes[pedIdx] = startTime;
    }
  }
 
  [[nodiscard]] auto size() const -> VIPRA::size { return _startTimes.size(); }

  auto check(VIPRA::time_s currTime, VIPRA::idx pedIdx) -> bool
  {
    if ( _startTimes[pedIdx] == -1 ) return false;
 
    VIPRA::f_pnt val = _duration.value(pedIdx);
    if ( currTime - _startTimes.at(pedIdx) >= val ) {
      _startTimes.at(pedIdx) = -1;
      return false;
    }
 
    return true;
  }

  auto get_duration(VIPRA::idx pedIdx) -> VIPRA::f_pnt { return _duration.value(pedIdx); }
 
 private:
  Behaviors::NumericValue    _duration;
  std::vector<VIPRA::time_s> _startTimes;

  static inline constexpr auto in_time_step(VIPRA::time_s  currTime,
                                            VIPRA::time_s  checkTime,
                                            VIPRA::delta_t deltaT) -> bool
  {
    const VIPRA::delta_t left = checkTime - deltaT;
    const VIPRA::delta_t right = checkTime + deltaT;
    return (currTime > left && currTime < right);
  }
};
}  // namespace VIPRA::Behaviors