fsfw/fsfw
fsfw/fsfw
10
3
Fork 6
Code Issues 31 Pull Requests 4 Releases 10 Wiki Activity

small tweak

Browse Source
This commit is contained in:
Robin Müller 2021-02-03 22:18:00 +01:00
parent cdb012fe5a
commit f7c1aae464
1 changed files with 225 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

442
pus/Service3Housekeeping.cpp
View File

@ -4,199 +4,199 @@
Service3Housekeeping::Service3Housekeeping(object_id_t objectId, uint16_t apid, Service3Housekeeping::Service3Housekeeping(object_id_t objectId, uint16_t apid,
uint8_t serviceId): uint8_t serviceId):
CommandingServiceBase(objectId, apid, serviceId, CommandingServiceBase(objectId, apid, serviceId,
NUM_OF_PARALLEL_COMMANDS, COMMAND_TIMEOUT_SECONDS) {} NUM_OF_PARALLEL_COMMANDS, COMMAND_TIMEOUT_SECONDS) {}
Service3Housekeeping::~Service3Housekeeping() {} Service3Housekeeping::~Service3Housekeeping() {}
ReturnValue_t Service3Housekeeping::isValidSubservice(uint8_t subservice) { ReturnValue_t Service3Housekeeping::isValidSubservice(uint8_t subservice) {
switch(static_cast<Subservice>(subservice)) { switch(static_cast<Subservice>(subservice)) {
case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION: case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION:
case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION: case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION:
case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION: case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION: case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
case Subservice::REPORT_HK_REPORT_STRUCTURES: case Subservice::REPORT_HK_REPORT_STRUCTURES:
case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES : case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES :
case Subservice::GENERATE_ONE_PARAMETER_REPORT: case Subservice::GENERATE_ONE_PARAMETER_REPORT:
case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT: case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT:
case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL: case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL:
case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL: case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL:
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
// Telemetry or invalid subservice. // Telemetry or invalid subservice.
case Subservice::HK_DEFINITIONS_REPORT: case Subservice::HK_DEFINITIONS_REPORT:
case Subservice::DIAGNOSTICS_DEFINITION_REPORT: case Subservice::DIAGNOSTICS_DEFINITION_REPORT:
case Subservice::HK_REPORT: case Subservice::HK_REPORT:
case Subservice::DIAGNOSTICS_REPORT: case Subservice::DIAGNOSTICS_REPORT:
default: default:
return AcceptsTelecommandsIF::INVALID_SUBSERVICE; return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
} }
} }
ReturnValue_t Service3Housekeeping::getMessageQueueAndObject(uint8_t subservice, ReturnValue_t Service3Housekeeping::getMessageQueueAndObject(uint8_t subservice,
const uint8_t *tcData, size_t tcDataLen, const uint8_t *tcData, size_t tcDataLen,
MessageQueueId_t *id, object_id_t *objectId) { MessageQueueId_t *id, object_id_t *objectId) {
ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen); ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen);
if(result != RETURN_OK) { if(result != RETURN_OK) {
return result; return result;
} }
return checkInterfaceAndAcquireMessageQueue(id,objectId); return checkInterfaceAndAcquireMessageQueue(id,objectId);
} }
ReturnValue_t Service3Housekeeping::checkAndAcquireTargetID( ReturnValue_t Service3Housekeeping::checkAndAcquireTargetID(
object_id_t* objectIdToSet, const uint8_t* tcData, size_t tcDataLen) { object_id_t* objectIdToSet, const uint8_t* tcData, size_t tcDataLen) {
if(SerializeAdapter::deSerialize(objectIdToSet, &tcData, &tcDataLen, if(SerializeAdapter::deSerialize(objectIdToSet, &tcData, &tcDataLen,
SerializeIF::Endianness::BIG) != HasReturnvaluesIF::RETURN_OK) { SerializeIF::Endianness::BIG) != HasReturnvaluesIF::RETURN_OK) {
return CommandingServiceBase::INVALID_TC; return CommandingServiceBase::INVALID_TC;
} }
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t Service3Housekeeping::checkInterfaceAndAcquireMessageQueue( ReturnValue_t Service3Housekeeping::checkInterfaceAndAcquireMessageQueue(
MessageQueueId_t* messageQueueToSet, object_id_t* objectId) { MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
// check HasLocalDataPoolIF property of target // check HasLocalDataPoolIF property of target
HasLocalDataPoolIF* possibleTarget = HasLocalDataPoolIF* possibleTarget =
objectManager->get<HasLocalDataPoolIF>(*objectId); objectManager->get<HasLocalDataPoolIF>(*objectId);
if(possibleTarget == nullptr){ if(possibleTarget == nullptr){
return CommandingServiceBase::INVALID_OBJECT; return CommandingServiceBase::INVALID_OBJECT;
} }
*messageQueueToSet = possibleTarget->getCommandQueue(); *messageQueueToSet = possibleTarget->getCommandQueue();
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t Service3Housekeeping::prepareCommand(CommandMessage* message, ReturnValue_t Service3Housekeeping::prepareCommand(CommandMessage* message,
uint8_t subservice, const uint8_t *tcData, size_t tcDataLen, uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
uint32_t *state, object_id_t objectId) { uint32_t *state, object_id_t objectId) {
switch(static_cast<Subservice>(subservice)) { switch(static_cast<Subservice>(subservice)) {
case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION: case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION:
return prepareReportingTogglingCommand(message, objectId, true, false, return prepareReportingTogglingCommand(message, objectId, true, false,
tcData, tcDataLen); tcData, tcDataLen);
case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION: case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION:
return prepareReportingTogglingCommand(message, objectId, false, false, return prepareReportingTogglingCommand(message, objectId, false, false,
tcData, tcDataLen); tcData, tcDataLen);
case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION: case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
return prepareReportingTogglingCommand(message, objectId, true, true, return prepareReportingTogglingCommand(message, objectId, true, true,
tcData, tcDataLen); tcData, tcDataLen);
case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION: case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
return prepareReportingTogglingCommand(message, objectId, false, true, return prepareReportingTogglingCommand(message, objectId, false, true,
tcData, tcDataLen); tcData, tcDataLen);
case Subservice::REPORT_HK_REPORT_STRUCTURES: case Subservice::REPORT_HK_REPORT_STRUCTURES:
return prepareStructureReportingCommand(message, objectId, false, tcData, return prepareStructureReportingCommand(message, objectId, false, tcData,
tcDataLen); tcDataLen);
case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES: case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES:
return prepareStructureReportingCommand(message, objectId, true, tcData, return prepareStructureReportingCommand(message, objectId, true, tcData,
tcDataLen); tcDataLen);
case Subservice::GENERATE_ONE_PARAMETER_REPORT: case Subservice::GENERATE_ONE_PARAMETER_REPORT:
return prepareOneShotReportCommand(message, objectId, false, return prepareOneShotReportCommand(message, objectId, false,
tcData, tcDataLen); tcData, tcDataLen);
case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT: case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT:
return prepareOneShotReportCommand(message, objectId, true, return prepareOneShotReportCommand(message, objectId, true,
tcData, tcDataLen); tcData, tcDataLen);
case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL: case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL:
return prepareCollectionIntervalModificationCommand(message, objectId, return prepareCollectionIntervalModificationCommand(message, objectId,
false, tcData, tcDataLen); false, tcData, tcDataLen);
case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL: case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL:
return prepareCollectionIntervalModificationCommand(message, objectId, return prepareCollectionIntervalModificationCommand(message, objectId,
true, tcData, tcDataLen); true, tcData, tcDataLen);
case Subservice::HK_DEFINITIONS_REPORT: case Subservice::HK_DEFINITIONS_REPORT:
case Subservice::DIAGNOSTICS_DEFINITION_REPORT: case Subservice::DIAGNOSTICS_DEFINITION_REPORT:
case Subservice::HK_REPORT: case Subservice::HK_REPORT:
case Subservice::DIAGNOSTICS_REPORT: case Subservice::DIAGNOSTICS_REPORT:
// Those are telemetry packets. // Those are telemetry packets.
return CommandingServiceBase::INVALID_TC; return CommandingServiceBase::INVALID_TC;
default: default:
// should never happen, subservice was already checked. // should never happen, subservice was already checked.
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t Service3Housekeeping::prepareReportingTogglingCommand( ReturnValue_t Service3Housekeeping::prepareReportingTogglingCommand(
CommandMessage *command, object_id_t objectId, CommandMessage *command, object_id_t objectId,
bool enableReporting, bool isDiagnostics, bool enableReporting, bool isDiagnostics,
const uint8_t* tcData, size_t tcDataLen) { const uint8_t* tcData, size_t tcDataLen) {
if(tcDataLen < sizeof(sid_t)) { if(tcDataLen < sizeof(sid_t)) {
// TC data should consist of object ID and set ID. // TC data should consist of object ID and set ID.
return CommandingServiceBase::INVALID_TC; return CommandingServiceBase::INVALID_TC;
} }
sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen); sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
HousekeepingMessage::setToggleReportingCommand(command, targetSid, HousekeepingMessage::setToggleReportingCommand(command, targetSid,
enableReporting, isDiagnostics); enableReporting, isDiagnostics);
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t Service3Housekeeping::prepareStructureReportingCommand( ReturnValue_t Service3Housekeeping::prepareStructureReportingCommand(
CommandMessage *command, object_id_t objectId, bool isDiagnostics, CommandMessage *command, object_id_t objectId, bool isDiagnostics,
const uint8_t* tcData, size_t tcDataLen) { const uint8_t* tcData, size_t tcDataLen) {
if(tcDataLen < sizeof(sid_t)) { if(tcDataLen < sizeof(sid_t)) {
// TC data should consist of object ID and set ID. // TC data should consist of object ID and set ID.
return CommandingServiceBase::INVALID_TC; return CommandingServiceBase::INVALID_TC;
} }
sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen); sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
HousekeepingMessage::setStructureReportingCommand(command, targetSid, HousekeepingMessage::setStructureReportingCommand(command, targetSid,
isDiagnostics); isDiagnostics);
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t Service3Housekeeping::prepareOneShotReportCommand( ReturnValue_t Service3Housekeeping::prepareOneShotReportCommand(
CommandMessage *command, object_id_t objectId, bool isDiagnostics, CommandMessage *command, object_id_t objectId, bool isDiagnostics,
const uint8_t *tcData, size_t tcDataLen) { const uint8_t *tcData, size_t tcDataLen) {
if(tcDataLen < sizeof(sid_t)) { if(tcDataLen < sizeof(sid_t)) {
// TC data should consist of object ID and set ID. // TC data should consist of object ID and set ID.
return CommandingServiceBase::INVALID_TC; return CommandingServiceBase::INVALID_TC;
} }
sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen); sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
HousekeepingMessage::setOneShotReportCommand(command, targetSid, HousekeepingMessage::setOneShotReportCommand(command, targetSid,
isDiagnostics); isDiagnostics);
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t Service3Housekeeping::prepareCollectionIntervalModificationCommand( ReturnValue_t Service3Housekeeping::prepareCollectionIntervalModificationCommand(
CommandMessage *command, object_id_t objectId, bool isDiagnostics, CommandMessage *command, object_id_t objectId, bool isDiagnostics,
const uint8_t *tcData, size_t tcDataLen) { const uint8_t *tcData, size_t tcDataLen) {
if(tcDataLen < sizeof(sid_t) + sizeof(float)) { if(tcDataLen < sizeof(sid_t) + sizeof(float)) {
// SID plus the size of the new collection intervL. // SID plus the size of the new collection intervL.
return CommandingServiceBase::INVALID_TC; return CommandingServiceBase::INVALID_TC;
} }
sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen); sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
float newCollectionInterval = 0; float newCollectionInterval = 0;
SerializeAdapter::deSerialize(&newCollectionInterval, &tcData, &tcDataLen, SerializeAdapter::deSerialize(&newCollectionInterval, &tcData, &tcDataLen,
SerializeIF::Endianness::BIG); SerializeIF::Endianness::BIG);
HousekeepingMessage::setCollectionIntervalModificationCommand(command, HousekeepingMessage::setCollectionIntervalModificationCommand(command,
targetSid, newCollectionInterval, isDiagnostics); targetSid, newCollectionInterval, isDiagnostics);
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply, ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
Command_t previousCommand, uint32_t *state, Command_t previousCommand, uint32_t *state,
CommandMessage* optionalNextCommand, object_id_t objectId, CommandMessage* optionalNextCommand, object_id_t objectId,
bool *isStep) { bool *isStep) {
Command_t command = reply->getCommand(); Command_t command = reply->getCommand();
switch(command) { switch(command) {
case(HousekeepingMessage::HK_REPORT): { case(HousekeepingMessage::HK_REPORT): {
ReturnValue_t result = generateHkReply(reply, ReturnValue_t result = generateHkReply(reply,
static_cast<uint8_t>(Subservice::HK_REPORT)); static_cast<uint8_t>(Subservice::HK_REPORT));
if(result != HasReturnvaluesIF::RETURN_OK) { if(result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
return CommandingServiceBase::EXECUTION_COMPLETE; return CommandingServiceBase::EXECUTION_COMPLETE;
} }
case(HousekeepingMessage::DIAGNOSTICS_REPORT): { case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
ReturnValue_t result = generateHkReply(reply, ReturnValue_t result = generateHkReply(reply,
static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT)); static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
if(result != HasReturnvaluesIF::RETURN_OK) { if(result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
return CommandingServiceBase::EXECUTION_COMPLETE; return CommandingServiceBase::EXECUTION_COMPLETE;
} }
case(HousekeepingMessage::HK_DEFINITIONS_REPORT): { case(HousekeepingMessage::HK_DEFINITIONS_REPORT): {
return generateHkReply(reply, static_cast<uint8_t>( return generateHkReply(reply, static_cast<uint8_t>(
@ -209,51 +209,59 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
break; break;
} }
case(HousekeepingMessage::HK_REQUEST_SUCCESS): { case(HousekeepingMessage::HK_REQUEST_SUCCESS): {
return CommandingServiceBase::EXECUTION_COMPLETE; return CommandingServiceBase::EXECUTION_COMPLETE;
} }
case(HousekeepingMessage::HK_REQUEST_FAILURE): { case(HousekeepingMessage::HK_REQUEST_FAILURE): {
failureParameter1 = objectId; failureParameter1 = objectId;
ReturnValue_t error = HasReturnvaluesIF::RETURN_FAILED; ReturnValue_t error = HasReturnvaluesIF::RETURN_FAILED;
HousekeepingMessage::getHkRequestFailureReply(reply,&error); HousekeepingMessage::getHkRequestFailureReply(reply,&error);
failureParameter2 = error; failureParameter2 = error;
return CommandingServiceBase::EXECUTION_COMPLETE; return CommandingServiceBase::EXECUTION_COMPLETE;
} }
default: default:
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "Service3Housekeeping::handleReply: Invalid reply with " sif::warning << "Service3Housekeeping::handleReply: Invalid reply with "
<< "reply command " << command << "!" << std::endl; << "reply command " << command << "!" << std::endl;
#else #else
sif::printWarning("Service3Housekeeping::handleReply: Invalid reply with " sif::printWarning("Service3Housekeeping::handleReply: Invalid reply with "
"reply command %hu!\n", command); "reply command %hu!\n", command);
#endif #endif
return CommandingServiceBase::INVALID_REPLY; return CommandingServiceBase::INVALID_REPLY;
} }
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
void Service3Housekeeping::handleUnrequestedReply( void Service3Housekeeping::handleUnrequestedReply(
CommandMessage* reply) { CommandMessage* reply) {
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
Command_t command = reply->getCommand(); Command_t command = reply->getCommand();
switch(command) { switch(command) {
case(HousekeepingMessage::DIAGNOSTICS_REPORT): { case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
result = generateHkReply(reply, result = generateHkReply(reply,
static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT)); static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
break; break;
} }
case(HousekeepingMessage::HK_REPORT): { case(HousekeepingMessage::HK_REPORT): {
result = generateHkReply(reply, result = generateHkReply(reply,
static_cast<uint8_t>(Subservice::HK_REPORT)); static_cast<uint8_t>(Subservice::HK_REPORT));
break; break;
} }
default: { case(HousekeepingMessage::HK_REQUEST_SUCCESS): {
break;
}
case(HousekeepingMessage::HK_REQUEST_FAILURE): {
break;
}
default: {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "Service3Housekeeping::handleUnrequestedReply: Invalid reply with reply " sif::warning << "Service3Housekeeping::handleUnrequestedReply: Invalid reply with reply "
"command " << command << "!" << std::endl; "command " << command << "!" << std::endl;
@ -262,49 +270,49 @@ void Service3Housekeeping::handleUnrequestedReply(
"reply command %hu!\n", command); "reply command %hu!\n", command);
#endif #endif
return; return;
} }
} }
if(result != HasReturnvaluesIF::RETURN_OK) { if(result != HasReturnvaluesIF::RETURN_OK) {
/* Configuration error */ /* Configuration error */
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "Service3Housekeeping::handleUnrequestedReply: Could not generate reply!" << sif::warning << "Service3Housekeeping::handleUnrequestedReply: Could not generate reply!" <<
std::endl; std::endl;
#else #else
sif::printWarning("Service3Housekeeping::handleUnrequestedReply: " sif::printWarning("Service3Housekeeping::handleUnrequestedReply: "
"Could not generate reply!\n"); "Could not generate reply!\n");
#endif #endif
} }
} }
MessageQueueId_t Service3Housekeeping::getHkQueue() const { MessageQueueId_t Service3Housekeeping::getHkQueue() const {
return commandQueue->getId(); return commandQueue->getId();
} }
ReturnValue_t Service3Housekeeping::generateHkReply( ReturnValue_t Service3Housekeeping::generateHkReply(
const CommandMessage* hkMessage, uint8_t subserviceId) { const CommandMessage* hkMessage, uint8_t subserviceId) {
store_address_t storeId; store_address_t storeId;
sid_t sid = HousekeepingMessage::getHkDataReply(hkMessage, &storeId); sid_t sid = HousekeepingMessage::getHkDataReply(hkMessage, &storeId);
auto resultPair = IPCStore->getData(storeId); auto resultPair = IPCStore->getData(storeId);
if(resultPair.first != HasReturnvaluesIF::RETURN_OK) { if(resultPair.first != HasReturnvaluesIF::RETURN_OK) {
return resultPair.first; return resultPair.first;
} }
HkPacket hkPacket(sid, resultPair.second.data(), resultPair.second.size()); HkPacket hkPacket(sid, resultPair.second.data(), resultPair.second.size());
return sendTmPacket(static_cast<uint8_t>(subserviceId), return sendTmPacket(static_cast<uint8_t>(subserviceId),
hkPacket.hkData, hkPacket.hkSize, nullptr, 0); hkPacket.hkData, hkPacket.hkSize, nullptr, 0);
} }
sid_t Service3Housekeeping::buildSid(object_id_t objectId, sid_t Service3Housekeeping::buildSid(object_id_t objectId,
const uint8_t** tcData, size_t* tcDataLen) { const uint8_t** tcData, size_t* tcDataLen) {
sid_t targetSid; sid_t targetSid;
targetSid.objectId = objectId; targetSid.objectId = objectId;
// skip deserialization of object ID, was already done. // skip deserialization of object ID, was already done.
*tcData += sizeof(object_id_t); *tcData += sizeof(object_id_t);
*tcDataLen -= sizeof(object_id_t); *tcDataLen -= sizeof(object_id_t);
// size check is expected to be performed beforehand! // size check is expected to be performed beforehand!
SerializeAdapter::deSerialize(&targetSid.ownerSetId, tcData, tcDataLen, SerializeAdapter::deSerialize(&targetSid.ownerSetId, tcData, tcDataLen,
SerializeIF::Endianness::BIG); SerializeIF::Endianness::BIG);
return targetSid; return targetSid;
} }