LineData.hpp

#ifndef ZAO_ENDPOINT_MONITOR_LINE_DATA_HPP_
#define ZAO_ENDPOINT_MONITOR_LINE_DATA_HPP_
 
#include <vector>
 
namespace zao {
namespace endpoint {
namespace monitor {
 
struct LineDataEntry {
 public:
  LineDataEntry() noexcept {}
 
  LineDataEntry(bool active, std::uint32_t remain, std::uint32_t send_packets,
                std::uint32_t timeout_count, std::uint32_t nack_count,
                std::uint32_t resend_packets, std::uint32_t est_rate,
                std::uint32_t act_rate, std::uint32_t rtt,
                std::uint32_t recv_packets, std::uint32_t recv_rate) noexcept
      : active_(active),
        remain_(remain),
        send_packets_(send_packets),
        timeout_count_(timeout_count),
        nack_count_(nack_count),
        resend_packets_(resend_packets),
        est_rate_(est_rate),
        act_rate_(act_rate),
        rtt_(rtt),
        recv_packets_(recv_packets),
        recv_rate_(recv_rate) {}
  bool active_ = false;
  std::uint32_t remain_ = 0;
  std::uint32_t send_packets_ = 0;
  std::uint32_t timeout_count_ = 0;
  std::uint32_t nack_count_ = 0;
  std::uint32_t resend_packets_ = 0;
  std::uint32_t est_rate_ = 0;
  std::uint32_t act_rate_ = 0;
  std::uint32_t rtt_ = 0;
  std::uint32_t recv_packets_ = 0;
  std::uint32_t recv_rate_ = 0;
};
 
class LineData {
 public:
  LineData() noexcept {}
 
  void SetLineData(const LineDataEntry& line_data) noexcept {
    line_data_.push_back(line_data);
  }
 
  std::vector<LineDataEntry> GetLineData() const noexcept { return line_data_; }
 
  bool GetLineData(std::uint8_t number,
                   LineDataEntry& line_data) const noexcept {
    auto index = number - 1;
    if (index < static_cast<std::uint8_t>(line_data_.size())) {
      line_data = line_data_.at(index);
      return true;
    }
    return false;
  }
 
 private:
  std::vector<LineDataEntry> line_data_;
};
 
}  // namespace monitor
}  // namespace endpoint
}  // namespace zao
 
#endif  // ZAO_ENDPOINT_MONITOR_LINE_DATA_HPP_