fly316/PX4-Autopilot
7
0
Fork 0
mirror of https://gitee.com/mirrors_PX4/PX4-Autopilot.git synced 2026-10-21 10:53:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

Style fix: All constants are CamelCase now

Browse Source
This commit is contained in:
Pavel Kirienko
2014-02-21 18:45:23 +04:00
parent a155e6f859
commit 47a2b01a14
41 changed files with 473 additions and 472 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libuavcan/src/can_driver.cpp
+11 -11
View File
@@ -10,17 +10,17 @@
namespace uavcan
{
const uint32_t CanFrame::MASK_STDID;
const uint32_t CanFrame::MASK_EXTID;
const uint32_t CanFrame::FLAG_EFF;
const uint32_t CanFrame::FLAG_RTR;
const uint32_t CanFrame::MaskStdID;
const uint32_t CanFrame::MaskExtID;
const uint32_t CanFrame::FlagEFF;
const uint32_t CanFrame::FlagRTR;
std::string CanFrame::toString(StringRepresentation mode) const
{
using std::snprintf;
assert(mode == STR_TIGHT || mode == STR_ALIGNED);
assert(mode == StrTight || mode == StrAligned);
static const int ASCII_COLUMN_OFFSET = 36;
@@ -28,17 +28,17 @@ std::string CanFrame::toString(StringRepresentation mode) const
char* wpos = buf, *epos = buf + sizeof(buf);
std::fill(buf, buf + sizeof(buf), 0);
if (id & FLAG_EFF)
if (id & FlagEFF)
{
wpos += snprintf(wpos, epos - wpos, "0x%08x ", (unsigned int)(id & MASK_EXTID));
wpos += snprintf(wpos, epos - wpos, "0x%08x ", (unsigned int)(id & MaskExtID));
}
else
{
const char* const fmt = (mode == STR_ALIGNED) ? " 0x%03x " : "0x%03x ";
wpos += snprintf(wpos, epos - wpos, fmt, (unsigned int)(id & MASK_STDID));
const char* const fmt = (mode == StrAligned) ? " 0x%03x " : "0x%03x ";
wpos += snprintf(wpos, epos - wpos, fmt, (unsigned int)(id & MaskStdID));
}
if (id & FLAG_RTR)
if (id & FlagRTR)
{
wpos += snprintf(wpos, epos - wpos, " RTR");
}
@@ -47,7 +47,7 @@ std::string CanFrame::toString(StringRepresentation mode) const
for (int dlen = 0; dlen < dlc; dlen++) // hex bytes
wpos += snprintf(wpos, epos - wpos, " %02x", (unsigned int)data[dlen]);
while (mode == STR_ALIGNED && wpos < buf + ASCII_COLUMN_OFFSET) // alignment
while (mode == StrAligned && wpos < buf + ASCII_COLUMN_OFFSET) // alignment
*wpos++ = ' ';
wpos += snprintf(wpos, epos - wpos, " \'"); // ascii
libuavcan/src/marshalling/bit_stream.cpp
+8 -8
View File
@@ -12,11 +12,11 @@ namespace uavcan
int BitStream::write(const uint8_t* bytes, const int bitlen)
{
// Temporary buffer is needed to merge new bits with cached unaligned bits from the last write() (see byte_cache_)
uint8_t tmp[MAX_BYTES_PER_RW + 1];
uint8_t tmp[MaxBytesPerRW + 1];
// Tmp space must be large enough to accomodate new bits AND unaligned bits from the last write()
const int bytelen = bitlenToBytelen(bitlen + (bit_offset_ % 8));
assert(MAX_BYTES_PER_RW >= bytelen);
assert(MaxBytesPerRW >= bytelen);
tmp[0] = tmp[bytelen - 1] = 0;
std::fill(tmp, tmp + bytelen, 0);
@@ -39,29 +39,29 @@ int BitStream::write(const uint8_t* bytes, const int bitlen)
if (write_res < 0)
return write_res;
if (write_res < bytelen)
return RESULT_OUT_OF_BUFFER;
return ResultOutOfBuffer;
bit_offset_ = new_bit_offset;
return RESULT_OK;
return ResultOk;
}
int BitStream::read(uint8_t* bytes, const int bitlen)
{
uint8_t tmp[MAX_BYTES_PER_RW + 1];
uint8_t tmp[MaxBytesPerRW + 1];
const int bytelen = bitlenToBytelen(bitlen + (bit_offset_ % 8));
assert(MAX_BYTES_PER_RW >= bytelen);
assert(MaxBytesPerRW >= bytelen);
const int read_res = buf_.read(bit_offset_ / 8, tmp, bytelen);
if (read_res < 0)
return read_res;
if (read_res < bytelen)
return RESULT_OUT_OF_BUFFER;
return ResultOutOfBuffer;
std::fill(bytes, bytes + bitlenToBytelen(bitlen), 0);
copyBitArray(tmp, bit_offset_ % 8, bitlen, bytes, 0);
bit_offset_ += bitlen;
return RESULT_OK;
return ResultOk;
}
std::string BitStream::toString() const
libuavcan/src/transport/can_io.cpp
+7 -7
View File
@@ -55,10 +55,10 @@ std::string CanTxQueue::Entry::toString() const
std::string str_qos;
switch (qos)
{
case VOLATILE:
case Volatile:
str_qos = "<volat> ";
break;
case PERSISTENT:
case Persistent:
str_qos = "<perst> ";
break;
default:
@@ -196,7 +196,7 @@ bool CanTxQueue::topPriorityHigherOrEqual(const CanFrame& rhs_frame) const
*/
int CanIOManager::sendToIface(int iface_index, const CanFrame& frame, uint64_t monotonic_tx_deadline)
{
assert(iface_index >= 0 && iface_index < MAX_IFACES);
assert(iface_index >= 0 && iface_index < MaxIfaces);
ICanIface* const iface = driver_.getIface(iface_index);
if (iface == NULL)
{
@@ -216,7 +216,7 @@ int CanIOManager::sendToIface(int iface_index, const CanFrame& frame, uint64_t m
int CanIOManager::sendFromTxQueue(int iface_index)
{
assert(iface_index >= 0 && iface_index < MAX_IFACES);
assert(iface_index >= 0 && iface_index < MaxIfaces);
CanTxQueue::Entry* entry = tx_queues_[iface_index].peek();
if (entry == NULL)
return 0;
@@ -246,14 +246,14 @@ uint64_t CanIOManager::getTimeUntilMonotonicDeadline(uint64_t monotonic_deadline
int CanIOManager::getNumIfaces() const
{
const int num = driver_.getNumIfaces();
assert(num > 0 && num <= MAX_IFACES);
return std::min(std::max(num, 0), (int)MAX_IFACES);
assert(num > 0 && num <= MaxIfaces);
return std::min(std::max(num, 0), (int)MaxIfaces);
}
uint64_t CanIOManager::getNumErrors(int iface_index) const
{
ICanIface* const iface = driver_.getIface(iface_index);
if (iface == NULL || iface_index >= MAX_IFACES || iface_index < 0)
if (iface == NULL || iface_index >= MaxIfaces || iface_index < 0)
{
assert(0);
return std::numeric_limits<uint64_t>::max();
libuavcan/src/transport/crc.cpp
+2 -2
View File
@@ -9,7 +9,7 @@ namespace uavcan
{
// print ', '.join(map(lambda x: '%04x' % x, map(lambda x: int(x, 0), c.crc_ccitt_tab)))
const uint16_t Crc16::TABLE[256] =
const uint16_t Crc16::Table[256] =
{
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
@@ -47,7 +47,7 @@ const uint16_t Crc16::TABLE[256] =
uint16_t Crc16::add(uint8_t byte)
{
value_ = (value_ << 8) ^ TABLE[((value_ >> 8) ^ byte) & 0xFF];
value_ = (value_ << 8) ^ Table[((value_ >> 8) ^ byte) & 0xFF];
return value_;
}
libuavcan/src/transport/dispatcher.cpp
+12 -12
View File
@@ -13,7 +13,7 @@ namespace uavcan
*/
bool Dispatcher::ListenerRegister::add(TransferListenerBase* listener, Mode mode)
{
if (mode == UNIQUE_LISTENER)
if (mode == UniqueListener)
{
TransferListenerBase* p = list_.get();
while (p)
@@ -68,7 +68,7 @@ void Dispatcher::handleFrame(const CanRxFrame& can_frame)
return;
}
if ((frame.getDstNodeID() != NodeID::BROADCAST) &&
if ((frame.getDstNodeID() != NodeID::Broadcast) &&
(frame.getDstNodeID() != getSelfNodeID()))
{
return;
@@ -76,16 +76,16 @@ void Dispatcher::handleFrame(const CanRxFrame& can_frame)
switch (frame.getTransferType())
{
case TRANSFER_TYPE_MESSAGE_BROADCAST:
case TRANSFER_TYPE_MESSAGE_UNICAST:
case TransferTypeMessageBroadcast:
case TransferTypeMessageUnicast:
lmsg_.handleFrame(frame);
break;
case TRANSFER_TYPE_SERVICE_REQUEST:
case TransferTypeServiceRequest:
lsrv_req_.handleFrame(frame);
break;
case TRANSFER_TYPE_SERVICE_RESPONSE:
case TransferTypeServiceResponse:
lsrv_resp_.handleFrame(frame);
break;
@@ -145,32 +145,32 @@ void Dispatcher::cleanup(uint64_t ts_monotonic)
bool Dispatcher::registerMessageListener(TransferListenerBase* listener)
{
if (listener->getDataTypeDescriptor().kind != DATA_TYPE_KIND_MESSAGE)
if (listener->getDataTypeDescriptor().kind != DataTypeKindMessage)
{
assert(0);
return false;
}
return lmsg_.add(listener, ListenerRegister::MANY_LISTENERS); // Multiple subscribers are OK
return lmsg_.add(listener, ListenerRegister::ManyListeners); // Multiple subscribers are OK
}
bool Dispatcher::registerServiceRequestListener(TransferListenerBase* listener)
{
if (listener->getDataTypeDescriptor().kind != DATA_TYPE_KIND_SERVICE)
if (listener->getDataTypeDescriptor().kind != DataTypeKindService)
{
assert(0);
return false;
}
return lsrv_req_.add(listener, ListenerRegister::UNIQUE_LISTENER); // Only one server per data type
return lsrv_req_.add(listener, ListenerRegister::UniqueListener); // Only one server per data type
}
bool Dispatcher::registerServiceResponseListener(TransferListenerBase* listener)
{
if (listener->getDataTypeDescriptor().kind != DATA_TYPE_KIND_SERVICE)
if (listener->getDataTypeDescriptor().kind != DataTypeKindService)
{
assert(0);
return false;
}
return lsrv_resp_.add(listener, ListenerRegister::MANY_LISTENERS); // Multiple callers may call same srv
return lsrv_resp_.add(listener, ListenerRegister::ManyListeners); // Multiple callers may call same srv
}
void Dispatcher::unregisterMessageListener(TransferListenerBase* listener)
libuavcan/src/transport/transfer.cpp
+24 -24
View File
@@ -12,7 +12,7 @@ namespace uavcan
/**
* NodeID
*/
const NodeID NodeID::BROADCAST(VALUE_BROADCAST);
const NodeID NodeID::Broadcast(ValueBroadcast);
/**
* TransferID
@@ -21,9 +21,9 @@ int TransferID::forwardDistance(TransferID rhs) const
{
int d = int(rhs.get()) - int(get());
if (d < 0)
d += 1 << BITLEN;
d += 1 << BitLen;
assert(((get() + d) & MAX) == rhs.get());
assert(((get() + d) & Max) == rhs.get());
return d;
}
@@ -34,13 +34,13 @@ int Frame::getMaxPayloadLen() const
{
switch (getTransferType())
{
case TRANSFER_TYPE_MESSAGE_BROADCAST:
case TransferTypeMessageBroadcast:
return sizeof(payload_);
break;
case TRANSFER_TYPE_SERVICE_RESPONSE:
case TRANSFER_TYPE_SERVICE_REQUEST:
case TRANSFER_TYPE_MESSAGE_UNICAST:
case TransferTypeServiceResponse:
case TransferTypeServiceRequest:
case TransferTypeMessageUnicast:
return sizeof(payload_) - 1;
break;
@@ -69,7 +69,7 @@ inline static uint32_t bitunpack(uint32_t val)
bool Frame::parse(const CanFrame& can_frame)
{
if ((can_frame.id & CanFrame::FLAG_RTR) || !(can_frame.id & CanFrame::FLAG_EFF))
if ((can_frame.id & CanFrame::FlagRTR) || !(can_frame.id & CanFrame::FlagEFF))
return false;
if (can_frame.dlc > sizeof(CanFrame::data))
@@ -81,7 +81,7 @@ bool Frame::parse(const CanFrame& can_frame)
/*
* CAN ID parsing
*/
const uint32_t id = can_frame.id & CanFrame::MASK_EXTID;
const uint32_t id = can_frame.id & CanFrame::MaskExtID;
transfer_id_ = bitunpack<0, 3>(id);
last_frame_ = bitunpack<3, 1>(id);
frame_index_ = bitunpack<4, 6>(id);
@@ -94,15 +94,15 @@ bool Frame::parse(const CanFrame& can_frame)
*/
switch (transfer_type_)
{
case TRANSFER_TYPE_MESSAGE_BROADCAST:
dst_node_id_ = NodeID::BROADCAST;
case TransferTypeMessageBroadcast:
dst_node_id_ = NodeID::Broadcast;
payload_len_ = can_frame.dlc;
std::copy(can_frame.data, can_frame.data + can_frame.dlc, payload_);
break;
case TRANSFER_TYPE_SERVICE_RESPONSE:
case TRANSFER_TYPE_SERVICE_REQUEST:
case TRANSFER_TYPE_MESSAGE_UNICAST:
case TransferTypeServiceResponse:
case TransferTypeServiceRequest:
case TransferTypeMessageUnicast:
if (can_frame.dlc < 1)
return false;
if (can_frame.data[0] & 0x80) // RESERVED, must be zero
@@ -133,7 +133,7 @@ bool Frame::compile(CanFrame& out_can_frame) const
return false;
}
out_can_frame.id = CanFrame::FLAG_EFF |
out_can_frame.id = CanFrame::FlagEFF |
bitpack<0, 3>(transfer_id_.get()) |
bitpack<3, 1>(last_frame_) |
bitpack<4, 6>(frame_index_) |
@@ -143,14 +143,14 @@ bool Frame::compile(CanFrame& out_can_frame) const
switch (transfer_type_)
{
case TRANSFER_TYPE_MESSAGE_BROADCAST:
case TransferTypeMessageBroadcast:
out_can_frame.dlc = payload_len_;
std::copy(payload_, payload_ + payload_len_, out_can_frame.data);
break;
case TRANSFER_TYPE_SERVICE_RESPONSE:
case TRANSFER_TYPE_SERVICE_REQUEST:
case TRANSFER_TYPE_MESSAGE_UNICAST:
case TransferTypeServiceResponse:
case TransferTypeServiceRequest:
case TransferTypeMessageUnicast:
assert((payload_len_ + 1) <= sizeof(CanFrame::data));
out_can_frame.data[0] = dst_node_id_.get();
out_can_frame.dlc = payload_len_ + 1;
@@ -168,15 +168,15 @@ bool Frame::isValid() const
{
// Refer to the specification for the detailed explanation of the checks
const bool invalid =
(frame_index_ > INDEX_MAX) ||
((frame_index_ == INDEX_MAX) && !last_frame_) ||
(frame_index_ > MaxIndex) ||
((frame_index_ == MaxIndex) && !last_frame_) ||
(!src_node_id_.isUnicast()) ||
(!dst_node_id_.isValid()) ||
(src_node_id_ == dst_node_id_) ||
((transfer_type_ == TRANSFER_TYPE_MESSAGE_BROADCAST) != dst_node_id_.isBroadcast()) ||
(transfer_type_ >= NUM_TRANSFER_TYPES) ||
((transfer_type_ == TransferTypeMessageBroadcast) != dst_node_id_.isBroadcast()) ||
(transfer_type_ >= NumTransferTypes) ||
(payload_len_ > getMaxPayloadLen()) ||
(data_type_id_ > DATA_TYPE_ID_MAX);
(data_type_id_ > MaxDataTypeID);
return !invalid;
}
libuavcan/src/transport/transfer_buffer.cpp
+2 -2
View File
@@ -45,7 +45,7 @@ void DynamicTransferBufferManagerEntry::Block::read(uint8_t*& outptr, unsigned i
unsigned int& total_offset, unsigned int& left_to_read)
{
assert(outptr);
for (int i = 0; (i < Block::SIZE) && (left_to_read > 0); i++, total_offset++)
for (int i = 0; (i < Block::Size) && (left_to_read > 0); i++, total_offset++)
{
if (total_offset >= target_offset)
{
@@ -59,7 +59,7 @@ void DynamicTransferBufferManagerEntry::Block::write(const uint8_t*& inptr, unsi
unsigned int& total_offset, unsigned int& left_to_write)
{
assert(inptr);
for (int i = 0; (i < Block::SIZE) && (left_to_write > 0); i++, total_offset++)
for (int i = 0; (i < Block::Size) && (left_to_write > 0); i++, total_offset++)
{
if (total_offset >= target_offset)
{
libuavcan/src/transport/transfer_listener.cpp
+3 -3
View File
@@ -97,17 +97,17 @@ void TransferListenerBase::handleReception(TransferReceiver& receiver, const RxF
{
switch (receiver.addFrame(frame, tba))
{
case TransferReceiver::RESULT_NOT_COMPLETE:
case TransferReceiver::ResultNotComplete:
return;
case TransferReceiver::RESULT_SINGLE_FRAME:
case TransferReceiver::ResultSingleFrame:
{
SingleFrameIncomingTransfer it(frame);
handleIncomingTransfer(it);
return;
}
case TransferReceiver::RESULT_COMPLETE:
case TransferReceiver::ResultComplete:
{
const ITransferBuffer* tbb = tba.access();
if (tbb == NULL)
libuavcan/src/transport/transfer_receiver.cpp
+26 -27
View File
@@ -8,24 +8,23 @@
#include <algorithm>
#include <uavcan/internal/debug.hpp>
#include <uavcan/internal/transport/transfer_receiver.hpp>
#include <uavcan/internal/transport/crc.hpp>
namespace uavcan
{
static const int CRC_LEN = 2;
const uint32_t TransferReceiver::DEFAULT_TRANSFER_INTERVAL;
const uint32_t TransferReceiver::MIN_TRANSFER_INTERVAL;
const uint32_t TransferReceiver::MAX_TRANSFER_INTERVAL;
const uint32_t TransferReceiver::DefaultTransferInterval;
const uint32_t TransferReceiver::MinTransferInterval;
const uint32_t TransferReceiver::MaxTransferInterval;
TransferReceiver::TidRelation TransferReceiver::getTidRelation(const RxFrame& frame) const
{
const int distance = tid_.forwardDistance(frame.getTransferID());
if (distance == 0)
return TID_SAME;
if (distance < ((1 << TransferID::BITLEN) / 2))
return TID_FUTURE;
return TID_REPEAT;
return TidSame;
if (distance < ((1 << TransferID::BitLen) / 2))
return TidFuture;
return TidRepeat;
}
void TransferReceiver::updateTransferTimings()
@@ -40,7 +39,7 @@ void TransferReceiver::updateTransferTimings()
(prev_transfer_ts_monotonic_ >= prev_prev_ts))
{
uint64_t interval = prev_transfer_ts_monotonic_ - prev_prev_ts;
interval = std::max(std::min(interval, uint64_t(MAX_TRANSFER_INTERVAL)), uint64_t(MIN_TRANSFER_INTERVAL));
interval = std::max(std::min(interval, uint64_t(MaxTransferInterval)), uint64_t(MinTransferInterval));
transfer_interval_ = static_cast<uint32_t>((uint64_t(transfer_interval_) * 7 + interval) / 8);
}
}
@@ -57,13 +56,13 @@ bool TransferReceiver::validate(const RxFrame& frame) const
if (iface_index_ != frame.getIfaceIndex())
return false;
if (frame.isFirst() && !frame.isLast() && (frame.getPayloadLen() < CRC_LEN))
if (frame.isFirst() && !frame.isLast() && (frame.getPayloadLen() < Crc16::NumBytes))
{
UAVCAN_TRACE("TransferReceiver", "CRC expected, %s", frame.toString().c_str());
return false;
}
if ((frame.getIndex() == Frame::INDEX_MAX) && !frame.isLast())
if ((frame.getIndex() == Frame::MaxIndex) && !frame.isLast())
{
UAVCAN_TRACE("TransferReceiver", "Unterminated transfer, %s", frame.toString().c_str());
return false;
@@ -76,7 +75,7 @@ bool TransferReceiver::validate(const RxFrame& frame) const
return false;
}
if (getTidRelation(frame) != TID_SAME)
if (getTidRelation(frame) != TidSame)
{
UAVCAN_TRACE("TransferReceiver", "Unexpected TID (current %i), %s", tid_.get(), frame.toString().c_str());
return false;
@@ -91,13 +90,13 @@ bool TransferReceiver::writePayload(const RxFrame& frame, ITransferBuffer& buf)
if (frame.isFirst()) // First frame contains CRC, we need to extract it now
{
if (frame.getPayloadLen() < CRC_LEN) // Must have been validated earlier though. I think I'm paranoid.
if (frame.getPayloadLen() < Crc16::NumBytes) // Must have been validated earlier though. I think I'm paranoid.
return false;
this_transfer_crc_ = (payload[0] & 0xFF) | (uint16_t(payload[1] & 0xFF) << 8); // Little endian.
const int effective_payload_len = payload_len - CRC_LEN;
const int res = buf.write(buffer_write_pos_, payload + CRC_LEN, effective_payload_len);
const int effective_payload_len = payload_len - Crc16::NumBytes;
const int res = buf.write(buffer_write_pos_, payload + Crc16::NumBytes, effective_payload_len);
const bool success = res == effective_payload_len;
if (success)
buffer_write_pos_ += effective_payload_len;
@@ -128,7 +127,7 @@ TransferReceiver::ResultCode TransferReceiver::receive(const RxFrame& frame, Tra
updateTransferTimings();
prepareForNextTransfer();
this_transfer_crc_ = 0; // SFT has no CRC
return RESULT_SINGLE_FRAME;
return ResultSingleFrame;
}
// Payload write
@@ -139,14 +138,14 @@ TransferReceiver::ResultCode TransferReceiver::receive(const RxFrame& frame, Tra
{
UAVCAN_TRACE("TransferReceiver", "Failed to access the buffer, %s", frame.toString().c_str());
prepareForNextTransfer();
return RESULT_NOT_COMPLETE;
return ResultNotComplete;
}
if (!writePayload(frame, *buf))
{
UAVCAN_TRACE("TransferReceiver", "Payload write failed, %s", frame.toString().c_str());
tba.remove();
prepareForNextTransfer();
return RESULT_NOT_COMPLETE;
return ResultNotComplete;
}
next_frame_index_++;
@@ -154,14 +153,14 @@ TransferReceiver::ResultCode TransferReceiver::receive(const RxFrame& frame, Tra
{
updateTransferTimings();
prepareForNextTransfer();
return RESULT_COMPLETE;
return ResultComplete;
}
return RESULT_NOT_COMPLETE;
return ResultNotComplete;
}
bool TransferReceiver::isTimedOut(uint64_t ts_monotonic) const
{
static const uint64_t INTERVAL_MULT = (1 << TransferID::BITLEN) / 2 + 1;
static const uint64_t INTERVAL_MULT = (1 << TransferID::BitLen) / 2 + 1;
const uint64_t ts = this_transfer_ts_monotonic_;
if (ts_monotonic <= ts)
return false;
@@ -174,7 +173,7 @@ TransferReceiver::ResultCode TransferReceiver::addFrame(const RxFrame& frame, Tr
(frame.getMonotonicTimestamp() < prev_transfer_ts_monotonic_) ||
(frame.getMonotonicTimestamp() < this_transfer_ts_monotonic_))
{
return RESULT_NOT_COMPLETE;
return ResultNotComplete;
}
const bool not_initialized = !isInitialized();
@@ -188,8 +187,8 @@ TransferReceiver::ResultCode TransferReceiver::addFrame(const RxFrame& frame, Tr
const bool need_restart = // FSM, the hard way
(not_initialized) ||
(receiver_timed_out) ||
(same_iface && first_fame && (tid_rel == TID_FUTURE)) ||
(iface_timed_out && first_fame && (tid_rel == TID_FUTURE));
(same_iface && first_fame && (tid_rel == TidFuture)) ||
(iface_timed_out && first_fame && (tid_rel == TidFuture));
if (need_restart)
{
@@ -206,12 +205,12 @@ TransferReceiver::ResultCode TransferReceiver::addFrame(const RxFrame& frame, Tr
if (!first_fame)
{
tid_.increment();
return RESULT_NOT_COMPLETE;
return ResultNotComplete;
}
}
if (!validate(frame))
return RESULT_NOT_COMPLETE;
return ResultNotComplete;
return receive(frame, tba);
}