32bool ConnData::IsDriverStatsMatch(
const DriverStats& ds)
 const {
 
   33  return ds.driver_bus == driver_stats.driver_bus &&
 
   34         ds.driver_iface == driver_stats.driver_iface;
 
   37bool ConnData::IsDriverMatch(NavAddr::Bus bus, 
const std::string& iface)
 const {
 
   38  return driver_stats.driver_bus == bus && driver_stats.driver_iface == iface;
 
   41std::string ConnData::to_string() {
 
   46ConnStates::ConnStates() {
 
   47  auto& registry = CommDriverRegistry::GetInstance();
 
   48  m_driverlist_lstnr.
Init(registry.evt_driverlist_change,
 
   50  m_driverstat_lstnr.
Init(registry.evt_driver_stats,
 
   54void ConnStates::HandleDriverStats(
const DriverStats& stats) {
 
   55  auto conn_params = TheConnectionParams();
 
   56  auto found_param = std::find_if(
 
   58        return cp->GetStrippedDSPort() == stats.driver_iface &&
 
   59               cp->GetCommProtocol() == stats.driver_bus;
 
   61  bool disabled = found_param != conn_params.end() && !(*found_param)->bEnabled;
 
   62  auto found_state = std::find_if(
 
   63      m_states.begin(), m_states.end(),
 
   64      [stats](
ConnData& cd) { return cd.IsDriverStatsMatch(stats); });
 
   65  if (found_state == m_states.end()) {
 
   67    data.state = ConnState::NoStats;
 
   68    data.driver_stats = stats;
 
   69    m_states.push_back(data);
 
   72    ConnState old_state = found_state->state;
 
   73    if (!stats.available) {
 
   74      found_state->state = ConnState::Unavailable;
 
   75    } 
else if (found_state->driver_stats.rx_count == stats.
rx_count &&
 
   76               found_state->driver_stats.tx_count == stats.
tx_count) {
 
   77      found_state->state = ConnState::NoData;
 
   79      found_state->state = ConnState::Ok;
 
   81    found_state->driver_stats = stats;
 
   82    if (found_state->state != old_state)
 
   88ConnState ConnStates::GetDriverState(NavAddr::Bus bus,
 
   89                                     const std::string& iface) {
 
   90  auto found = std::find_if(
 
   91      m_states.begin(), m_states.end(),
 
   92      [bus, iface](
ConnData& cd) { return cd.IsDriverMatch(bus, iface); });
 
   93  return found == m_states.end() ? ConnState::NoStats : found->state;
 
   97void ConnStates::OnDriverListChange(
const ObservedEvt&) {
 
   98  auto& drivers = CommDriverRegistry::GetInstance().
GetDrivers();
 
   99  auto end = std::remove_if(m_states.begin(), m_states.end(), [&](
ConnData cd) {
 
  100    return FindDriver(drivers, cd.driver_stats.driver_iface,
 
  101                      cd.driver_stats.driver_bus) == nullptr;
 
  103  m_states.erase(end, m_states.end());
 
  106void ConnStates::OnDriverStats(
const ObservedEvt& ev) {
 
  107  auto stats_ptr = UnpackEvtPointer<DriverStats>(ev);
 
  108  if (stats_ptr) HandleDriverStats(*stats_ptr);
 
const std::vector< DriverPtr > & GetDrivers() const
Runtime data for a driver and thus connection.
EventVar evt_conn_status_change
Notified with a shared_ptr<ConnData> when the state is changed.
void Notify() override
Notify all listeners, no data supplied.
void Init(const KeyProvider &kp, const std::function< void(ObservedEvt &ev)> &action)
Initiate an object yet not listening.
Custom event class for OpenCPN's notification system.
Communication statistics infrastructure.
Runtime connection/driver state definitions.
Driver statistics report.
unsigned tx_count
Number of bytes sent since program start.
unsigned rx_count
Number of bytes received since program start.