zwave_tx_incoming_frames.hpp

Go to the documentation of this file.

/******************************************************************************
 * # License
 * <b>Copyright 2022 Silicon Laboratories Inc. www.silabs.com</b>
 ******************************************************************************
 * The licensor of this software is Silicon Laboratories Inc. Your use of this
 * software is governed by the terms of Silicon Labs Master Software License
 * Agreement (MSLA) available at
 * www.silabs.com/about-us/legal/master-software-license-agreement. This
 * software is distributed to you in Source Code format and is governed by the
 * sections of the MSLA applicable to Source Code.
 *
 *****************************************************************************/
 
#ifndef ZWAVE_TX_INCOMING_FRAMES_HPP
#define ZWAVE_TX_INCOMING_FRAMES_HPP
 
// Includes from this component
#include "zwave_tx.h"
#include "priority_queue.hpp"
 
// Includes from other components
#include "zwave_controller_types.h"
 
// Type definition for the number of frames to expect
using number_of_frames_t = uint8_t;
 
using zwave_tx_incoming_frame_item_t = struct zwave_tx_incoming_frame_item {
  // Remote NodeID that will send us some frames in the near future
  zwave_node_id_t node_id;
  // Number of frames that we expect to receive from NodeID
  number_of_frames_t incoming_frames;
};
 
struct incoming_frame_item_compare {
  bool operator()(const zwave_tx_incoming_frame_item_t &lhs,
                  const zwave_tx_incoming_frame_item_t &rhs) const
  {
    return lhs.node_id > rhs.node_id;
  }
};
 
// Class definition that keeps track of incoming frames
class zwave_tx_incoming_frames
{
  private:
  // List of frames that we expect from NodeIDs.
  priority_queue<zwave_tx_incoming_frame_item_t,
                 ZWAVE_TX_INCOMING_FRAMES_BUFFER_SIZE,
                 incoming_frame_item_compare>
    frame_list;
 
  sl_status_t insert(zwave_node_id_t node_id,
                     number_of_frames_t incoming_frames)
  {
    zwave_tx_incoming_frame_item_t item = {};
    item.node_id                        = node_id;
    item.incoming_frames                = incoming_frames;
    return (frame_list.insert(std::move(item)) == true ? SL_STATUS_OK
                                                       : SL_STATUS_FAIL);
  }
 
  public:
  sl_status_t set_frames(zwave_node_id_t node_id,
                         number_of_frames_t incoming_frames)
  {
    for (auto it = frame_list.begin(); it != frame_list.end(); ++it) {
      if (it->node_id == node_id) {
        // Decrement
        if (incoming_frames == 0) {
          frame_list.erase(it);
          return SL_STATUS_OK;
        } else {
          it->incoming_frames = incoming_frames;
          return SL_STATUS_OK;
        }
      }
    }
 
    // We don't know about this NodeID. Insert it.
    if (incoming_frames > 0) {
      return insert(node_id, incoming_frames);
    }
 
    return SL_STATUS_NOT_FOUND;
  }
 
  sl_status_t decrement_frames(zwave_node_id_t node_id)
  {
    for (auto it = frame_list.begin(); it != frame_list.end(); ++it) {
      if (it->node_id == node_id) {
        // Decrement
        if (it->incoming_frames <= 1) {
          frame_list.erase(it);
          return SL_STATUS_OK;
        } else {
          it->incoming_frames -= 1;
          return SL_STATUS_OK;
        }
      }
    }
    return SL_STATUS_NOT_FOUND;
  }
 
  number_of_frames_t get_frames(zwave_node_id_t node_id)
  {
    for (auto it = frame_list.begin(); it != frame_list.end(); ++it) {
      if (it->node_id == node_id) {
        return it->incoming_frames;
      }
    }
 
    // Not found, return no frame.
    return 0;
  }
 
  void clear()
  {
    frame_list.clear();
  }
 
  bool empty() const
  {
    return frame_list.empty();
  }
};
 
#endif  //ZWAVE_TX_INCOMING_FRAMES_HPP