modbusException.hpp

// Modbus for c++ <https://github.com/Mazurel/Modbus>
// Copyright (c) 2020 Mateusz Mazur aka Mazurel
// Licensed under: MIT License <http://opensource.org/licenses/MIT>
 
#pragma once
 
#include <cstdint>
#include <cstring>
#include <stdexcept>
#include <vector>
 
#include "modbusUtils.hpp"
 
namespace MB {
class ModbusException : public std::exception {
  private:
    uint8_t _slaveId;
    bool _validSlave;
    utils::MBErrorCode _errorCode;
    utils::MBFunctionCode _functionCode;
 
  public:
    // We do not allow default CTORs: https://github.com/Mazurel/Modbus/issues/6
    ModbusException() = delete;
 
    explicit ModbusException(const std::vector<uint8_t> &inputData,
                             bool CRC = false) noexcept;
 
    explicit ModbusException(
        utils::MBErrorCode errorCode, uint8_t slaveId = 0xFF,
        utils::MBFunctionCode functionCode = utils::Undefined) noexcept
        : _slaveId(slaveId), _validSlave(true), _errorCode(errorCode),
          _functionCode(functionCode) {}
 
    /*
     * Check if there is Modbus error in raw modbus input
     * NOTE: this method doesn't detect invalid byte order, byte order is
     * checked at ModbusRequest/ModbusResponse
     * */
    static bool exist(const std::vector<uint8_t> &inputData) noexcept {
        if (inputData.size() < 2) // TODO Figure out better solution to such mistake
            return false;
 
        return inputData[1] & 0b10000000;
    }
 
    /*
     *  Returns attached SlaveID
     *  NOTE: it is worth to check if slaveId is specified with isSlaveValid()
     * */
    [[nodiscard]] uint8_t slaveID() const noexcept { return _slaveId; }
 
    [[nodiscard]] bool isSlaveValid() const noexcept { return _validSlave; }
 
    void setSlaveID(uint8_t slaveId) noexcept {
        _validSlave = true;
        _slaveId    = slaveId;
    }
 
    [[nodiscard]] utils::MBErrorCode getErrorCode() const noexcept { return _errorCode; }
 
    [[nodiscard]] const char *what() const noexcept override {
        auto og   = toString();
        char *str = new char[og.size()];
        stpcpy(str, og.c_str());
        return str;
    }
 
    [[nodiscard]] std::string toString() const noexcept;
    [[nodiscard]] std::vector<uint8_t> toRaw() const noexcept;
 
    [[nodiscard]] utils::MBFunctionCode functionCode() const noexcept {
        return _functionCode;
    }
 
    void setFunctionCode(utils::MBFunctionCode functionCode) noexcept {
        _functionCode = functionCode;
    }
};
} // namespace MB