Digital_Voice_Modem_Project
/
dvmhost
mirror of https://github.com/DVMProject/dvmhost.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

more NULL to nullptr changes;

Browse Source
3.0-rcon_maint
Bryan Biedenkapp 3 years ago
parent 727a3eb155
commit daf09bd562
16 changed files with 94 additions and 94 deletions
Show Stats Download Patch File Download Diff File

16
nxdn/Audio.cpp
Unescape View File

@ -65,8 +65,8 @@ Audio::~Audio()
/// <param name="out"></param> /// <param name="out"></param>
void Audio::decode(const uint8_t* in, uint8_t* out) const void Audio::decode(const uint8_t* in, uint8_t* out) const
{ {
assert(in != NULL); assert(in != nullptr);
assert(out != NULL); assert(out != nullptr);
decode(in + 0U, out, 0U); decode(in + 0U, out, 0U);
decode(in + 9U, out, 49U); decode(in + 9U, out, 49U);
@ -79,8 +79,8 @@ void Audio::decode(const uint8_t* in, uint8_t* out) const
/// <param name="out"></param> /// <param name="out"></param>
void Audio::encode(const uint8_t* in, uint8_t* out) const void Audio::encode(const uint8_t* in, uint8_t* out) const
{ {
assert(in != NULL); assert(in != nullptr);
assert(out != NULL); assert(out != nullptr);
encode(in, out + 0U, 0U); encode(in, out + 0U, 0U);
encode(in, out + 9U, 49U); encode(in, out + 9U, 49U);
@ -98,8 +98,8 @@ void Audio::encode(const uint8_t* in, uint8_t* out) const
/// <param name="offset"></param> /// <param name="offset"></param>
void Audio::decode(const uint8_t* in, uint8_t* out, uint32_t offset) const void Audio::decode(const uint8_t* in, uint8_t* out, uint32_t offset) const
{ {
assert(in != NULL); assert(in != nullptr);
assert(out != NULL); assert(out != nullptr);
uint32_t a = 0U; uint32_t a = 0U;
uint32_t MASK = 0x800000U; uint32_t MASK = 0x800000U;
@ -154,8 +154,8 @@ void Audio::decode(const uint8_t* in, uint8_t* out, uint32_t offset) const
/// <param name="offset"></param> /// <param name="offset"></param>
void Audio::encode(const uint8_t* in, uint8_t* out, uint32_t offset) const void Audio::encode(const uint8_t* in, uint8_t* out, uint32_t offset) const
{ {
assert(in != NULL); assert(in != nullptr);
assert(out != NULL); assert(out != nullptr);
uint32_t aOrig = 0U; uint32_t aOrig = 0U;
uint32_t bOrig = 0U; uint32_t bOrig = 0U;

48
nxdn/Control.cpp
Unescape View File

@ -89,8 +89,8 @@ Control::Control(uint32_t ran, uint32_t callHang, uint32_t queueSize, uint32_t t
modem::Modem* modem, network::BaseNetwork* network, bool duplex, lookups::RadioIdLookup* ridLookup, modem::Modem* modem, network::BaseNetwork* network, bool duplex, lookups::RadioIdLookup* ridLookup,
lookups::TalkgroupIdLookup* tidLookup, lookups::IdenTableLookup* idenTable, lookups::RSSIInterpolator* rssiMapper, lookups::TalkgroupIdLookup* tidLookup, lookups::IdenTableLookup* idenTable, lookups::RSSIInterpolator* rssiMapper,
bool dumpRCCHData, bool debug, bool verbose) : bool dumpRCCHData, bool debug, bool verbose) :
m_voice(NULL), m_voice(nullptr),
m_data(NULL), m_data(nullptr),
m_ran(ran), m_ran(ran),
m_timeout(timeout), m_timeout(timeout),
m_modem(modem), m_modem(modem),
@ -135,10 +135,10 @@ Control::Control(uint32_t ran, uint32_t callHang, uint32_t queueSize, uint32_t t
m_verbose(verbose), m_verbose(verbose),
m_debug(debug) m_debug(debug)
{ {
assert(ridLookup != NULL); assert(ridLookup != nullptr);
assert(tidLookup != NULL); assert(tidLookup != nullptr);
assert(idenTable != NULL); assert(idenTable != nullptr);
assert(rssiMapper != NULL); assert(rssiMapper != nullptr);
acl::AccessControl::init(m_ridLookup, m_tidLookup); acl::AccessControl::init(m_ridLookup, m_tidLookup);
@ -155,15 +155,15 @@ Control::Control(uint32_t ran, uint32_t callHang, uint32_t queueSize, uint32_t t
/// </summary> /// </summary>
Control::~Control() Control::~Control()
{ {
if (m_voice != NULL) { if (m_voice != nullptr) {
delete m_voice; delete m_voice;
} }
if (m_trunk != NULL) { if (m_trunk != nullptr) {
delete m_trunk; delete m_trunk;
} }
if (m_data != NULL) { if (m_data != nullptr) {
delete m_data; delete m_data;
} }
} }
@ -176,11 +176,11 @@ void Control::reset()
m_rfState = RS_RF_LISTENING; m_rfState = RS_RF_LISTENING;
m_ccHalted = false; m_ccHalted = false;
if (m_voice != NULL) { if (m_voice != nullptr) {
m_voice->resetRF(); m_voice->resetRF();
} }
if (m_data != NULL) { if (m_data != nullptr) {
m_data->resetRF(); m_data->resetRF();
} }
@ -273,16 +273,16 @@ void Control::setOptions(yaml::Node& conf, const std::string cwCallsign, const s
LogInfo(" Verify Registration: %s", m_trunk->m_verifyReg ? "yes" : "no"); LogInfo(" Verify Registration: %s", m_trunk->m_verifyReg ? "yes" : "no");
} }
if (m_voice != NULL) { if (m_voice != nullptr) {
m_voice->resetRF(); m_voice->resetRF();
m_voice->resetNet(); m_voice->resetNet();
} }
if (m_data != NULL) { if (m_data != nullptr) {
m_data->resetRF(); m_data->resetRF();
} }
if (m_trunk != NULL) { if (m_trunk != nullptr) {
m_trunk->resetRF(); m_trunk->resetRF();
m_trunk->resetNet(); m_trunk->resetNet();
} }
@ -296,7 +296,7 @@ void Control::setOptions(yaml::Node& conf, const std::string cwCallsign, const s
/// <returns></returns> /// <returns></returns>
bool Control::processFrame(uint8_t* data, uint32_t len) bool Control::processFrame(uint8_t* data, uint32_t len)
{ {
assert(data != NULL); assert(data != nullptr);
uint8_t type = data[0U]; uint8_t type = data[0U];
bool sync = data[1U] == 0x01U; bool sync = data[1U] == 0x01U;
@ -455,7 +455,7 @@ bool Control::processFrame(uint8_t* data, uint32_t len)
/// <returns>Length of frame data retreived.</returns> /// <returns>Length of frame data retreived.</returns>
uint32_t Control::getFrame(uint8_t* data) uint32_t Control::getFrame(uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
if (m_queue.isEmpty()) if (m_queue.isEmpty())
return 0U; return 0U;
@ -473,7 +473,7 @@ uint32_t Control::getFrame(uint8_t* data)
/// <param name="ms"></param> /// <param name="ms"></param>
void Control::clock(uint32_t ms) void Control::clock(uint32_t ms)
{ {
if (m_network != NULL) { if (m_network != nullptr) {
processNetwork(); processNetwork();
if (m_network->getStatus() == network::NET_STAT_RUNNING) { if (m_network->getStatus() == network::NET_STAT_RUNNING) {
@ -553,7 +553,7 @@ void Control::clock(uint32_t ms)
} }
if (m_dedicatedControl) { if (m_dedicatedControl) {
if (m_network != NULL) if (m_network != nullptr)
m_network->resetNXDN(); m_network->resetNXDN();
} }
@ -574,14 +574,14 @@ void Control::clock(uint32_t ms)
m_data->resetRF(); m_data->resetRF();
if (m_network != NULL) if (m_network != nullptr)
m_network->resetNXDN(); m_network->resetNXDN();
m_rfState = RS_RF_LISTENING; m_rfState = RS_RF_LISTENING;
} }
// clock data and trunking // clock data and trunking
if (m_trunk != NULL) { if (m_trunk != nullptr) {
m_trunk->clock(ms); m_trunk->clock(ms);
} }
} }
@ -627,7 +627,7 @@ void Control::setRCCHVerbose(bool verbose)
/// <param name="net"></param> /// <param name="net"></param>
void Control::addFrame(const uint8_t *data, uint32_t length, bool net) void Control::addFrame(const uint8_t *data, uint32_t length, bool net)
{ {
assert(data != NULL); assert(data != nullptr);
if (!net) { if (!net) {
if (m_rfTimeout.isRunning() && m_rfTimeout.hasExpired()) if (m_rfTimeout.isRunning() && m_rfTimeout.hasExpired())
@ -677,7 +677,7 @@ void Control::processNetwork()
return; return;
if (length == 0U) if (length == 0U)
return; return;
if (data == NULL) { if (data == nullptr) {
m_network->resetNXDN(); m_network->resetNXDN();
return; return;
} }
@ -815,7 +815,7 @@ void Control::writeEndRF()
m_rfTimeout.stop(); m_rfTimeout.stop();
//m_queue.clear(); //m_queue.clear();
if (m_network != NULL) if (m_network != nullptr)
m_network->resetNXDN(); m_network->resetNXDN();
} }
@ -832,6 +832,6 @@ void Control::writeEndNet()
m_netTimeout.stop(); m_netTimeout.stop();
m_networkWatchdog.stop(); m_networkWatchdog.stop();
if (m_network != NULL) if (m_network != nullptr)
m_network->resetP25(); m_network->resetP25();
} }

18
nxdn/Convolution.cpp
Unescape View File

@ -59,12 +59,12 @@ const uint32_t K = 5U;
/// Initializes a new instance of the Convolution class. /// Initializes a new instance of the Convolution class.
/// </summary> /// </summary>
Convolution::Convolution() : Convolution::Convolution() :
m_metrics1(NULL), m_metrics1(nullptr),
m_metrics2(NULL), m_metrics2(nullptr),
m_oldMetrics(NULL), m_oldMetrics(nullptr),
m_newMetrics(NULL), m_newMetrics(nullptr),
m_decisions(NULL), m_decisions(nullptr),
m_dp(NULL) m_dp(nullptr)
{ {
m_metrics1 = new uint16_t[20U]; m_metrics1 = new uint16_t[20U];
m_metrics2 = new uint16_t[20U]; m_metrics2 = new uint16_t[20U];
@ -101,7 +101,7 @@ void Convolution::start()
/// <param name="nBits"></param> /// <param name="nBits"></param>
uint32_t Convolution::chainback(uint8_t* out, uint32_t nBits) uint32_t Convolution::chainback(uint8_t* out, uint32_t nBits)
{ {
assert(out != NULL); assert(out != nullptr);
uint32_t state = 0U; uint32_t state = 0U;
@ -173,8 +173,8 @@ bool Convolution::decode(uint8_t s0, uint8_t s1)
/// <param name="nBits"></param> /// <param name="nBits"></param>
void Convolution::encode(const uint8_t* in, uint8_t* out, uint32_t nBits) const void Convolution::encode(const uint8_t* in, uint8_t* out, uint32_t nBits) const
{ {
assert(in != NULL); assert(in != nullptr);
assert(out != NULL); assert(out != nullptr);
assert(nBits > 0U); assert(nBits > 0U);
uint8_t d1 = 0U, d2 = 0U, d3 = 0U, d4 = 0U; uint8_t d1 = 0U, d2 = 0U, d3 = 0U, d4 = 0U;

2
nxdn/NXDNUtils.cpp
Unescape View File

@ -57,7 +57,7 @@ const uint8_t SCRAMBLER[] = {
/// <param name="data"></param> /// <param name="data"></param>
void NXDNUtils::scrambler(uint8_t* data) void NXDNUtils::scrambler(uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
for (uint32_t i = 0U; i < NXDN_FRAME_LENGTH_BYTES; i++) for (uint32_t i = 0U; i < NXDN_FRAME_LENGTH_BYTES; i++)
data[i] ^= SCRAMBLER[i]; data[i] ^= SCRAMBLER[i];

2
nxdn/Sync.cpp
Unescape View File

@ -47,7 +47,7 @@ using namespace nxdn;
/// <param name="data"></param> /// <param name="data"></param>
void Sync::addNXDNSync(uint8_t* data) void Sync::addNXDNSync(uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
for (uint32_t i = 0U; i < NXDN_FSW_BYTES_LENGTH; i++) for (uint32_t i = 0U; i < NXDN_FSW_BYTES_LENGTH; i++)
data[i] = (data[i] & ~NXDN_FSW_BYTES_MASK[i]) | NXDN_FSW_BYTES[i]; data[i] = (data[i] & ~NXDN_FSW_BYTES_MASK[i]) | NXDN_FSW_BYTES[i];

12
nxdn/channel/CAC.cpp
Unescape View File

@ -124,7 +124,7 @@ CAC::CAC() :
m_idleBusy(true), m_idleBusy(true),
m_txContinuous(false), m_txContinuous(false),
m_receive(true), m_receive(true),
m_data(NULL), m_data(nullptr),
m_rxCRC(0U) m_rxCRC(0U)
{ {
m_data = new uint8_t[NXDN_CAC_CRC_LENGTH_BYTES]; m_data = new uint8_t[NXDN_CAC_CRC_LENGTH_BYTES];
@ -141,7 +141,7 @@ CAC::CAC(const CAC& data) :
m_idleBusy(true), m_idleBusy(true),
m_txContinuous(false), m_txContinuous(false),
m_receive(true), m_receive(true),
m_data(NULL), m_data(nullptr),
m_rxCRC(0U) m_rxCRC(0U)
{ {
copy(data); copy(data);
@ -185,7 +185,7 @@ CAC& CAC::operator=(const CAC& data)
/// <returns>True, if CAC was decoded, otherwise false.</returns> /// <returns>True, if CAC was decoded, otherwise false.</returns>
bool CAC::decode(const uint8_t* data) bool CAC::decode(const uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
uint8_t buffer[NXDN_CAC_IN_FEC_LENGTH_BYTES]; uint8_t buffer[NXDN_CAC_IN_FEC_LENGTH_BYTES];
::memset(buffer, 0x00U, NXDN_CAC_IN_FEC_LENGTH_BYTES); ::memset(buffer, 0x00U, NXDN_CAC_IN_FEC_LENGTH_BYTES);
@ -259,7 +259,7 @@ bool CAC::decode(const uint8_t* data)
/// <param name="data"></param> /// <param name="data"></param>
void CAC::encode(uint8_t* data) const void CAC::encode(uint8_t* data) const
{ {
assert(data != NULL); assert(data != nullptr);
m_data[0U] &= 0xC0U; m_data[0U] &= 0xC0U;
m_data[0U] |= m_ran; m_data[0U] |= m_ran;
@ -344,7 +344,7 @@ void CAC::encode(uint8_t* data) const
/// <param name="data"></param> /// <param name="data"></param>
void CAC::getData(uint8_t* data) const void CAC::getData(uint8_t* data) const
{ {
assert(data != NULL); assert(data != nullptr);
uint32_t offset = 8U; uint32_t offset = 8U;
for (uint32_t i = 0U; i < (NXDN_CAC_SHORT_LENGTH_BITS - 10); i++, offset++) { for (uint32_t i = 0U; i < (NXDN_CAC_SHORT_LENGTH_BITS - 10); i++, offset++) {
@ -359,7 +359,7 @@ void CAC::getData(uint8_t* data) const
/// <param name="data"></param> /// <param name="data"></param>
void CAC::setData(const uint8_t* data) void CAC::setData(const uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
::memset(m_data, 0x00U, NXDN_CAC_CRC_LENGTH_BYTES); ::memset(m_data, 0x00U, NXDN_CAC_CRC_LENGTH_BYTES);

12
nxdn/channel/FACCH1.cpp
Unescape View File

@ -72,7 +72,7 @@ const uint32_t PUNCTURE_LIST[] = {
/// Initializes a new instance of the FACCH1 class. /// Initializes a new instance of the FACCH1 class.
/// </summary> /// </summary>
FACCH1::FACCH1() : FACCH1::FACCH1() :
m_data(NULL) m_data(nullptr)
{ {
m_data = new uint8_t[NXDN_FACCH1_CRC_LENGTH_BYTES]; m_data = new uint8_t[NXDN_FACCH1_CRC_LENGTH_BYTES];
::memset(m_data, 0x00U, NXDN_FACCH1_CRC_LENGTH_BYTES); ::memset(m_data, 0x00U, NXDN_FACCH1_CRC_LENGTH_BYTES);
@ -83,7 +83,7 @@ FACCH1::FACCH1() :
/// </summary> /// </summary>
/// <param name="data"></param> /// <param name="data"></param>
FACCH1::FACCH1(const FACCH1& data) : FACCH1::FACCH1(const FACCH1& data) :
m_data(NULL) m_data(nullptr)
{ {
copy(data); copy(data);
} }
@ -117,7 +117,7 @@ FACCH1& FACCH1::operator=(const FACCH1& data)
/// <returns>True, if FACCH1 was decoded, otherwise false.</returns> /// <returns>True, if FACCH1 was decoded, otherwise false.</returns>
bool FACCH1::decode(const uint8_t* data, uint32_t offset) bool FACCH1::decode(const uint8_t* data, uint32_t offset)
{ {
assert(data != NULL); assert(data != nullptr);
uint8_t buffer[NXDN_FACCH1_FEC_LENGTH_BYTES]; uint8_t buffer[NXDN_FACCH1_FEC_LENGTH_BYTES];
::memset(buffer, 0x00U, NXDN_FACCH1_FEC_LENGTH_BYTES); ::memset(buffer, 0x00U, NXDN_FACCH1_FEC_LENGTH_BYTES);
@ -188,7 +188,7 @@ bool FACCH1::decode(const uint8_t* data, uint32_t offset)
/// <returns>True, if LICH was decoded, otherwise false.</returns> /// <returns>True, if LICH was decoded, otherwise false.</returns>
void FACCH1::encode(uint8_t* data, uint32_t offset) const void FACCH1::encode(uint8_t* data, uint32_t offset) const
{ {
assert(data != NULL); assert(data != nullptr);
uint8_t buffer[NXDN_FACCH1_CRC_LENGTH_BYTES]; uint8_t buffer[NXDN_FACCH1_CRC_LENGTH_BYTES];
::memset(buffer, 0x00U, NXDN_FACCH1_CRC_LENGTH_BYTES); ::memset(buffer, 0x00U, NXDN_FACCH1_CRC_LENGTH_BYTES);
@ -240,7 +240,7 @@ void FACCH1::encode(uint8_t* data, uint32_t offset) const
/// <param name="data"></param> /// <param name="data"></param>
void FACCH1::getData(uint8_t* data) const void FACCH1::getData(uint8_t* data) const
{ {
assert(data != NULL); assert(data != nullptr);
::memcpy(data, m_data, NXDN_FACCH1_CRC_LENGTH_BYTES - 2U); ::memcpy(data, m_data, NXDN_FACCH1_CRC_LENGTH_BYTES - 2U);
} }
@ -251,7 +251,7 @@ void FACCH1::getData(uint8_t* data) const
/// <param name="data"></param> /// <param name="data"></param>
void FACCH1::setData(const uint8_t* data) void FACCH1::setData(const uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
::memcpy(m_data, data, NXDN_FACCH1_CRC_LENGTH_BYTES - 2U); ::memcpy(m_data, data, NXDN_FACCH1_CRC_LENGTH_BYTES - 2U);
} }

4
nxdn/channel/LICH.cpp
Unescape View File

@ -104,7 +104,7 @@ LICH& LICH::operator=(const LICH& data)
/// <returns>True, if LICH was decoded, otherwise false.</returns> /// <returns>True, if LICH was decoded, otherwise false.</returns>
bool LICH::decode(const uint8_t* data) bool LICH::decode(const uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
uint8_t lich[1U]; uint8_t lich[1U];
::memset(lich, 0x00U, 1U); ::memset(lich, 0x00U, 1U);
@ -138,7 +138,7 @@ bool LICH::decode(const uint8_t* data)
/// <param name="data"></param> /// <param name="data"></param>
void LICH::encode(uint8_t* data) void LICH::encode(uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
m_lich = 0U; m_lich = 0U;

12
nxdn/channel/SACCH.cpp
Unescape View File

@ -67,7 +67,7 @@ const uint32_t PUNCTURE_LIST[] = { 5U, 11U, 17U, 23U, 29U, 35U, 41U, 47U, 53U, 5
SACCH::SACCH() : SACCH::SACCH() :
m_ran(0U), m_ran(0U),
m_structure(NXDN_SR_SINGLE), m_structure(NXDN_SR_SINGLE),
m_data(NULL) m_data(nullptr)
{ {
m_data = new uint8_t[NXDN_SACCH_CRC_LENGTH_BYTES]; m_data = new uint8_t[NXDN_SACCH_CRC_LENGTH_BYTES];
::memset(m_data, 0x00U, NXDN_SACCH_CRC_LENGTH_BYTES); ::memset(m_data, 0x00U, NXDN_SACCH_CRC_LENGTH_BYTES);
@ -80,7 +80,7 @@ SACCH::SACCH() :
SACCH::SACCH(const SACCH& data) : SACCH::SACCH(const SACCH& data) :
m_ran(0U), m_ran(0U),
m_structure(NXDN_SR_SINGLE), m_structure(NXDN_SR_SINGLE),
m_data(NULL) m_data(nullptr)
{ {
copy(data); copy(data);
} }
@ -117,7 +117,7 @@ SACCH& SACCH::operator=(const SACCH& data)
/// <returns>True, if SACCH was decoded, otherwise false.</returns> /// <returns>True, if SACCH was decoded, otherwise false.</returns>
bool SACCH::decode(const uint8_t* data) bool SACCH::decode(const uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
uint8_t buffer[NXDN_SACCH_FEC_LENGTH_BYTES]; uint8_t buffer[NXDN_SACCH_FEC_LENGTH_BYTES];
::memset(buffer, 0x00U, NXDN_SACCH_FEC_LENGTH_BYTES); ::memset(buffer, 0x00U, NXDN_SACCH_FEC_LENGTH_BYTES);
@ -192,7 +192,7 @@ bool SACCH::decode(const uint8_t* data)
/// <param name="data"></param> /// <param name="data"></param>
void SACCH::encode(uint8_t* data) const void SACCH::encode(uint8_t* data) const
{ {
assert(data != NULL); assert(data != nullptr);
m_data[0U] &= 0xC0U; m_data[0U] &= 0xC0U;
m_data[0U] |= m_ran; m_data[0U] |= m_ran;
@ -254,7 +254,7 @@ void SACCH::encode(uint8_t* data) const
/// <param name="data"></param> /// <param name="data"></param>
void SACCH::getData(uint8_t* data) const void SACCH::getData(uint8_t* data) const
{ {
assert(data != NULL); assert(data != nullptr);
uint32_t offset = 8U; uint32_t offset = 8U;
for (uint32_t i = 0U; i < (NXDN_SACCH_LENGTH_BITS - 8); i++, offset++) { for (uint32_t i = 0U; i < (NXDN_SACCH_LENGTH_BITS - 8); i++, offset++) {
@ -269,7 +269,7 @@ void SACCH::getData(uint8_t* data) const
/// <param name="data"></param> /// <param name="data"></param>
void SACCH::setData(const uint8_t* data) void SACCH::setData(const uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
uint32_t offset = 8U; uint32_t offset = 8U;
for (uint32_t i = 0U; i < (NXDN_SACCH_LENGTH_BITS - 8); i++, offset++) { for (uint32_t i = 0U; i < (NXDN_SACCH_LENGTH_BITS - 8); i++, offset++) {

12
nxdn/channel/UDCH.cpp
Unescape View File

@ -95,7 +95,7 @@ const uint32_t PUNCTURE_LIST[] = {
/// </summary> /// </summary>
UDCH::UDCH() : UDCH::UDCH() :
m_ran(0U), m_ran(0U),
m_data(NULL) m_data(nullptr)
{ {
m_data = new uint8_t[NXDN_UDCH_CRC_LENGTH_BYTES]; m_data = new uint8_t[NXDN_UDCH_CRC_LENGTH_BYTES];
::memset(m_data, 0x00U, NXDN_UDCH_CRC_LENGTH_BYTES); ::memset(m_data, 0x00U, NXDN_UDCH_CRC_LENGTH_BYTES);
@ -107,7 +107,7 @@ UDCH::UDCH() :
/// <param name="data"></param> /// <param name="data"></param>
UDCH::UDCH(const UDCH& data) : UDCH::UDCH(const UDCH& data) :
m_ran(0U), m_ran(0U),
m_data(NULL) m_data(nullptr)
{ {
copy(data); copy(data);
} }
@ -143,7 +143,7 @@ UDCH& UDCH::operator=(const UDCH& data)
/// <returns>True, if UDCH was decoded, otherwise false.</returns> /// <returns>True, if UDCH was decoded, otherwise false.</returns>
bool UDCH::decode(const uint8_t* data) bool UDCH::decode(const uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
uint8_t buffer[NXDN_UDCH_FEC_LENGTH_BYTES]; uint8_t buffer[NXDN_UDCH_FEC_LENGTH_BYTES];
::memset(buffer, 0x00U, NXDN_UDCH_FEC_LENGTH_BYTES); ::memset(buffer, 0x00U, NXDN_UDCH_FEC_LENGTH_BYTES);
@ -215,7 +215,7 @@ bool UDCH::decode(const uint8_t* data)
/// <param name="data"></param> /// <param name="data"></param>
void UDCH::encode(uint8_t* data) const void UDCH::encode(uint8_t* data) const
{ {
assert(data != NULL); assert(data != nullptr);
m_data[0U] = m_ran; m_data[0U] = m_ran;
@ -269,7 +269,7 @@ void UDCH::encode(uint8_t* data) const
/// <param name="data"></param> /// <param name="data"></param>
void UDCH::getData(uint8_t* data) const void UDCH::getData(uint8_t* data) const
{ {
assert(data != NULL); assert(data != nullptr);
::memcpy(data, m_data + 1U, NXDN_RTCH_LC_LENGTH_BYTES); ::memcpy(data, m_data + 1U, NXDN_RTCH_LC_LENGTH_BYTES);
} }
@ -280,7 +280,7 @@ void UDCH::getData(uint8_t* data) const
/// <param name="data"></param> /// <param name="data"></param>
void UDCH::setData(const uint8_t* data) void UDCH::setData(const uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
::memcpy(m_data + 1U, data, NXDN_RTCH_LC_LENGTH_BYTES); ::memcpy(m_data + 1U, data, NXDN_RTCH_LC_LENGTH_BYTES);
} }

4
nxdn/lc/PacketInformation.cpp
Unescape View File

@ -74,7 +74,7 @@ PacketInformation::~PacketInformation()
/// <returns>True, if packet information was decoded, otherwise false.</returns> /// <returns>True, if packet information was decoded, otherwise false.</returns>
bool PacketInformation::decode(const uint8_t messageType, const uint8_t* data) bool PacketInformation::decode(const uint8_t messageType, const uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
switch (messageType) switch (messageType)
{ {
@ -118,7 +118,7 @@ bool PacketInformation::decode(const uint8_t messageType, const uint8_t* data)
/// <param name="data"></param> /// <param name="data"></param>
void PacketInformation::encode(const uint8_t messageType, uint8_t* data) void PacketInformation::encode(const uint8_t messageType, uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
switch (messageType) switch (messageType)
{ {

8
nxdn/lc/RCCH.cpp
Unescape View File

@ -105,7 +105,7 @@ RCCH& RCCH::operator=(const RCCH& data)
/// <returns>True, if RCCH was decoded, otherwise false.</returns> /// <returns>True, if RCCH was decoded, otherwise false.</returns>
void RCCH::decode(const uint8_t* data, uint32_t length, uint32_t offset) void RCCH::decode(const uint8_t* data, uint32_t length, uint32_t offset)
{ {
assert(data != NULL); assert(data != nullptr);
uint8_t rcch[22U]; uint8_t rcch[22U];
::memset(rcch, 0x00U, NXDN_RCCH_LC_LENGTH_BYTES + 4U); ::memset(rcch, 0x00U, NXDN_RCCH_LC_LENGTH_BYTES + 4U);
@ -130,7 +130,7 @@ void RCCH::decode(const uint8_t* data, uint32_t length, uint32_t offset)
/// <param name="offset"></param> /// <param name="offset"></param>
void RCCH::encode(uint8_t* data, uint32_t length, uint32_t offset) void RCCH::encode(uint8_t* data, uint32_t length, uint32_t offset)
{ {
assert(data != NULL); assert(data != nullptr);
uint8_t rcch[22U]; uint8_t rcch[22U];
::memset(rcch, 0x00U, NXDN_RCCH_LC_LENGTH_BYTES + 4U); ::memset(rcch, 0x00U, NXDN_RCCH_LC_LENGTH_BYTES + 4U);
@ -244,7 +244,7 @@ RCCH::RCCH(SiteData siteData) :
/// <returns></returns> /// <returns></returns>
bool RCCH::decodeLC(const uint8_t* data) bool RCCH::decodeLC(const uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
m_messageType = data[0U] & 0x3FU; // Message Type m_messageType = data[0U] & 0x3FU; // Message Type
@ -303,7 +303,7 @@ bool RCCH::decodeLC(const uint8_t* data)
/// <param name="rs"></param> /// <param name="rs"></param>
void RCCH::encodeLC(uint8_t* data) void RCCH::encodeLC(uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
data[0U] = m_messageType & 0x3FU; // Message Type data[0U] = m_messageType & 0x3FU; // Message Type

8
nxdn/lc/RTCH.cpp
Unescape View File

@ -129,7 +129,7 @@ RTCH& RTCH::operator=(const RTCH& data)
/// <returns>True, if RTCH was decoded, otherwise false.</returns> /// <returns>True, if RTCH was decoded, otherwise false.</returns>
void RTCH::decode(const uint8_t* data, uint32_t length, uint32_t offset) void RTCH::decode(const uint8_t* data, uint32_t length, uint32_t offset)
{ {
assert(data != NULL); assert(data != nullptr);
uint8_t rtch[NXDN_RTCH_LC_LENGTH_BYTES]; uint8_t rtch[NXDN_RTCH_LC_LENGTH_BYTES];
::memset(rtch, 0x00U, NXDN_RTCH_LC_LENGTH_BYTES); ::memset(rtch, 0x00U, NXDN_RTCH_LC_LENGTH_BYTES);
@ -154,7 +154,7 @@ void RTCH::decode(const uint8_t* data, uint32_t length, uint32_t offset)
/// <param name="offset"></param> /// <param name="offset"></param>
void RTCH::encode(uint8_t* data, uint32_t length, uint32_t offset) void RTCH::encode(uint8_t* data, uint32_t length, uint32_t offset)
{ {
assert(data != NULL); assert(data != nullptr);
uint8_t rtch[NXDN_RTCH_LC_LENGTH_BYTES]; uint8_t rtch[NXDN_RTCH_LC_LENGTH_BYTES];
::memset(rtch, 0x00U, NXDN_RTCH_LC_LENGTH_BYTES); ::memset(rtch, 0x00U, NXDN_RTCH_LC_LENGTH_BYTES);
@ -213,7 +213,7 @@ void RTCH::reset()
/// <returns></returns> /// <returns></returns>
bool RTCH::decodeLC(const uint8_t* data) bool RTCH::decodeLC(const uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
m_messageType = data[0U] & 0x3FU; // Message Type m_messageType = data[0U] & 0x3FU; // Message Type
@ -329,7 +329,7 @@ bool RTCH::decodeLC(const uint8_t* data)
/// <param name="rs"></param> /// <param name="rs"></param>
void RTCH::encodeLC(uint8_t* data) void RTCH::encodeLC(uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
data[0U] = m_messageType & 0x3FU; // Message Type data[0U] = m_messageType & 0x3FU; // Message Type

8
nxdn/packet/Data.cpp
Unescape View File

@ -180,7 +180,7 @@ void Data::resetNet()
/// <returns></returns> /// <returns></returns>
bool Data::process(uint8_t option, uint8_t* data, uint32_t len) bool Data::process(uint8_t option, uint8_t* data, uint32_t len)
{ {
assert(data != NULL); assert(data != nullptr);
channel::UDCH udch; channel::UDCH udch;
bool validUDCH = udch.decode(data + 2U); bool validUDCH = udch.decode(data + 2U);
@ -288,7 +288,7 @@ bool Data::process(uint8_t option, uint8_t* data, uint32_t len)
/// <returns></returns> /// <returns></returns>
bool Data::processNetwork(uint8_t option, lc::RTCH& netLC, uint8_t* data, uint32_t len) bool Data::processNetwork(uint8_t option, lc::RTCH& netLC, uint8_t* data, uint32_t len)
{ {
assert(data != NULL); assert(data != nullptr);
if (m_nxdn->m_netState == RS_NET_IDLE) { if (m_nxdn->m_netState == RS_NET_IDLE) {
m_nxdn->m_queue.clear(); m_nxdn->m_queue.clear();
@ -419,9 +419,9 @@ Data::~Data()
/// <param name="len"></param> /// <param name="len"></param>
void Data::writeNetwork(const uint8_t *data, uint32_t len) void Data::writeNetwork(const uint8_t *data, uint32_t len)
{ {
assert(data != NULL); assert(data != nullptr);
if (m_network == NULL) if (m_network == nullptr)
return; return;
if (m_nxdn->m_rfTimeout.isRunning() && m_nxdn->m_rfTimeout.hasExpired()) if (m_nxdn->m_rfTimeout.isRunning() && m_nxdn->m_rfTimeout.hasExpired())

14
nxdn/packet/Trunk.cpp
Unescape View File

@ -143,7 +143,7 @@ void Trunk::resetNet()
/// <returns></returns> /// <returns></returns>
bool Trunk::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len) bool Trunk::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
{ {
assert(data != NULL); assert(data != nullptr);
channel::CAC cac; channel::CAC cac;
bool validCAC = cac.decode(data + 2U); bool validCAC = cac.decode(data + 2U);
@ -232,7 +232,7 @@ bool Trunk::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
/// <returns></returns> /// <returns></returns>
bool Trunk::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t* data, uint32_t len) bool Trunk::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t* data, uint32_t len)
{ {
assert(data != NULL); assert(data != nullptr);
if (m_nxdn->m_netState == RS_NET_IDLE) { if (m_nxdn->m_netState == RS_NET_IDLE) {
m_nxdn->m_queue.clear(); m_nxdn->m_queue.clear();
@ -251,7 +251,7 @@ bool Trunk::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t
void Trunk::clock(uint32_t ms) void Trunk::clock(uint32_t ms)
{ {
if (m_nxdn->m_control) { if (m_nxdn->m_control) {
if (m_nxdn->m_network != NULL) { if (m_nxdn->m_network != nullptr) {
if (m_nxdn->m_network->isHandlingChGrants() && m_nxdn->m_siteData.netActive()) { if (m_nxdn->m_network->isHandlingChGrants() && m_nxdn->m_siteData.netActive()) {
bool grp = true; bool grp = true;
uint32_t srcId = 0U; uint32_t srcId = 0U;
@ -316,9 +316,9 @@ Trunk::~Trunk()
/// <param name="len"></param> /// <param name="len"></param>
void Trunk::writeNetwork(const uint8_t *data, uint32_t len) void Trunk::writeNetwork(const uint8_t *data, uint32_t len)
{ {
assert(data != NULL); assert(data != nullptr);
if (m_network == NULL) if (m_network == nullptr)
return; return;
if (m_nxdn->m_rfTimeout.isRunning() && m_nxdn->m_rfTimeout.hasExpired()) if (m_nxdn->m_rfTimeout.isRunning() && m_nxdn->m_rfTimeout.hasExpired())
@ -438,7 +438,7 @@ bool Trunk::writeRF_Message_Grant(bool grp, bool skip, bool net, bool skipNetChe
uint8_t messageType = m_rfLC.getMessageType(); uint8_t messageType = m_rfLC.getMessageType();
// do we have a network connection and are we handling grants at the network? // do we have a network connection and are we handling grants at the network?
if (m_nxdn->m_network != NULL) { if (m_nxdn->m_network != nullptr) {
if (m_nxdn->m_network->isHandlingChGrants() && m_nxdn->m_siteData.netActive() && !skipNetCheck) { if (m_nxdn->m_network->isHandlingChGrants() && m_nxdn->m_siteData.netActive() && !skipNetCheck) {
return m_nxdn->m_network->writeGrantReq(grp, m_rfLC.getSrcId(), m_rfLC.getDstId()); return m_nxdn->m_network->writeGrantReq(grp, m_rfLC.getSrcId(), m_rfLC.getDstId());
} }
@ -779,7 +779,7 @@ void Trunk::writeRF_CC_Message_Service_Info()
/// <param name="data"></param> /// <param name="data"></param>
void Trunk::addPostBits(uint8_t* data) void Trunk::addPostBits(uint8_t* data)
{ {
assert(data != NULL); assert(data != nullptr);
// post field // post field
for (uint32_t i = 0U; i < NXDN_CAC_E_POST_FIELD_BITS; i++) { for (uint32_t i = 0U; i < NXDN_CAC_E_POST_FIELD_BITS; i++) {

8
nxdn/packet/Voice.cpp
Unescape View File

@ -187,7 +187,7 @@ void Voice::resetNet()
/// <returns></returns> /// <returns></returns>
bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len) bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
{ {
assert(data != NULL); assert(data != nullptr);
channel::SACCH sacch; channel::SACCH sacch;
bool valid = sacch.decode(data + 2U); bool valid = sacch.decode(data + 2U);
@ -621,7 +621,7 @@ bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
/// <returns></returns> /// <returns></returns>
bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t *data, uint32_t len) bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t *data, uint32_t len)
{ {
assert(data != NULL); assert(data != nullptr);
if (m_nxdn->m_netState == RS_NET_IDLE) { if (m_nxdn->m_netState == RS_NET_IDLE) {
m_nxdn->m_queue.clear(); m_nxdn->m_queue.clear();
@ -1016,9 +1016,9 @@ Voice::~Voice()
/// <param name="len"></param> /// <param name="len"></param>
void Voice::writeNetwork(const uint8_t *data, uint32_t len) void Voice::writeNetwork(const uint8_t *data, uint32_t len)
{ {
assert(data != NULL); assert(data != nullptr);
if (m_network == NULL) if (m_network == nullptr)
return; return;
if (m_nxdn->m_rfTimeout.isRunning() && m_nxdn->m_rfTimeout.hasExpired()) if (m_nxdn->m_rfTimeout.isRunning() && m_nxdn->m_rfTimeout.hasExpired())

Write Preview
Loading…
Cancel
Save

Powered by TurnKey Linux.