diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/ComponentCppWriter.scala b/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/ComponentCppWriter.scala index cedf06d86..84fe54485 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/ComponentCppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/ComponentCppWriter.scala @@ -536,7 +536,6 @@ case class ComponentCppWriter ( ) ), List(s"Fw::${kindStr}ComponentBase(compName)") ::: - (if (hasExternalParameters) List("paramDelegatePtr(nullptr)") else Nil) ::: smInstancesByName.map { (name, smi) => val sm = s.a.stateMachineMap(smi.symbol) val hasActionsOrGuards = sm.hasActions || sm.hasGuards @@ -555,9 +554,6 @@ case class ComponentCppWriter ( throttledEventsWithTimeout.map((_, event) => line( s"this->${eventThrottleTimeName(event.getName)} = Fw::Time();" )), - sortedParams.flatMap((_, param) => guardedList(!param.isExternal) ( - lines(s"this->${paramValidityFlagName(param.getName)} = Fw::ParamValid::UNINIT;") - )) ) ) ), diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/ComponentCppWriterUtils.scala b/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/ComponentCppWriterUtils.scala index aa8d3c77a..38933cdce 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/ComponentCppWriterUtils.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/ComponentCppWriterUtils.scala @@ -964,6 +964,19 @@ abstract class ComponentCppWriterUtils( CppDoc.Function.PureVirtual ) + def getValidityFlagForParam(param: Param) = { + val paramName = param.getName + val flagName = paramValidityFlagName(paramName) + linesClassMember( + lines( + s"""| + |//! The validity flag for $paramName + |Fw::ParamValid $flagName = Fw::ParamValid::UNINIT; + |""" + ) + ) + } + /** Writes the type of a state machine implementation */ def writeStateMachineImplType(smSymbol: Symbol.StateMachine) = StateMachine.getSymbolKind(smSymbol) match { diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/ComponentParameters.scala b/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/ComponentParameters.scala index 98b200192..33f339079 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/ComponentParameters.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/ComponentParameters.scala @@ -10,6 +10,8 @@ case class ComponentParameters ( aNode: Ast.Annotated[AstNode[Ast.DefComponent]] ) extends ComponentCppWriterUtils(s, aNode) { + val paramBufferName = "_paramBuffer" + def getConstantMembers: List[CppDoc.Class.Member] = guardedList (hasParameters) (List(getParamIds)) @@ -40,6 +42,34 @@ case class ComponentParameters ( guardedList (hasExternalParameters) (getParamDelegate) ) + private def checkValidityFlag(param: Param, flagValue: String) = + val paramName = param.getName + val validityFlagName = paramValidityFlagName(paramName) + s"this->$validityFlagName == Fw::ParamValid::$flagValue" + + private def checkValidityFlagValidOrDefault(param: Param) = + s"(${checkValidityFlag(param, "VALID")}) || (${checkValidityFlag(param, "DEFAULT")})" + + private def deserializeParam(param: Param) = { + val paramName = param.getName + val varName = paramVariableName(paramName) + val validityFlagName = paramValidityFlagName(paramName) + if param.isExternal + then + val idConstantName = paramIdConstantName(paramName) + lines( + s"""|FW_ASSERT(this->paramDelegatePtr != nullptr); + |_stat = this->paramDelegatePtr->deserializeParam( + | _baseId, + | $idConstantName, + | this->$validityFlagName, + | $paramBufferName + |);""" + ) + else + lines(s"_stat = $paramBufferName.deserializeTo(this->$varName);") + } + private def getExternalParameterFunctions: List[CppDoc.Class.Member] = { lazy val delegateInit = addAccessTagAndComment( "protected", @@ -84,9 +114,7 @@ case class ComponentParameters ( ) ), CppDoc.Type(writeParamType(param.paramType, "Fw::ParamString")), - if param.isExternal - then writeGetterFunctionBodyForExternalParam(param) - else writeGetterFunctionBodyForInternalParam(param) + writeGetterFunctionBody(param) ) private def getGetterFunctions: List[CppDoc.Class.Member] = @@ -127,22 +155,6 @@ case class ComponentParameters ( ) ) - private def getParam(param: Param, validityFlag: String) = { - val paramName = param.getName - val idConstantName = paramIdConstantName(paramName) - val prmGetPortInvokerName = outputPortInvokerName(prmGetPort.get) - lines( - s"""|_id = _baseId + $idConstantName; - | - |// Get parameter $paramName - |$validityFlag = this->$prmGetPortInvokerName( - | 0, - | _id, - | _buff - |);""" - ) - } - private def getParamDelegate = addAccessTagAndComment( "private", @@ -152,12 +164,54 @@ case class ComponentParameters ( lines( s"""| |//! Delegate to serialize/deserialize an externally stored parameter - |Fw::ParamExternalDelegate* paramDelegatePtr; + |Fw::ParamExternalDelegate* paramDelegatePtr = nullptr; |""" ) ) + ), + CppDoc.Lines.Hpp + ) + + private def getParamFromComponent(param: Param) = { + if param.isExternal + then + val idConstantName = paramIdConstantName(param.getName) + lines( + s"""|FW_ASSERT(this->paramDelegatePtr != nullptr); + |Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + | static_cast(this->getIdBase()), + | $idConstantName, + | $paramBufferName + |); + |if(_stat == Fw::FW_SERIALIZE_OK) { + | _stat = $paramBufferName.deserializeTo(_local); + | FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + |} else { + | valid = Fw::ParamValid::INVALID; + |}""" ) + else + val variableName = paramVariableName(param.getName) + lines(s"_local = this->$variableName;") + } + + private def getParamFromPort(param: Param) = { + val paramName = param.getName + val idConstantName = paramIdConstantName(paramName) + val prmGetPortInvokerName = outputPortInvokerName(prmGetPort.get) + val validityFlagName = paramValidityFlagName(param.getName) + lines( + s"""| + |_id = _baseId + $idConstantName; + | + |// Get serialized parameter $paramName + |this->$validityFlagName = this->$prmGetPortInvokerName( + | 0, + | _id, + | $paramBufferName + |);""" ) + } private def getParamIds = linesClassMember( List.concat( @@ -201,26 +255,25 @@ case class ComponentParameters ( ) private def getParamVarForParam(param: Param) = - guardedList (!param.isExternal) { - val paramType = writeParamType(param.paramType, "Fw::ParamString") - val paramVarName = paramVariableName(param.getName) - List( - linesClassMember( - List.concat( - addSeparatedPreComment( - s"Parameter ${param.getName}", - AnnotationCppWriter.asStringOpt(param.aNode) - ), - lines(s"$paramType $paramVarName;") - ) - ) + val paramType = writeParamType(param.paramType, "Fw::ParamString") + val paramVarName = paramVariableName(param.getName) + linesClassMember( + List.concat( + addSeparatedPreComment( + s"Parameter ${param.getName}", + AnnotationCppWriter.asStringOpt(param.aNode) + ), + lines(s"$paramType $paramVarName;") ) - } + ) private def getParamVars = addAccessTagAndComment( "private", "Parameter variables", - sortedParams.flatMap((_, param) => getParamVarForParam(param)), + // Only internal paramenters need storage for parameter values + sortedParams.collect { + case (_, param) if !param.isExternal => getParamVarForParam(param) + }, CppDoc.Lines.Hpp ) @@ -274,27 +327,10 @@ case class ComponentParameters ( sortedParams.map((_, param) => getSetterForParam(param)) ) - private def getValidityFlagForParam(param: Param) = { - val paramName = param.getName - val flagName = paramValidityFlagName(paramName) - guardedList (!param.isExternal) ( - List( - linesClassMember( - lines( - s"""| - |//! True if $paramName was successfully received - |Fw::ParamValid $flagName; - |""" - ) - ) - ) - ) - } - private def getValidityFlags = addAccessTagAndComment( "private", "Parameter validity flags", - sortedParams.flatMap((_, param) => getValidityFlagForParam(param)), + sortedParams.map((_, param) => getValidityFlagForParam(param)), CppDoc.Lines.Hpp ) @@ -304,155 +340,137 @@ case class ComponentParameters ( private def paramVariableName(name: String) = s"m_$name" - private def writeGetterFunctionBodyForExternalParam(param: Param) = { - val paramType = writeParamType(param.paramType, "Fw::ParamString") - val idConstantName = paramIdConstantName(param.getName) - lines( - s"""|$paramType _local{}; - |Fw::ParamBuffer _getBuff; - |// Get the base ID - |const FwPrmIdType _baseId = static_cast(this->getIdBase()); - |// Get the local ID to pass to the delegate - |const FwPrmIdType _localId = $idConstantName; - | - |FW_ASSERT(this->paramDelegatePtr != nullptr); - |// Get the external parameter from the delegate - |Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - |if(_stat == Fw::FW_SERIALIZE_OK) { - | _stat = _getBuff.deserializeTo(_local); - | FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - | valid = Fw::ParamValid::VALID; - |} else { - | valid = Fw::ParamValid::INVALID; - |} - |return _local; - |""" - ) + private def setDefaultValue(param: Param, value: Value) = { + val paramName = param.getName + val varName = paramVariableName(paramName) + val cppValue = ValueCppWriter.write(s, value) + if param.isExternal + then + val cppType = TypeCppWriter.getName(s, value.getType, "Fw::String") + val validityFlagName = paramValidityFlagName(param.getName) + List.concat( + lines( + s"""|$cppType _val = $cppValue; + |$paramBufferName.resetSer(); + |_stat = $paramBufferName.serializeFrom(_val); + |FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat));""" + ), + deserializeParam(param), + wrapInIf( + "_stat != Fw::FW_SERIALIZE_OK", + lines(s"this->$validityFlagName = Fw::ParamValid::INVALID;") + ) + ) + else + lines(s"this->$varName = $cppValue;") } - private def writeGetterFunctionBodyForInternalParam(param: Param) = { + private def setValidityFlag(param: Param, flagValue: String) = + val paramName = param.getName + val validityFlagName = paramValidityFlagName(paramName) + s"this->$validityFlagName = Fw::ParamValid::$flagValue;" + + private def setValidityFlagLines(param: Param, flagValue: String) = + lines(setValidityFlag(param, flagValue)) + + private def writeGetterFunctionBody(param: Param) = { val paramType = writeParamType(param.paramType, "Fw::ParamString") val validityFlagName = paramValidityFlagName(param.getName) - val variableName = paramVariableName(param.getName) - lines( - s"""|$paramType _local{}; - |this->m_paramLock.lock(); - |valid = this->$validityFlagName; - |_local = this->$variableName; - |this->m_paramLock.unLock(); - |return _local; - |""" + List.concat( + lines( + s"""|Fw::ParamBuffer $paramBufferName; + |$paramType _local{}; + |this->m_paramLock.lock(); + |valid = this->$validityFlagName;""" + ), + wrapInIf( + "(valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)", + getParamFromComponent(param) + ), + lines( + """|this->m_paramLock.unlock(); + |return _local;""" + ) ) } - private def writeLoadForExternalParam(param: Param) = { - val paramName = param.getName - val idConstantName = paramIdConstantName(paramName) - val varName = paramVariableName(paramName) + private def writeLoadForParam(param: Param) = { + // Generate a block, or an if statement, or an if-else statement + def writeCondition( + condition: => String, + ifBlock: List[Line], + elseBlock: => List[Line] + ) = + if param.isExternal && !param.default.isDefined + // External parameter, no default: no condition needed + then ifBlock + else if param.default.isDefined + // Default: if and else needed + then wrapInIfElse(condition, ifBlock, elseBlock) + // Internal parameter, no default: if needed + else wrapInIf(condition, ifBlock) List.concat( - getParam(param, "_paramValid"), - lines( - s"""| - |// If there was a deserialization issue, mark it invalid - |""" - ), - wrapInIfElse( - s"_paramValid == Fw::ParamValid::VALID", + getParamFromPort(param), + { + val orUseDefaultValue = param.default match { + case Some(_) => " or use default value" + case None => "" + } + lines( + s"""| + |this->m_paramLock.lock(); + | + |// Deserialize parameter$orUseDefaultValue""" + ) + }, + writeCondition( + checkValidityFlag(param, "VALID"), List.concat( - lines( - s"""|// Pass the local ID to the delegate - |constexpr FwPrmIdType _localId = $idConstantName; - | - |FW_ASSERT(this->paramDelegatePtr != nullptr); - |// Call the delegate deserialize function for $varName - |_stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - |""" - ), + deserializeParam(param), wrapInIf( "_stat != Fw::FW_SERIALIZE_OK", - lines( - s"_paramValid = Fw::ParamValid::INVALID;" + setValidityFlagLines( + param, + if param.default.isDefined then "DEFAULT" else "INVALID" ) ) ), - lines(s"_paramValid = Fw::ParamValid::INVALID;") + setValidityFlagLines(param, "DEFAULT") + ), + param.default match { + case Some(value) => + wrapInIf( + checkValidityFlag(param, "DEFAULT"), + setDefaultValue(param, value) + ) + case None => Nil + }, + lines( + """| + |this->m_paramLock.unlock();""" ) ) } - private def writeLoadForInternalParam(param: Param) = { - val paramName = param.getName - val idConstantName = paramIdConstantName(paramName) - val validityFlagName = paramValidityFlagName(paramName) - val varName = paramVariableName(paramName) + private def writeLoadFunctionBody = { + val prmGetPortName = prmGetPort.get.getUnqualifiedName + val prmGetIsConnected = outputPortIsConnectedName(prmGetPortName) List.concat( - getParam(param, s"this->$validityFlagName"), lines( - s"""| - |// Deserialize value - |this->m_paramLock.lock(); + s"""|Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_OK; + |const FwPrmIdType _baseId = static_cast(this->getIdBase()); + |FW_ASSERT(this->$prmGetIsConnected(0)); | - |// If there was a deserialization issue, mark it invalid + |FwPrmIdType _id{}; + |Fw::ParamBuffer $paramBufferName; |""" ), - wrapInIfElse( - s"this->$validityFlagName == Fw::ParamValid::VALID", - line(s"_stat = _buff.deserializeTo(this->$varName);") :: - wrapInIf( - "_stat != Fw::FW_SERIALIZE_OK", - param.default match { - case Some(value) => lines( - s"""|this->$validityFlagName = Fw::ParamValid::DEFAULT; - |// Set default value - |this->$varName = ${ValueCppWriter.write(s, value)}; - |""" - ) - case None => lines( - s"this->$validityFlagName = Fw::ParamValid::INVALID;" - ) - } - ), - param.default match { - case Some(value) => lines( - s"""|// Set default value - |this->$validityFlagName = Fw::ParamValid::DEFAULT; - |this->$varName = ${ValueCppWriter.write(s, value)}; - |""" - ) - case None => lines("// No default") - } - ), - Line.blank :: lines("this->m_paramLock.unLock();") - ) - } - - private def writeLoadFunctionBody = { - val prmGetPortName = prmGetPort.get.getUnqualifiedName - val prmGetIsConnected = outputPortIsConnectedName(prmGetPortName) - intersperseBlankLines( - List( - lines( - s"""|Fw::ParamBuffer _buff; - |Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_OK; - |const FwPrmIdType _baseId = static_cast(this->getIdBase()); - |FW_ASSERT(this->$prmGetIsConnected(0)); - | - |FwPrmIdType _id{}; - |""" - ), - guardedList (hasExternalParameters) (lines("Fw::ParamValid _paramValid;")), - intersperseBlankLines( - sortedParams.map((_, param) => - if param.isExternal - then writeLoadForExternalParam(param) - else writeLoadForInternalParam(param) - ) - ), - lines( - """|// Call notifier - |this->parametersLoaded(); - |""" - ) + sortedParams.flatMap((_, param) => writeLoadForParam(param)), + lines( + """| + |// Call notifier + |this->parametersLoaded(); + |""" ) ) } @@ -475,79 +493,77 @@ case class ComponentParameters ( val prmSetPortInvokerName = outputPortInvokerName(prmSetPort.get) List.concat( lines( - s"""|Fw::ParamBuffer _saveBuff; - |FwPrmIdType _id; - |Fw::SerializeStatus _stat; - | - |""" + s"""|if (!this->$prmSetIsConnected(0)) { + | return Fw::CmdResponse::EXECUTION_ERROR; + |} + |Fw::ParamBuffer $paramBufferName; + |const FwIdType idBase = this->getIdBase(); + |Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + |// Serialize the parameter + |this->m_paramLock.lock();""" ), wrapInIf( - s"this->$prmSetIsConnected(0)", - List.concat( - if (param.isExternal) - then lines( - s"""|// Get the local and base ID to pass to the delegate - |_id = $idConstantName; - |const FwPrmIdType _baseId = static_cast(this->getIdBase()); - | - |FW_ASSERT(this->paramDelegatePtr != nullptr); - |_stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - |""" - ) - else lines ( - s"""|this->m_paramLock.lock(); - | - |_stat = _saveBuff.serializeFrom($paramVarName); - | - |this->m_paramLock.unLock(); - |""" - ), - lines( - s"""|if (_stat != Fw::FW_SERIALIZE_OK) { - | return Fw::CmdResponse::VALIDATION_ERROR; - |} - | - |_id = static_cast(this->getIdBase() + $idConstantName); - | - |// Save the parameter - |this->$prmSetPortInvokerName( - | 0, - | _id, - | _saveBuff - |); - | - |return Fw::CmdResponse::OK; - |""" - ) + checkValidityFlagValidOrDefault(param), + if (param.isExternal) + then lines( + s"""|FW_ASSERT(this->paramDelegatePtr != nullptr); + |_stat = this->paramDelegatePtr->serializeParam( + | static_cast(idBase), + | $idConstantName, + | $paramBufferName + |);""" + ) + else lines ( + s"_stat = $paramBufferName.serializeFrom($paramVarName);" ) ), - Line.blank :: lines("return Fw::CmdResponse::EXECUTION_ERROR;") + lines( + s"""|this->m_paramLock.unlock(); + |if (_stat != Fw::FW_SERIALIZE_OK) { + | return Fw::CmdResponse::VALIDATION_ERROR; + |} + |// Save the parameter + |this->$prmSetPortInvokerName( + | 0, + | static_cast(idBase + $idConstantName), + | $paramBufferName + |); + |// Return the command response + |return Fw::CmdResponse::OK;""" + ) ) } private def writeSetterBodyForExternalParam(param: Param) = { val idConstantName = paramIdConstantName(param.getName) - val varName = paramVariableName(param.getName) lines( - s"""|const FwPrmIdType _localId = $idConstantName; - |const FwPrmIdType _baseId = static_cast(this->getIdBase()); + s"""|Fw::CmdResponse _response{}; | + |this->m_paramLock.lock(); + |// Update the external parameter |FW_ASSERT(this->paramDelegatePtr != nullptr); - |// Call the delegate serialize function for $varName |const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - | _baseId, - | _localId, + | static_cast(this->getIdBase()), + | $idConstantName, | Fw::ParamValid::VALID, | val |); - |if (_stat != Fw::FW_SERIALIZE_OK) { - | return Fw::CmdResponse::VALIDATION_ERROR; + |// Set response and update component state + |if (_stat == Fw::FW_SERIALIZE_OK) { + | ${setValidityFlag(param, "VALID")} + | _response = Fw::CmdResponse::OK; |} + |else { + | ${setValidityFlag(param, "INVALID")} + | _response = Fw::CmdResponse::VALIDATION_ERROR; + |} + |this->m_paramLock.unlock(); | |// Call notifier - |this->parameterUpdated($idConstantName); - |return Fw::CmdResponse::OK; - |""" + |if (_response == Fw::CmdResponse::OK) { + | this->parameterUpdated($idConstantName); + |} + |return _response;""" ) } @@ -567,7 +583,7 @@ case class ComponentParameters ( |this->m_paramLock.lock(); |this->$varName = _localVal; |this->$validityFlagName = Fw::ParamValid::VALID; - |this->m_paramLock.unLock(); + |this->m_paramLock.unlock(); | |// Call notifier |this->parameterUpdated($idConstantName); diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/TestWriter/ComponentTesterBaseWriter.scala b/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/TestWriter/ComponentTesterBaseWriter.scala index 39c287374..0653e5f62 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/TestWriter/ComponentTesterBaseWriter.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/TestWriter/ComponentTesterBaseWriter.scala @@ -194,11 +194,7 @@ case class ComponentTesterBaseWriter( constructorClassMember( Some(s"Construct object $testerBaseClassName"), constructorParams, - "Fw::PassiveComponentBase(compName)" :: sortedParams.collect { - case (_, param) if !param.isExternal => - val flagName = paramValidityFlagName(param.getName) - s"$flagName(Fw::ParamValid::UNINIT)" - }, + List("Fw::PassiveComponentBase(compName)"), { lazy val portHistories = line("// Initialize port histories") :: typedOutputPorts.filter(hasPortParams).map(p => { @@ -1604,41 +1600,26 @@ case class ComponentTesterBaseWriter( addAccessTagAndComment( "private", "Parameter validity flags", - sortedParams.flatMap { case (_, param) => - guardedList (!param.isExternal) ( - List( - linesClassMember( - lines( - s"""| - |//! True if ${param.getName} was successfully received - |Fw::ParamValid ${paramValidityFlagName(param.getName)}; - |""" - ) - ) - ) - ) + sortedParams.collect { + case (_, param) if !param.isExternal => getValidityFlagForParam(param) }, CppDoc.Lines.Hpp ), addAccessTagAndComment( "private", "Parameter variables", - sortedParams.flatMap { case (_, param) => - guardedList (!param.isExternal) { - val paramType = writeParamType(param.paramType, "Fw::ParamString") - val paramVarName = paramVariableName(param.getName) - List( - linesClassMember( - List.concat( - addSeparatedPreComment( - s"Parameter ${param.getName}", - AnnotationCppWriter.asStringOpt(param.aNode) - ), - lines(s"$paramType $paramVarName;") - ) - ) + sortedParams.collect { case (_, param) if !param.isExternal => + val paramType = writeParamType(param.paramType, "Fw::ParamString") + val paramVarName = paramVariableName(param.getName) + linesClassMember( + List.concat( + addSeparatedPreComment( + s"Parameter ${param.getName}", + AnnotationCppWriter.asStringOpt(param.aNode) + ), + lines(s"$paramType $paramVarName;") ) - } + ) }, CppDoc.Lines.Hpp ), @@ -1737,6 +1718,7 @@ case class ExternalParameterDelegate( lines( """|Fw::SerializeStatus stat; |(void) baseId; + |(void) prmStat; | |// Serialize the parameter based on ID |switch(localId) @@ -1833,41 +1815,26 @@ case class ExternalParameterDelegate( addAccessTagAndComment( "public", "Parameter validity flags", - sortedParams.flatMap { case (_, param) => - guardedList (param.isExternal) ( - List( - linesClassMember( - lines( - s"""| - |//! True if ${param.getName} was successfully received - |Fw::ParamValid ${paramValidityFlagName(param.getName)}; - |""" - ) - ) - ) - ) + sortedParams.collect { + case (_, param) if param.isExternal => getValidityFlagForParam(param) }, CppDoc.Lines.Hpp ), addAccessTagAndComment( "public", "Parameter variables", - sortedParams.flatMap { case (_, param) => - guardedList (param.isExternal) { - val paramType = writeParamType(param.paramType, "Fw::ParamString") - val paramVarName = paramVariableName(param.getName) - List( - linesClassMember( - List.concat( - addSeparatedPreComment( - s"Parameter ${param.getName}", - AnnotationCppWriter.asStringOpt(param.aNode) - ), - lines(s"$paramType $paramVarName;") - ) - ) + sortedParams.collect { case (_, param) if param.isExternal => + val paramType = writeParamType(param.paramType, "Fw::ParamString") + val paramVarName = paramVariableName(param.getName) + linesClassMember( + List.concat( + addSeparatedPreComment( + s"Parameter ${param.getName}", + AnnotationCppWriter.asStringOpt(param.aNode) + ), + lines(s"$paramType $paramVarName;") ) - } + ) }, CppDoc.Lines.Hpp ) diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveExternalParamsComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveExternalParamsComponentAc.ref.cpp index b9603e34f..0aaec168f 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveExternalParamsComponentAc.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveExternalParamsComponentAc.ref.cpp @@ -1666,165 +1666,205 @@ void ActiveExternalParamsComponentBase :: void ActiveExternalParamsComponentBase :: loadParameters() { - Fw::ParamBuffer _buff; Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_OK; const FwPrmIdType _baseId = static_cast(this->getIdBase()); FW_ASSERT(this->isConnected_prmGetOut_OutputPort(0)); FwPrmIdType _id{}; - - Fw::ParamValid _paramValid; + Fw::ParamBuffer _paramBuffer; _id = _baseId + PARAMID_PARAMI32EXT; - // Get parameter ParamI32Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamI32Ext + this->m_param_ParamI32Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMI32EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamI32Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMI32EXT, + this->m_param_ParamI32Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMF64EXT; - // Get parameter ParamF64Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamF64Ext + this->m_param_ParamF64Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMF64EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamF64Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMF64EXT, + this->m_param_ParamF64Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMSTRINGEXT; - // Get parameter ParamStringExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStringExt + this->m_param_ParamStringExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStringExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; } + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT) { + Fw::String _val = Fw::String("external default"); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + } + } + + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMENUMEXT; - // Get parameter ParamEnumExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamEnumExt + this->m_param_ParamEnumExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMENUMEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamEnumExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMENUMEXT, + this->m_param_ParamEnumExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMARRAYEXT; - // Get parameter ParamArrayExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamArrayExt + this->m_param_ParamArrayExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamArrayExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT) { + A _val = A({1, 2, 3}); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + } + } + + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCTEXT; - // Get parameter ParamStructExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStructExt + this->m_param_ParamStructExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStructExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRUCTEXT, + this->m_param_ParamStructExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + // Call notifier this->parametersLoaded(); } @@ -1835,8 +1875,7 @@ void ActiveExternalParamsComponentBase :: ActiveExternalParamsComponentBase :: ActiveExternalParamsComponentBase(const char* compName) : - Fw::ActiveComponentBase(compName), - paramDelegatePtr(nullptr) + Fw::ActiveComponentBase(compName) { } @@ -3471,138 +3510,150 @@ void ActiveExternalParamsComponentBase :: I32 ActiveExternalParamsComponentBase :: paramGet_ParamI32Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; I32 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamI32Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } F64 ActiveExternalParamsComponentBase :: paramGet_ParamF64Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamF64Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } Fw::ParamString ActiveExternalParamsComponentBase :: paramGet_ParamStringExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStringExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } E ActiveExternalParamsComponentBase :: paramGet_ParamEnumExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamEnumExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } A ActiveExternalParamsComponentBase :: paramGet_ParamArrayExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamArrayExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } S ActiveExternalParamsComponentBase :: paramGet_ParamStructExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStructExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } @@ -4628,139 +4679,193 @@ void ActiveExternalParamsComponentBase :: Fw::CmdResponse ActiveExternalParamsComponentBase :: paramSet_ParamI32Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamI32Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMI32EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMI32EXT); + } + return _response; } Fw::CmdResponse ActiveExternalParamsComponentBase :: paramSet_ParamF64Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamF64Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMF64EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMF64EXT); + } + return _response; } Fw::CmdResponse ActiveExternalParamsComponentBase :: paramSet_ParamStringExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStringExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRINGEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRINGEXT); + } + return _response; } Fw::CmdResponse ActiveExternalParamsComponentBase :: paramSet_ParamEnumExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamEnumExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMENUMEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMENUMEXT); + } + return _response; } Fw::CmdResponse ActiveExternalParamsComponentBase :: paramSet_ParamArrayExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamArrayExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMARRAYEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMARRAYEXT); + } + return _response; } Fw::CmdResponse ActiveExternalParamsComponentBase :: paramSet_ParamStructExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStructExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); + } + return _response; } // ---------------------------------------------------------------------- @@ -4770,195 +4875,197 @@ Fw::CmdResponse ActiveExternalParamsComponentBase :: Fw::CmdResponse ActiveExternalParamsComponentBase :: paramSave_ParamI32Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamI32Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamI32Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMI32EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMI32EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMI32EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveExternalParamsComponentBase :: paramSave_ParamF64Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMF64EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveExternalParamsComponentBase :: paramSave_ParamStringExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRINGEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRINGEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRINGEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveExternalParamsComponentBase :: paramSave_ParamEnumExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnumExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnumExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUMEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMENUMEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUMEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveExternalParamsComponentBase :: paramSave_ParamArrayExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAYEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMARRAYEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAYEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveExternalParamsComponentBase :: paramSave_ParamStructExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStructExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStructExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCTEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCTEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } - -// ---------------------------------------------------------------------- -// Parameter delegate -// ---------------------------------------------------------------------- diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveExternalParamsComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveExternalParamsComponentAc.ref.hpp index 921ac3c43..8c868758f 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveExternalParamsComponentAc.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveExternalParamsComponentAc.ref.hpp @@ -2151,6 +2151,30 @@ class ActiveExternalParamsComponentBase : #endif + private: + + // ---------------------------------------------------------------------- + // Parameter validity flags + // ---------------------------------------------------------------------- + + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; + private: // ---------------------------------------------------------------------- @@ -2158,7 +2182,7 @@ class ActiveExternalParamsComponentBase : // ---------------------------------------------------------------------- //! Delegate to serialize/deserialize an externally stored parameter - Fw::ParamExternalDelegate* paramDelegatePtr; + Fw::ParamExternalDelegate* paramDelegatePtr = nullptr; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveParamsComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveParamsComponentAc.ref.cpp index 3549687fe..48835ac2d 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveParamsComponentAc.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveParamsComponentAc.ref.cpp @@ -1666,170 +1666,150 @@ void ActiveParamsComponentBase :: void ActiveParamsComponentBase :: loadParameters() { - Fw::ParamBuffer _buff; Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_OK; const FwPrmIdType _baseId = static_cast(this->getIdBase()); FW_ASSERT(this->isConnected_prmGetOut_OutputPort(0)); FwPrmIdType _id{}; + Fw::ParamBuffer _paramBuffer; _id = _baseId + PARAMID_PARAMU32; - // Get parameter ParamU32 + // Get serialized parameter ParamU32 this->m_param_ParamU32_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamU32_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamU32); + _stat = _paramBuffer.deserializeTo(this->m_ParamU32); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamU32_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMF64; - // Get parameter ParamF64 + // Get serialized parameter ParamF64 this->m_param_ParamF64_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamF64_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamF64); + _stat = _paramBuffer.deserializeTo(this->m_ParamF64); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamF64_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRING; - // Get parameter ParamString + // Get serialized parameter ParamString this->m_param_ParamString_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamString_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamString); + _stat = _paramBuffer.deserializeTo(this->m_ParamString); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamString = Fw::String("default"); } } else { - // Set default value this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT) { this->m_ParamString = Fw::String("default"); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMENUM; - // Get parameter ParamEnum + // Get serialized parameter ParamEnum this->m_param_ParamEnum_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamEnum); + _stat = _paramBuffer.deserializeTo(this->m_ParamEnum); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamEnum_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMARRAY; - // Get parameter ParamArray + // Get serialized parameter ParamArray this->m_param_ParamArray_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamArray_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamArray); + _stat = _paramBuffer.deserializeTo(this->m_ParamArray); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamArray = A({1, 2, 3}); } } else { - // Set default value this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT) { this->m_ParamArray = A({1, 2, 3}); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCT; - // Get parameter ParamStruct + // Get serialized parameter ParamStruct this->m_param_ParamStruct_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamStruct); + _stat = _paramBuffer.deserializeTo(this->m_ParamStruct); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamStruct_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parametersLoaded(); @@ -1843,12 +1823,7 @@ ActiveParamsComponentBase :: ActiveParamsComponentBase(const char* compName) : Fw::ActiveComponentBase(compName) { - this->m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamString_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; + } ActiveParamsComponentBase :: @@ -3481,66 +3456,84 @@ void ActiveParamsComponentBase :: U32 ActiveParamsComponentBase :: paramGet_ParamU32(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; U32 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamU32_valid; - _local = this->m_ParamU32; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamU32; + } + this->m_paramLock.unlock(); return _local; } F64 ActiveParamsComponentBase :: paramGet_ParamF64(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamF64_valid; - _local = this->m_ParamF64; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamF64; + } + this->m_paramLock.unlock(); return _local; } Fw::ParamString ActiveParamsComponentBase :: paramGet_ParamString(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamString_valid; - _local = this->m_ParamString; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamString; + } + this->m_paramLock.unlock(); return _local; } E ActiveParamsComponentBase :: paramGet_ParamEnum(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamEnum_valid; - _local = this->m_ParamEnum; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamEnum; + } + this->m_paramLock.unlock(); return _local; } A ActiveParamsComponentBase :: paramGet_ParamArray(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamArray_valid; - _local = this->m_ParamArray; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamArray; + } + this->m_paramLock.unlock(); return _local; } S ActiveParamsComponentBase :: paramGet_ParamStruct(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamStruct_valid; - _local = this->m_ParamStruct; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamStruct; + } + this->m_paramLock.unlock(); return _local; } @@ -4565,7 +4558,7 @@ Fw::CmdResponse ActiveParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamU32 = _localVal; this->m_param_ParamU32_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMU32); @@ -4585,7 +4578,7 @@ Fw::CmdResponse ActiveParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamF64 = _localVal; this->m_param_ParamF64_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMF64); @@ -4605,7 +4598,7 @@ Fw::CmdResponse ActiveParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamString = _localVal; this->m_param_ParamString_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRING); @@ -4625,7 +4618,7 @@ Fw::CmdResponse ActiveParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamEnum = _localVal; this->m_param_ParamEnum_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMENUM); @@ -4645,7 +4638,7 @@ Fw::CmdResponse ActiveParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamArray = _localVal; this->m_param_ParamArray_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMARRAY); @@ -4665,7 +4658,7 @@ Fw::CmdResponse ActiveParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamStruct = _localVal; this->m_param_ParamStruct_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRUCT); @@ -4679,185 +4672,167 @@ Fw::CmdResponse ActiveParamsComponentBase :: Fw::CmdResponse ActiveParamsComponentBase :: paramSave_ParamU32() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamU32); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMU32); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamU32_valid == Fw::ParamValid::VALID) || (this->m_param_ParamU32_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamU32); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMU32), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveParamsComponentBase :: paramSave_ParamF64() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamF64); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamF64); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveParamsComponentBase :: paramSave_ParamString() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamString); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRING); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamString_valid == Fw::ParamValid::VALID) || (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamString); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRING), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveParamsComponentBase :: paramSave_ParamEnum() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamEnum); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUM); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnum_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamEnum); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUM), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveParamsComponentBase :: paramSave_ParamArray() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamArray); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAY); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArray_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamArray); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAY), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveParamsComponentBase :: paramSave_ParamStruct() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamStruct); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStruct_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamStruct); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveParamsComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveParamsComponentAc.ref.hpp index fe0192717..17d875b48 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveParamsComponentAc.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveParamsComponentAc.ref.hpp @@ -2145,23 +2145,23 @@ class ActiveParamsComponentBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveSerialComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveSerialComponentAc.ref.cpp index 83601d41a..2cda418d2 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveSerialComponentAc.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveSerialComponentAc.ref.cpp @@ -2128,323 +2128,343 @@ void ActiveSerialComponentBase :: void ActiveSerialComponentBase :: loadParameters() { - Fw::ParamBuffer _buff; Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_OK; const FwPrmIdType _baseId = static_cast(this->getIdBase()); FW_ASSERT(this->isConnected_prmGetOut_OutputPort(0)); FwPrmIdType _id{}; - - Fw::ParamValid _paramValid; + Fw::ParamBuffer _paramBuffer; _id = _baseId + PARAMID_PARAMU32; - // Get parameter ParamU32 + // Get serialized parameter ParamU32 this->m_param_ParamU32_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamU32_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamU32); + _stat = _paramBuffer.deserializeTo(this->m_ParamU32); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamU32_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMF64; - // Get parameter ParamF64 + // Get serialized parameter ParamF64 this->m_param_ParamF64_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamF64_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamF64); + _stat = _paramBuffer.deserializeTo(this->m_ParamF64); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamF64_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRING; - // Get parameter ParamString + // Get serialized parameter ParamString this->m_param_ParamString_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamString_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamString); + _stat = _paramBuffer.deserializeTo(this->m_ParamString); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamString = Fw::String("default"); } } else { - // Set default value this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT) { this->m_ParamString = Fw::String("default"); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMENUM; - // Get parameter ParamEnum + // Get serialized parameter ParamEnum this->m_param_ParamEnum_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamEnum); + _stat = _paramBuffer.deserializeTo(this->m_ParamEnum); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamEnum_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMARRAY; - // Get parameter ParamArray + // Get serialized parameter ParamArray this->m_param_ParamArray_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamArray_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamArray); + _stat = _paramBuffer.deserializeTo(this->m_ParamArray); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamArray = A({1, 2, 3}); } } else { - // Set default value this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT) { this->m_ParamArray = A({1, 2, 3}); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCT; - // Get parameter ParamStruct + // Get serialized parameter ParamStruct this->m_param_ParamStruct_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamStruct); + _stat = _paramBuffer.deserializeTo(this->m_ParamStruct); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamStruct_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMI32EXT; - // Get parameter ParamI32Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamI32Ext + this->m_param_ParamI32Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMI32EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamI32Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMI32EXT, + this->m_param_ParamI32Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMF64EXT; - // Get parameter ParamF64Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamF64Ext + this->m_param_ParamF64Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMF64EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamF64Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMF64EXT, + this->m_param_ParamF64Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMSTRINGEXT; - // Get parameter ParamStringExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStringExt + this->m_param_ParamStringExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStringExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT) { + Fw::String _val = Fw::String("external default"); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMENUMEXT; - // Get parameter ParamEnumExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamEnumExt + this->m_param_ParamEnumExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMENUMEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamEnumExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMENUMEXT, + this->m_param_ParamEnumExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMARRAYEXT; - // Get parameter ParamArrayExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamArrayExt + this->m_param_ParamArrayExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamArrayExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT) { + A _val = A({1, 2, 3}); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + } + } + + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCTEXT; - // Get parameter ParamStructExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStructExt + this->m_param_ParamStructExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStructExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRUCTEXT, + this->m_param_ParamStructExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + // Call notifier this->parametersLoaded(); } @@ -2455,8 +2475,7 @@ void ActiveSerialComponentBase :: ActiveSerialComponentBase :: ActiveSerialComponentBase(const char* compName) : - Fw::ActiveComponentBase(compName), - paramDelegatePtr(nullptr) + Fw::ActiveComponentBase(compName) { this->m_EventActivityLowThrottledThrottle = 0; this->m_EventFatalThrottledThrottle = 0; @@ -2464,13 +2483,6 @@ ActiveSerialComponentBase :: this->m_EventWarningLowThrottledIntervalThrottle = 0; this->m_EventWarningLowThrottledIntervalThrottleTime = Fw::Time(); - - this->m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamString_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; } ActiveSerialComponentBase :: @@ -7123,204 +7135,234 @@ void ActiveSerialComponentBase :: U32 ActiveSerialComponentBase :: paramGet_ParamU32(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; U32 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamU32_valid; - _local = this->m_ParamU32; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamU32; + } + this->m_paramLock.unlock(); return _local; } F64 ActiveSerialComponentBase :: paramGet_ParamF64(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamF64_valid; - _local = this->m_ParamF64; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamF64; + } + this->m_paramLock.unlock(); return _local; } Fw::ParamString ActiveSerialComponentBase :: paramGet_ParamString(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamString_valid; - _local = this->m_ParamString; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamString; + } + this->m_paramLock.unlock(); return _local; } E ActiveSerialComponentBase :: paramGet_ParamEnum(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamEnum_valid; - _local = this->m_ParamEnum; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamEnum; + } + this->m_paramLock.unlock(); return _local; } A ActiveSerialComponentBase :: paramGet_ParamArray(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamArray_valid; - _local = this->m_ParamArray; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamArray; + } + this->m_paramLock.unlock(); return _local; } S ActiveSerialComponentBase :: paramGet_ParamStruct(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamStruct_valid; - _local = this->m_ParamStruct; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamStruct; + } + this->m_paramLock.unlock(); return _local; } I32 ActiveSerialComponentBase :: paramGet_ParamI32Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; I32 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamI32Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } F64 ActiveSerialComponentBase :: paramGet_ParamF64Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamF64Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } Fw::ParamString ActiveSerialComponentBase :: paramGet_ParamStringExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStringExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } E ActiveSerialComponentBase :: paramGet_ParamEnumExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamEnumExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } A ActiveSerialComponentBase :: paramGet_ParamArrayExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamArrayExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } S ActiveSerialComponentBase :: paramGet_ParamStructExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStructExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } @@ -9056,7 +9098,7 @@ Fw::CmdResponse ActiveSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamU32 = _localVal; this->m_param_ParamU32_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMU32); @@ -9076,7 +9118,7 @@ Fw::CmdResponse ActiveSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamF64 = _localVal; this->m_param_ParamF64_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMF64); @@ -9096,7 +9138,7 @@ Fw::CmdResponse ActiveSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamString = _localVal; this->m_param_ParamString_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRING); @@ -9116,7 +9158,7 @@ Fw::CmdResponse ActiveSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamEnum = _localVal; this->m_param_ParamEnum_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMENUM); @@ -9136,7 +9178,7 @@ Fw::CmdResponse ActiveSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamArray = _localVal; this->m_param_ParamArray_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMARRAY); @@ -9156,7 +9198,7 @@ Fw::CmdResponse ActiveSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamStruct = _localVal; this->m_param_ParamStruct_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRUCT); @@ -9166,139 +9208,193 @@ Fw::CmdResponse ActiveSerialComponentBase :: Fw::CmdResponse ActiveSerialComponentBase :: paramSet_ParamI32Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamI32Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMI32EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMI32EXT); + } + return _response; } Fw::CmdResponse ActiveSerialComponentBase :: paramSet_ParamF64Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamF64Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMF64EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMF64EXT); + } + return _response; } Fw::CmdResponse ActiveSerialComponentBase :: paramSet_ParamStringExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStringExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRINGEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRINGEXT); + } + return _response; } Fw::CmdResponse ActiveSerialComponentBase :: paramSet_ParamEnumExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamEnumExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMENUMEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMENUMEXT); + } + return _response; } Fw::CmdResponse ActiveSerialComponentBase :: paramSet_ParamArrayExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamArrayExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMARRAYEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMARRAYEXT); + } + return _response; } Fw::CmdResponse ActiveSerialComponentBase :: paramSet_ParamStructExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStructExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); + } + return _response; } // ---------------------------------------------------------------------- @@ -9308,381 +9404,365 @@ Fw::CmdResponse ActiveSerialComponentBase :: Fw::CmdResponse ActiveSerialComponentBase :: paramSave_ParamU32() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamU32); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMU32); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamU32_valid == Fw::ParamValid::VALID) || (this->m_param_ParamU32_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamU32); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMU32), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveSerialComponentBase :: paramSave_ParamF64() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamF64); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamF64); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveSerialComponentBase :: paramSave_ParamString() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamString); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRING); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamString_valid == Fw::ParamValid::VALID) || (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamString); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRING), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveSerialComponentBase :: paramSave_ParamEnum() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamEnum); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUM); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnum_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamEnum); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUM), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveSerialComponentBase :: paramSave_ParamArray() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamArray); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAY); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArray_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamArray); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAY), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveSerialComponentBase :: paramSave_ParamStruct() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamStruct); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStruct_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamStruct); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveSerialComponentBase :: paramSave_ParamI32Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamI32Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamI32Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMI32EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMI32EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMI32EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveSerialComponentBase :: paramSave_ParamF64Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMF64EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveSerialComponentBase :: paramSave_ParamStringExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRINGEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRINGEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRINGEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveSerialComponentBase :: paramSave_ParamEnumExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnumExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnumExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUMEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMENUMEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUMEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveSerialComponentBase :: paramSave_ParamArrayExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAYEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMARRAYEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAYEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveSerialComponentBase :: paramSave_ParamStructExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStructExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStructExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCTEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCTEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } - -// ---------------------------------------------------------------------- -// Parameter delegate -// ---------------------------------------------------------------------- diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveSerialComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveSerialComponentAc.ref.hpp index cd9873fb7..4aa13f83f 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveSerialComponentAc.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveSerialComponentAc.ref.hpp @@ -3464,23 +3464,41 @@ class ActiveSerialComponentBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; private: @@ -3526,7 +3544,7 @@ class ActiveSerialComponentBase : // ---------------------------------------------------------------------- //! Delegate to serialize/deserialize an externally stored parameter - Fw::ParamExternalDelegate* paramDelegatePtr; + Fw::ParamExternalDelegate* paramDelegatePtr = nullptr; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveTestComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveTestComponentAc.ref.cpp index 45204dea0..1e14b1d94 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveTestComponentAc.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveTestComponentAc.ref.cpp @@ -2206,323 +2206,343 @@ namespace M { void ActiveTestComponentBase :: loadParameters() { - Fw::ParamBuffer _buff; Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_OK; const FwPrmIdType _baseId = static_cast(this->getIdBase()); FW_ASSERT(this->isConnected_prmGetOut_OutputPort(0)); FwPrmIdType _id{}; - - Fw::ParamValid _paramValid; + Fw::ParamBuffer _paramBuffer; _id = _baseId + PARAMID_PARAMU32; - // Get parameter ParamU32 + // Get serialized parameter ParamU32 this->m_param_ParamU32_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamU32_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamU32); + _stat = _paramBuffer.deserializeTo(this->m_ParamU32); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamU32_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMF64; - // Get parameter ParamF64 + // Get serialized parameter ParamF64 this->m_param_ParamF64_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamF64_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamF64); + _stat = _paramBuffer.deserializeTo(this->m_ParamF64); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamF64_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRING; - // Get parameter ParamString + // Get serialized parameter ParamString this->m_param_ParamString_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamString_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamString); + _stat = _paramBuffer.deserializeTo(this->m_ParamString); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamString = Fw::String("default"); } } else { - // Set default value this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT) { this->m_ParamString = Fw::String("default"); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMENUM; - // Get parameter ParamEnum + // Get serialized parameter ParamEnum this->m_param_ParamEnum_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamEnum); + _stat = _paramBuffer.deserializeTo(this->m_ParamEnum); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamEnum_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMARRAY; - // Get parameter ParamArray + // Get serialized parameter ParamArray this->m_param_ParamArray_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamArray_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamArray); + _stat = _paramBuffer.deserializeTo(this->m_ParamArray); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamArray = A({1, 2, 3}); } } else { - // Set default value this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT) { this->m_ParamArray = A({1, 2, 3}); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCT; - // Get parameter ParamStruct + // Get serialized parameter ParamStruct this->m_param_ParamStruct_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamStruct); + _stat = _paramBuffer.deserializeTo(this->m_ParamStruct); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamStruct_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMI32EXT; - // Get parameter ParamI32Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamI32Ext + this->m_param_ParamI32Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMI32EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamI32Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMI32EXT, + this->m_param_ParamI32Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMF64EXT; - // Get parameter ParamF64Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamF64Ext + this->m_param_ParamF64Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMF64EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamF64Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMF64EXT, + this->m_param_ParamF64Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMSTRINGEXT; - // Get parameter ParamStringExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStringExt + this->m_param_ParamStringExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStringExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT) { + Fw::String _val = Fw::String("external default"); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMENUMEXT; - // Get parameter ParamEnumExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamEnumExt + this->m_param_ParamEnumExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMENUMEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamEnumExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMENUMEXT, + this->m_param_ParamEnumExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMARRAYEXT; - // Get parameter ParamArrayExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamArrayExt + this->m_param_ParamArrayExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamArrayExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT) { + A _val = A({1, 2, 3}); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + } + } + + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCTEXT; - // Get parameter ParamStructExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStructExt + this->m_param_ParamStructExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStructExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRUCTEXT, + this->m_param_ParamStructExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + // Call notifier this->parametersLoaded(); } @@ -2533,8 +2553,7 @@ namespace M { ActiveTestComponentBase :: ActiveTestComponentBase(const char* compName) : - Fw::ActiveComponentBase(compName), - paramDelegatePtr(nullptr) + Fw::ActiveComponentBase(compName) { this->m_EventActivityLowThrottledThrottle = 0; this->m_EventFatalThrottledThrottle = 0; @@ -2542,13 +2561,6 @@ namespace M { this->m_EventWarningLowThrottledIntervalThrottle = 0; this->m_EventWarningLowThrottledIntervalThrottleTime = Fw::Time(); - - this->m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamString_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; } ActiveTestComponentBase :: @@ -6955,204 +6967,234 @@ namespace M { U32 ActiveTestComponentBase :: paramGet_ParamU32(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; U32 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamU32_valid; - _local = this->m_ParamU32; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamU32; + } + this->m_paramLock.unlock(); return _local; } F64 ActiveTestComponentBase :: paramGet_ParamF64(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamF64_valid; - _local = this->m_ParamF64; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamF64; + } + this->m_paramLock.unlock(); return _local; } Fw::ParamString ActiveTestComponentBase :: paramGet_ParamString(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamString_valid; - _local = this->m_ParamString; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamString; + } + this->m_paramLock.unlock(); return _local; } E ActiveTestComponentBase :: paramGet_ParamEnum(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamEnum_valid; - _local = this->m_ParamEnum; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamEnum; + } + this->m_paramLock.unlock(); return _local; } A ActiveTestComponentBase :: paramGet_ParamArray(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamArray_valid; - _local = this->m_ParamArray; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamArray; + } + this->m_paramLock.unlock(); return _local; } S ActiveTestComponentBase :: paramGet_ParamStruct(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamStruct_valid; - _local = this->m_ParamStruct; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamStruct; + } + this->m_paramLock.unlock(); return _local; } I32 ActiveTestComponentBase :: paramGet_ParamI32Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; I32 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamI32Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } F64 ActiveTestComponentBase :: paramGet_ParamF64Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamF64Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } Fw::ParamString ActiveTestComponentBase :: paramGet_ParamStringExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStringExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } E ActiveTestComponentBase :: paramGet_ParamEnumExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamEnumExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } A ActiveTestComponentBase :: paramGet_ParamArrayExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamArrayExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } S ActiveTestComponentBase :: paramGet_ParamStructExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStructExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } @@ -8843,7 +8885,7 @@ namespace M { this->m_paramLock.lock(); this->m_ParamU32 = _localVal; this->m_param_ParamU32_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMU32); @@ -8863,7 +8905,7 @@ namespace M { this->m_paramLock.lock(); this->m_ParamF64 = _localVal; this->m_param_ParamF64_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMF64); @@ -8883,7 +8925,7 @@ namespace M { this->m_paramLock.lock(); this->m_ParamString = _localVal; this->m_param_ParamString_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRING); @@ -8903,7 +8945,7 @@ namespace M { this->m_paramLock.lock(); this->m_ParamEnum = _localVal; this->m_param_ParamEnum_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMENUM); @@ -8923,7 +8965,7 @@ namespace M { this->m_paramLock.lock(); this->m_ParamArray = _localVal; this->m_param_ParamArray_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMARRAY); @@ -8943,7 +8985,7 @@ namespace M { this->m_paramLock.lock(); this->m_ParamStruct = _localVal; this->m_param_ParamStruct_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRUCT); @@ -8953,139 +8995,193 @@ namespace M { Fw::CmdResponse ActiveTestComponentBase :: paramSet_ParamI32Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamI32Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMI32EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMI32EXT); + } + return _response; } Fw::CmdResponse ActiveTestComponentBase :: paramSet_ParamF64Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamF64Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMF64EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMF64EXT); + } + return _response; } Fw::CmdResponse ActiveTestComponentBase :: paramSet_ParamStringExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStringExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRINGEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRINGEXT); + } + return _response; } Fw::CmdResponse ActiveTestComponentBase :: paramSet_ParamEnumExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamEnumExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMENUMEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMENUMEXT); + } + return _response; } Fw::CmdResponse ActiveTestComponentBase :: paramSet_ParamArrayExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamArrayExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMARRAYEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMARRAYEXT); + } + return _response; } Fw::CmdResponse ActiveTestComponentBase :: paramSet_ParamStructExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStructExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); + } + return _response; } // ---------------------------------------------------------------------- @@ -9095,379 +9191,367 @@ namespace M { Fw::CmdResponse ActiveTestComponentBase :: paramSave_ParamU32() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamU32); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMU32); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamU32_valid == Fw::ParamValid::VALID) || (this->m_param_ParamU32_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamU32); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMU32), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveTestComponentBase :: paramSave_ParamF64() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamF64); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamF64); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveTestComponentBase :: paramSave_ParamString() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamString); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRING); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamString_valid == Fw::ParamValid::VALID) || (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamString); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRING), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveTestComponentBase :: paramSave_ParamEnum() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamEnum); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUM); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnum_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamEnum); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUM), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveTestComponentBase :: paramSave_ParamArray() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamArray); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAY); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArray_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamArray); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAY), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveTestComponentBase :: paramSave_ParamStruct() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamStruct); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStruct_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamStruct); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveTestComponentBase :: paramSave_ParamI32Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamI32Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamI32Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMI32EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMI32EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMI32EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveTestComponentBase :: paramSave_ParamF64Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMF64EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveTestComponentBase :: paramSave_ParamStringExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRINGEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRINGEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRINGEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveTestComponentBase :: paramSave_ParamEnumExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnumExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnumExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUMEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMENUMEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUMEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveTestComponentBase :: paramSave_ParamArrayExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAYEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMARRAYEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAYEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse ActiveTestComponentBase :: paramSave_ParamStructExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStructExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStructExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCTEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCTEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } // ---------------------------------------------------------------------- @@ -9543,8 +9627,4 @@ namespace M { } } - // ---------------------------------------------------------------------- - // Parameter delegate - // ---------------------------------------------------------------------- - } diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveTestComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveTestComponentAc.ref.hpp index 1056e80cf..00eee538f 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveTestComponentAc.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveTestComponentAc.ref.hpp @@ -3446,23 +3446,41 @@ namespace M { // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; private: @@ -3508,7 +3526,7 @@ namespace M { // ---------------------------------------------------------------------- //! Delegate to serialize/deserialize an externally stored parameter - Fw::ParamExternalDelegate* paramDelegatePtr; + Fw::ParamExternalDelegate* paramDelegatePtr = nullptr; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/base/PassiveExternalParamsComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/PassiveExternalParamsComponentAc.ref.cpp index 1f285a2f4..bf480ea72 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/PassiveExternalParamsComponentAc.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/PassiveExternalParamsComponentAc.ref.cpp @@ -1373,165 +1373,205 @@ void PassiveExternalParamsComponentBase :: void PassiveExternalParamsComponentBase :: loadParameters() { - Fw::ParamBuffer _buff; Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_OK; const FwPrmIdType _baseId = static_cast(this->getIdBase()); FW_ASSERT(this->isConnected_prmGetOut_OutputPort(0)); FwPrmIdType _id{}; - - Fw::ParamValid _paramValid; + Fw::ParamBuffer _paramBuffer; _id = _baseId + PARAMID_PARAMI32EXT; - // Get parameter ParamI32Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamI32Ext + this->m_param_ParamI32Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMI32EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamI32Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMI32EXT, + this->m_param_ParamI32Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMF64EXT; - // Get parameter ParamF64Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamF64Ext + this->m_param_ParamF64Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMF64EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamF64Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMF64EXT, + this->m_param_ParamF64Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMSTRINGEXT; - // Get parameter ParamStringExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStringExt + this->m_param_ParamStringExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStringExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; } + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT) { + Fw::String _val = Fw::String("external default"); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + } + } + + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMENUMEXT; - // Get parameter ParamEnumExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamEnumExt + this->m_param_ParamEnumExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMENUMEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamEnumExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMENUMEXT, + this->m_param_ParamEnumExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMARRAYEXT; - // Get parameter ParamArrayExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamArrayExt + this->m_param_ParamArrayExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamArrayExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT) { + A _val = A({1, 2, 3}); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + } + } + + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCTEXT; - // Get parameter ParamStructExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStructExt + this->m_param_ParamStructExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStructExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRUCTEXT, + this->m_param_ParamStructExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + // Call notifier this->parametersLoaded(); } @@ -1542,8 +1582,7 @@ void PassiveExternalParamsComponentBase :: PassiveExternalParamsComponentBase :: PassiveExternalParamsComponentBase(const char* compName) : - Fw::PassiveComponentBase(compName), - paramDelegatePtr(nullptr) + Fw::PassiveComponentBase(compName) { } @@ -2509,138 +2548,150 @@ void PassiveExternalParamsComponentBase :: I32 PassiveExternalParamsComponentBase :: paramGet_ParamI32Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; I32 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamI32Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } F64 PassiveExternalParamsComponentBase :: paramGet_ParamF64Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamF64Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } Fw::ParamString PassiveExternalParamsComponentBase :: paramGet_ParamStringExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStringExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } E PassiveExternalParamsComponentBase :: paramGet_ParamEnumExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamEnumExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } A PassiveExternalParamsComponentBase :: paramGet_ParamArrayExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamArrayExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } S PassiveExternalParamsComponentBase :: paramGet_ParamStructExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStructExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } @@ -3096,139 +3147,193 @@ void PassiveExternalParamsComponentBase :: Fw::CmdResponse PassiveExternalParamsComponentBase :: paramSet_ParamI32Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamI32Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMI32EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMI32EXT); + } + return _response; } Fw::CmdResponse PassiveExternalParamsComponentBase :: paramSet_ParamF64Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamF64Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMF64EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMF64EXT); + } + return _response; } Fw::CmdResponse PassiveExternalParamsComponentBase :: paramSet_ParamStringExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStringExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRINGEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRINGEXT); + } + return _response; } Fw::CmdResponse PassiveExternalParamsComponentBase :: paramSet_ParamEnumExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamEnumExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMENUMEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMENUMEXT); + } + return _response; } Fw::CmdResponse PassiveExternalParamsComponentBase :: paramSet_ParamArrayExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamArrayExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMARRAYEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMARRAYEXT); + } + return _response; } Fw::CmdResponse PassiveExternalParamsComponentBase :: paramSet_ParamStructExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStructExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); + } + return _response; } // ---------------------------------------------------------------------- @@ -3238,195 +3343,197 @@ Fw::CmdResponse PassiveExternalParamsComponentBase :: Fw::CmdResponse PassiveExternalParamsComponentBase :: paramSave_ParamI32Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamI32Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamI32Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMI32EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMI32EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMI32EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveExternalParamsComponentBase :: paramSave_ParamF64Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMF64EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveExternalParamsComponentBase :: paramSave_ParamStringExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRINGEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRINGEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRINGEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveExternalParamsComponentBase :: paramSave_ParamEnumExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnumExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnumExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUMEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMENUMEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUMEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveExternalParamsComponentBase :: paramSave_ParamArrayExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAYEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMARRAYEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAYEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveExternalParamsComponentBase :: paramSave_ParamStructExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStructExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStructExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCTEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCTEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } - -// ---------------------------------------------------------------------- -// Parameter delegate -// ---------------------------------------------------------------------- diff --git a/compiler/tools/fpp-to-cpp/test/component/base/PassiveExternalParamsComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/PassiveExternalParamsComponentAc.ref.hpp index e5ee087ed..316a54127 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/PassiveExternalParamsComponentAc.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/PassiveExternalParamsComponentAc.ref.hpp @@ -1757,6 +1757,30 @@ class PassiveExternalParamsComponentBase : #endif + private: + + // ---------------------------------------------------------------------- + // Parameter validity flags + // ---------------------------------------------------------------------- + + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; + private: // ---------------------------------------------------------------------- @@ -1764,7 +1788,7 @@ class PassiveExternalParamsComponentBase : // ---------------------------------------------------------------------- //! Delegate to serialize/deserialize an externally stored parameter - Fw::ParamExternalDelegate* paramDelegatePtr; + Fw::ParamExternalDelegate* paramDelegatePtr = nullptr; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/base/PassiveParamsComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/PassiveParamsComponentAc.ref.cpp index d5ed9f531..3ad881751 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/PassiveParamsComponentAc.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/PassiveParamsComponentAc.ref.cpp @@ -1373,170 +1373,150 @@ void PassiveParamsComponentBase :: void PassiveParamsComponentBase :: loadParameters() { - Fw::ParamBuffer _buff; Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_OK; const FwPrmIdType _baseId = static_cast(this->getIdBase()); FW_ASSERT(this->isConnected_prmGetOut_OutputPort(0)); FwPrmIdType _id{}; + Fw::ParamBuffer _paramBuffer; _id = _baseId + PARAMID_PARAMU32; - // Get parameter ParamU32 + // Get serialized parameter ParamU32 this->m_param_ParamU32_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamU32_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamU32); + _stat = _paramBuffer.deserializeTo(this->m_ParamU32); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamU32_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMF64; - // Get parameter ParamF64 + // Get serialized parameter ParamF64 this->m_param_ParamF64_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamF64_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamF64); + _stat = _paramBuffer.deserializeTo(this->m_ParamF64); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamF64_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRING; - // Get parameter ParamString + // Get serialized parameter ParamString this->m_param_ParamString_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamString_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamString); + _stat = _paramBuffer.deserializeTo(this->m_ParamString); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamString = Fw::String("default"); } } else { - // Set default value this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT) { this->m_ParamString = Fw::String("default"); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMENUM; - // Get parameter ParamEnum + // Get serialized parameter ParamEnum this->m_param_ParamEnum_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamEnum); + _stat = _paramBuffer.deserializeTo(this->m_ParamEnum); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamEnum_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMARRAY; - // Get parameter ParamArray + // Get serialized parameter ParamArray this->m_param_ParamArray_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamArray_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamArray); + _stat = _paramBuffer.deserializeTo(this->m_ParamArray); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamArray = A({1, 2, 3}); } } else { - // Set default value this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT) { this->m_ParamArray = A({1, 2, 3}); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCT; - // Get parameter ParamStruct + // Get serialized parameter ParamStruct this->m_param_ParamStruct_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamStruct); + _stat = _paramBuffer.deserializeTo(this->m_ParamStruct); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamStruct_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parametersLoaded(); @@ -1550,12 +1530,7 @@ PassiveParamsComponentBase :: PassiveParamsComponentBase(const char* compName) : Fw::PassiveComponentBase(compName) { - this->m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamString_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; + } PassiveParamsComponentBase :: @@ -2519,66 +2494,84 @@ void PassiveParamsComponentBase :: U32 PassiveParamsComponentBase :: paramGet_ParamU32(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; U32 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamU32_valid; - _local = this->m_ParamU32; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamU32; + } + this->m_paramLock.unlock(); return _local; } F64 PassiveParamsComponentBase :: paramGet_ParamF64(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamF64_valid; - _local = this->m_ParamF64; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamF64; + } + this->m_paramLock.unlock(); return _local; } Fw::ParamString PassiveParamsComponentBase :: paramGet_ParamString(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamString_valid; - _local = this->m_ParamString; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamString; + } + this->m_paramLock.unlock(); return _local; } E PassiveParamsComponentBase :: paramGet_ParamEnum(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamEnum_valid; - _local = this->m_ParamEnum; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamEnum; + } + this->m_paramLock.unlock(); return _local; } A PassiveParamsComponentBase :: paramGet_ParamArray(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamArray_valid; - _local = this->m_ParamArray; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamArray; + } + this->m_paramLock.unlock(); return _local; } S PassiveParamsComponentBase :: paramGet_ParamStruct(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamStruct_valid; - _local = this->m_ParamStruct; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamStruct; + } + this->m_paramLock.unlock(); return _local; } @@ -3033,7 +3026,7 @@ Fw::CmdResponse PassiveParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamU32 = _localVal; this->m_param_ParamU32_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMU32); @@ -3053,7 +3046,7 @@ Fw::CmdResponse PassiveParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamF64 = _localVal; this->m_param_ParamF64_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMF64); @@ -3073,7 +3066,7 @@ Fw::CmdResponse PassiveParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamString = _localVal; this->m_param_ParamString_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRING); @@ -3093,7 +3086,7 @@ Fw::CmdResponse PassiveParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamEnum = _localVal; this->m_param_ParamEnum_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMENUM); @@ -3113,7 +3106,7 @@ Fw::CmdResponse PassiveParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamArray = _localVal; this->m_param_ParamArray_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMARRAY); @@ -3133,7 +3126,7 @@ Fw::CmdResponse PassiveParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamStruct = _localVal; this->m_param_ParamStruct_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRUCT); @@ -3147,185 +3140,167 @@ Fw::CmdResponse PassiveParamsComponentBase :: Fw::CmdResponse PassiveParamsComponentBase :: paramSave_ParamU32() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamU32); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMU32); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamU32_valid == Fw::ParamValid::VALID) || (this->m_param_ParamU32_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamU32); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMU32), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveParamsComponentBase :: paramSave_ParamF64() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamF64); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamF64); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveParamsComponentBase :: paramSave_ParamString() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamString); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRING); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamString_valid == Fw::ParamValid::VALID) || (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamString); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRING), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveParamsComponentBase :: paramSave_ParamEnum() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamEnum); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUM); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnum_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamEnum); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUM), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveParamsComponentBase :: paramSave_ParamArray() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamArray); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAY); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArray_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamArray); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAY), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveParamsComponentBase :: paramSave_ParamStruct() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamStruct); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStruct_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamStruct); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } diff --git a/compiler/tools/fpp-to-cpp/test/component/base/PassiveParamsComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/PassiveParamsComponentAc.ref.hpp index cee47aaaa..81b9336c6 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/PassiveParamsComponentAc.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/PassiveParamsComponentAc.ref.hpp @@ -1751,23 +1751,23 @@ class PassiveParamsComponentBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/base/PassiveSerialComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/PassiveSerialComponentAc.ref.cpp index c569b153d..a537233c4 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/PassiveSerialComponentAc.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/PassiveSerialComponentAc.ref.cpp @@ -1618,323 +1618,343 @@ void PassiveSerialComponentBase :: void PassiveSerialComponentBase :: loadParameters() { - Fw::ParamBuffer _buff; Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_OK; const FwPrmIdType _baseId = static_cast(this->getIdBase()); FW_ASSERT(this->isConnected_prmGetOut_OutputPort(0)); FwPrmIdType _id{}; - - Fw::ParamValid _paramValid; + Fw::ParamBuffer _paramBuffer; _id = _baseId + PARAMID_PARAMU32; - // Get parameter ParamU32 + // Get serialized parameter ParamU32 this->m_param_ParamU32_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamU32_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamU32); + _stat = _paramBuffer.deserializeTo(this->m_ParamU32); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamU32_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMF64; - // Get parameter ParamF64 + // Get serialized parameter ParamF64 this->m_param_ParamF64_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamF64_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamF64); + _stat = _paramBuffer.deserializeTo(this->m_ParamF64); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamF64_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRING; - // Get parameter ParamString + // Get serialized parameter ParamString this->m_param_ParamString_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamString_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamString); + _stat = _paramBuffer.deserializeTo(this->m_ParamString); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamString = Fw::String("default"); } } else { - // Set default value this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT) { this->m_ParamString = Fw::String("default"); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMENUM; - // Get parameter ParamEnum + // Get serialized parameter ParamEnum this->m_param_ParamEnum_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamEnum); + _stat = _paramBuffer.deserializeTo(this->m_ParamEnum); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamEnum_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMARRAY; - // Get parameter ParamArray + // Get serialized parameter ParamArray this->m_param_ParamArray_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamArray_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamArray); + _stat = _paramBuffer.deserializeTo(this->m_ParamArray); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamArray = A({1, 2, 3}); } } else { - // Set default value this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT) { this->m_ParamArray = A({1, 2, 3}); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCT; - // Get parameter ParamStruct + // Get serialized parameter ParamStruct this->m_param_ParamStruct_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamStruct); + _stat = _paramBuffer.deserializeTo(this->m_ParamStruct); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamStruct_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMI32EXT; - // Get parameter ParamI32Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamI32Ext + this->m_param_ParamI32Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMI32EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamI32Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMI32EXT, + this->m_param_ParamI32Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMF64EXT; - // Get parameter ParamF64Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamF64Ext + this->m_param_ParamF64Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMF64EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamF64Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMF64EXT, + this->m_param_ParamF64Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMSTRINGEXT; - // Get parameter ParamStringExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStringExt + this->m_param_ParamStringExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStringExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT) { + Fw::String _val = Fw::String("external default"); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMENUMEXT; - // Get parameter ParamEnumExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamEnumExt + this->m_param_ParamEnumExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMENUMEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamEnumExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMENUMEXT, + this->m_param_ParamEnumExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMARRAYEXT; - // Get parameter ParamArrayExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamArrayExt + this->m_param_ParamArrayExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamArrayExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT) { + A _val = A({1, 2, 3}); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + } + } + + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCTEXT; - // Get parameter ParamStructExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStructExt + this->m_param_ParamStructExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStructExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRUCTEXT, + this->m_param_ParamStructExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + // Call notifier this->parametersLoaded(); } @@ -1945,8 +1965,7 @@ void PassiveSerialComponentBase :: PassiveSerialComponentBase :: PassiveSerialComponentBase(const char* compName) : - Fw::PassiveComponentBase(compName), - paramDelegatePtr(nullptr) + Fw::PassiveComponentBase(compName) { this->m_EventActivityLowThrottledThrottle = 0; this->m_EventFatalThrottledThrottle = 0; @@ -1954,13 +1973,6 @@ PassiveSerialComponentBase :: this->m_EventWarningLowThrottledIntervalThrottle = 0; this->m_EventWarningLowThrottledIntervalThrottleTime = Fw::Time(); - - this->m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamString_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; } PassiveSerialComponentBase :: @@ -5021,204 +5033,234 @@ void PassiveSerialComponentBase :: U32 PassiveSerialComponentBase :: paramGet_ParamU32(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; U32 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamU32_valid; - _local = this->m_ParamU32; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamU32; + } + this->m_paramLock.unlock(); return _local; } F64 PassiveSerialComponentBase :: paramGet_ParamF64(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamF64_valid; - _local = this->m_ParamF64; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamF64; + } + this->m_paramLock.unlock(); return _local; } Fw::ParamString PassiveSerialComponentBase :: paramGet_ParamString(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamString_valid; - _local = this->m_ParamString; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamString; + } + this->m_paramLock.unlock(); return _local; } E PassiveSerialComponentBase :: paramGet_ParamEnum(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamEnum_valid; - _local = this->m_ParamEnum; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamEnum; + } + this->m_paramLock.unlock(); return _local; } A PassiveSerialComponentBase :: paramGet_ParamArray(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamArray_valid; - _local = this->m_ParamArray; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamArray; + } + this->m_paramLock.unlock(); return _local; } S PassiveSerialComponentBase :: paramGet_ParamStruct(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamStruct_valid; - _local = this->m_ParamStruct; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamStruct; + } + this->m_paramLock.unlock(); return _local; } I32 PassiveSerialComponentBase :: paramGet_ParamI32Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; I32 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamI32Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } F64 PassiveSerialComponentBase :: paramGet_ParamF64Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamF64Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } Fw::ParamString PassiveSerialComponentBase :: paramGet_ParamStringExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStringExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } E PassiveSerialComponentBase :: paramGet_ParamEnumExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamEnumExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } A PassiveSerialComponentBase :: paramGet_ParamArrayExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamArrayExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } S PassiveSerialComponentBase :: paramGet_ParamStructExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStructExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } @@ -5802,7 +5844,7 @@ Fw::CmdResponse PassiveSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamU32 = _localVal; this->m_param_ParamU32_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMU32); @@ -5822,7 +5864,7 @@ Fw::CmdResponse PassiveSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamF64 = _localVal; this->m_param_ParamF64_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMF64); @@ -5842,7 +5884,7 @@ Fw::CmdResponse PassiveSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamString = _localVal; this->m_param_ParamString_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRING); @@ -5862,7 +5904,7 @@ Fw::CmdResponse PassiveSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamEnum = _localVal; this->m_param_ParamEnum_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMENUM); @@ -5882,7 +5924,7 @@ Fw::CmdResponse PassiveSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamArray = _localVal; this->m_param_ParamArray_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMARRAY); @@ -5902,7 +5944,7 @@ Fw::CmdResponse PassiveSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamStruct = _localVal; this->m_param_ParamStruct_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRUCT); @@ -5912,139 +5954,193 @@ Fw::CmdResponse PassiveSerialComponentBase :: Fw::CmdResponse PassiveSerialComponentBase :: paramSet_ParamI32Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamI32Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMI32EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMI32EXT); + } + return _response; } Fw::CmdResponse PassiveSerialComponentBase :: paramSet_ParamF64Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamF64Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMF64EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMF64EXT); + } + return _response; } Fw::CmdResponse PassiveSerialComponentBase :: paramSet_ParamStringExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStringExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRINGEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRINGEXT); + } + return _response; } Fw::CmdResponse PassiveSerialComponentBase :: paramSet_ParamEnumExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamEnumExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMENUMEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMENUMEXT); + } + return _response; } Fw::CmdResponse PassiveSerialComponentBase :: paramSet_ParamArrayExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamArrayExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMARRAYEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMARRAYEXT); + } + return _response; } Fw::CmdResponse PassiveSerialComponentBase :: paramSet_ParamStructExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStructExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); + } + return _response; } // ---------------------------------------------------------------------- @@ -6054,381 +6150,365 @@ Fw::CmdResponse PassiveSerialComponentBase :: Fw::CmdResponse PassiveSerialComponentBase :: paramSave_ParamU32() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamU32); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMU32); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamU32_valid == Fw::ParamValid::VALID) || (this->m_param_ParamU32_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamU32); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMU32), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveSerialComponentBase :: paramSave_ParamF64() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamF64); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamF64); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveSerialComponentBase :: paramSave_ParamString() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamString); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRING); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamString_valid == Fw::ParamValid::VALID) || (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamString); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRING), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveSerialComponentBase :: paramSave_ParamEnum() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamEnum); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUM); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnum_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamEnum); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUM), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveSerialComponentBase :: paramSave_ParamArray() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamArray); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAY); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArray_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamArray); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAY), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveSerialComponentBase :: paramSave_ParamStruct() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamStruct); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStruct_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamStruct); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveSerialComponentBase :: paramSave_ParamI32Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamI32Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamI32Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMI32EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMI32EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMI32EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveSerialComponentBase :: paramSave_ParamF64Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMF64EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveSerialComponentBase :: paramSave_ParamStringExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRINGEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRINGEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRINGEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveSerialComponentBase :: paramSave_ParamEnumExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnumExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnumExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUMEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMENUMEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUMEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveSerialComponentBase :: paramSave_ParamArrayExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAYEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMARRAYEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAYEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveSerialComponentBase :: paramSave_ParamStructExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStructExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStructExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCTEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCTEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } - -// ---------------------------------------------------------------------- -// Parameter delegate -// ---------------------------------------------------------------------- diff --git a/compiler/tools/fpp-to-cpp/test/component/base/PassiveSerialComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/PassiveSerialComponentAc.ref.hpp index 349782b6f..d4831e619 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/PassiveSerialComponentAc.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/PassiveSerialComponentAc.ref.hpp @@ -2680,23 +2680,41 @@ class PassiveSerialComponentBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; private: @@ -2742,7 +2760,7 @@ class PassiveSerialComponentBase : // ---------------------------------------------------------------------- //! Delegate to serialize/deserialize an externally stored parameter - Fw::ParamExternalDelegate* paramDelegatePtr; + Fw::ParamExternalDelegate* paramDelegatePtr = nullptr; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/base/PassiveTestComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/PassiveTestComponentAc.ref.cpp index 4f75df3a6..9e6b67904 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/PassiveTestComponentAc.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/PassiveTestComponentAc.ref.cpp @@ -1850,323 +1850,343 @@ void PassiveTestComponentBase :: void PassiveTestComponentBase :: loadParameters() { - Fw::ParamBuffer _buff; Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_OK; const FwPrmIdType _baseId = static_cast(this->getIdBase()); FW_ASSERT(this->isConnected_prmGetOut_OutputPort(0)); FwPrmIdType _id{}; - - Fw::ParamValid _paramValid; + Fw::ParamBuffer _paramBuffer; _id = _baseId + PARAMID_PARAMU32; - // Get parameter ParamU32 + // Get serialized parameter ParamU32 this->m_param_ParamU32_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamU32_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamU32); + _stat = _paramBuffer.deserializeTo(this->m_ParamU32); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamU32_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMF64; - // Get parameter ParamF64 + // Get serialized parameter ParamF64 this->m_param_ParamF64_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamF64_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamF64); + _stat = _paramBuffer.deserializeTo(this->m_ParamF64); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamF64_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRING; - // Get parameter ParamString + // Get serialized parameter ParamString this->m_param_ParamString_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamString_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamString); + _stat = _paramBuffer.deserializeTo(this->m_ParamString); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamString = Fw::String("default"); } } else { - // Set default value this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT) { this->m_ParamString = Fw::String("default"); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMENUM; - // Get parameter ParamEnum + // Get serialized parameter ParamEnum this->m_param_ParamEnum_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamEnum); + _stat = _paramBuffer.deserializeTo(this->m_ParamEnum); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamEnum_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMARRAY; - // Get parameter ParamArray + // Get serialized parameter ParamArray this->m_param_ParamArray_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamArray_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamArray); + _stat = _paramBuffer.deserializeTo(this->m_ParamArray); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamArray = A({1, 2, 3}); } } else { - // Set default value this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT) { this->m_ParamArray = A({1, 2, 3}); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCT; - // Get parameter ParamStruct + // Get serialized parameter ParamStruct this->m_param_ParamStruct_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamStruct); + _stat = _paramBuffer.deserializeTo(this->m_ParamStruct); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamStruct_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMI32EXT; - // Get parameter ParamI32Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamI32Ext + this->m_param_ParamI32Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMI32EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamI32Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMI32EXT, + this->m_param_ParamI32Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMF64EXT; - // Get parameter ParamF64Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamF64Ext + this->m_param_ParamF64Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMF64EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamF64Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMF64EXT, + this->m_param_ParamF64Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMSTRINGEXT; - // Get parameter ParamStringExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStringExt + this->m_param_ParamStringExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStringExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT) { + Fw::String _val = Fw::String("external default"); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMENUMEXT; - // Get parameter ParamEnumExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamEnumExt + this->m_param_ParamEnumExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMENUMEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamEnumExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMENUMEXT, + this->m_param_ParamEnumExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMARRAYEXT; - // Get parameter ParamArrayExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamArrayExt + this->m_param_ParamArrayExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamArrayExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT) { + A _val = A({1, 2, 3}); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + } + } + + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCTEXT; - // Get parameter ParamStructExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStructExt + this->m_param_ParamStructExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStructExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRUCTEXT, + this->m_param_ParamStructExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + // Call notifier this->parametersLoaded(); } @@ -2177,8 +2197,7 @@ void PassiveTestComponentBase :: PassiveTestComponentBase :: PassiveTestComponentBase(const char* compName) : - Fw::PassiveComponentBase(compName), - paramDelegatePtr(nullptr) + Fw::PassiveComponentBase(compName) { this->m_EventActivityLowThrottledThrottle = 0; this->m_EventFatalThrottledThrottle = 0; @@ -2186,13 +2205,6 @@ PassiveTestComponentBase :: this->m_EventWarningLowThrottledIntervalThrottle = 0; this->m_EventWarningLowThrottledIntervalThrottleTime = Fw::Time(); - - this->m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamString_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; } PassiveTestComponentBase :: @@ -5201,204 +5213,234 @@ void PassiveTestComponentBase :: U32 PassiveTestComponentBase :: paramGet_ParamU32(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; U32 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamU32_valid; - _local = this->m_ParamU32; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamU32; + } + this->m_paramLock.unlock(); return _local; } F64 PassiveTestComponentBase :: paramGet_ParamF64(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamF64_valid; - _local = this->m_ParamF64; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamF64; + } + this->m_paramLock.unlock(); return _local; } Fw::ParamString PassiveTestComponentBase :: paramGet_ParamString(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamString_valid; - _local = this->m_ParamString; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamString; + } + this->m_paramLock.unlock(); return _local; } E PassiveTestComponentBase :: paramGet_ParamEnum(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamEnum_valid; - _local = this->m_ParamEnum; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamEnum; + } + this->m_paramLock.unlock(); return _local; } A PassiveTestComponentBase :: paramGet_ParamArray(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamArray_valid; - _local = this->m_ParamArray; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamArray; + } + this->m_paramLock.unlock(); return _local; } S PassiveTestComponentBase :: paramGet_ParamStruct(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamStruct_valid; - _local = this->m_ParamStruct; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamStruct; + } + this->m_paramLock.unlock(); return _local; } I32 PassiveTestComponentBase :: paramGet_ParamI32Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; I32 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamI32Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } F64 PassiveTestComponentBase :: paramGet_ParamF64Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamF64Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } Fw::ParamString PassiveTestComponentBase :: paramGet_ParamStringExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStringExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } E PassiveTestComponentBase :: paramGet_ParamEnumExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamEnumExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } A PassiveTestComponentBase :: paramGet_ParamArrayExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamArrayExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } S PassiveTestComponentBase :: paramGet_ParamStructExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStructExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } @@ -6037,7 +6079,7 @@ Fw::CmdResponse PassiveTestComponentBase :: this->m_paramLock.lock(); this->m_ParamU32 = _localVal; this->m_param_ParamU32_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMU32); @@ -6057,7 +6099,7 @@ Fw::CmdResponse PassiveTestComponentBase :: this->m_paramLock.lock(); this->m_ParamF64 = _localVal; this->m_param_ParamF64_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMF64); @@ -6077,7 +6119,7 @@ Fw::CmdResponse PassiveTestComponentBase :: this->m_paramLock.lock(); this->m_ParamString = _localVal; this->m_param_ParamString_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRING); @@ -6097,7 +6139,7 @@ Fw::CmdResponse PassiveTestComponentBase :: this->m_paramLock.lock(); this->m_ParamEnum = _localVal; this->m_param_ParamEnum_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMENUM); @@ -6117,7 +6159,7 @@ Fw::CmdResponse PassiveTestComponentBase :: this->m_paramLock.lock(); this->m_ParamArray = _localVal; this->m_param_ParamArray_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMARRAY); @@ -6137,7 +6179,7 @@ Fw::CmdResponse PassiveTestComponentBase :: this->m_paramLock.lock(); this->m_ParamStruct = _localVal; this->m_param_ParamStruct_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRUCT); @@ -6147,139 +6189,193 @@ Fw::CmdResponse PassiveTestComponentBase :: Fw::CmdResponse PassiveTestComponentBase :: paramSet_ParamI32Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamI32Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMI32EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMI32EXT); + } + return _response; } Fw::CmdResponse PassiveTestComponentBase :: paramSet_ParamF64Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamF64Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMF64EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMF64EXT); + } + return _response; } Fw::CmdResponse PassiveTestComponentBase :: paramSet_ParamStringExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStringExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRINGEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRINGEXT); + } + return _response; } Fw::CmdResponse PassiveTestComponentBase :: paramSet_ParamEnumExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamEnumExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMENUMEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMENUMEXT); + } + return _response; } Fw::CmdResponse PassiveTestComponentBase :: paramSet_ParamArrayExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamArrayExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMARRAYEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMARRAYEXT); + } + return _response; } Fw::CmdResponse PassiveTestComponentBase :: paramSet_ParamStructExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStructExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); + } + return _response; } // ---------------------------------------------------------------------- @@ -6289,379 +6385,367 @@ Fw::CmdResponse PassiveTestComponentBase :: Fw::CmdResponse PassiveTestComponentBase :: paramSave_ParamU32() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamU32); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMU32); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamU32_valid == Fw::ParamValid::VALID) || (this->m_param_ParamU32_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamU32); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMU32), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveTestComponentBase :: paramSave_ParamF64() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamF64); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamF64); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveTestComponentBase :: paramSave_ParamString() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamString); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRING); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamString_valid == Fw::ParamValid::VALID) || (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamString); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRING), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveTestComponentBase :: paramSave_ParamEnum() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamEnum); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUM); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnum_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamEnum); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUM), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveTestComponentBase :: paramSave_ParamArray() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamArray); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAY); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArray_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamArray); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAY), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveTestComponentBase :: paramSave_ParamStruct() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamStruct); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStruct_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamStruct); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveTestComponentBase :: paramSave_ParamI32Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamI32Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamI32Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMI32EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMI32EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMI32EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveTestComponentBase :: paramSave_ParamF64Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMF64EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveTestComponentBase :: paramSave_ParamStringExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRINGEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRINGEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRINGEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveTestComponentBase :: paramSave_ParamEnumExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnumExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnumExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUMEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMENUMEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUMEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveTestComponentBase :: paramSave_ParamArrayExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAYEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMARRAYEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAYEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse PassiveTestComponentBase :: paramSave_ParamStructExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStructExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStructExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCTEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCTEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } // ---------------------------------------------------------------------- @@ -6736,7 +6820,3 @@ void PassiveTestComponentBase :: break; } } - -// ---------------------------------------------------------------------- -// Parameter delegate -// ---------------------------------------------------------------------- diff --git a/compiler/tools/fpp-to-cpp/test/component/base/PassiveTestComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/PassiveTestComponentAc.ref.hpp index 3bbfd5aee..b3eb93f43 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/PassiveTestComponentAc.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/PassiveTestComponentAc.ref.hpp @@ -2825,23 +2825,41 @@ class PassiveTestComponentBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; private: @@ -2887,7 +2905,7 @@ class PassiveTestComponentBase : // ---------------------------------------------------------------------- //! Delegate to serialize/deserialize an externally stored parameter - Fw::ParamExternalDelegate* paramDelegatePtr; + Fw::ParamExternalDelegate* paramDelegatePtr = nullptr; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedExternalParamsComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedExternalParamsComponentAc.ref.cpp index 171214e50..ae159a9ff 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedExternalParamsComponentAc.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedExternalParamsComponentAc.ref.cpp @@ -1666,165 +1666,205 @@ void QueuedExternalParamsComponentBase :: void QueuedExternalParamsComponentBase :: loadParameters() { - Fw::ParamBuffer _buff; Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_OK; const FwPrmIdType _baseId = static_cast(this->getIdBase()); FW_ASSERT(this->isConnected_prmGetOut_OutputPort(0)); FwPrmIdType _id{}; - - Fw::ParamValid _paramValid; + Fw::ParamBuffer _paramBuffer; _id = _baseId + PARAMID_PARAMI32EXT; - // Get parameter ParamI32Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamI32Ext + this->m_param_ParamI32Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMI32EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamI32Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMI32EXT, + this->m_param_ParamI32Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMF64EXT; - // Get parameter ParamF64Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamF64Ext + this->m_param_ParamF64Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMF64EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamF64Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMF64EXT, + this->m_param_ParamF64Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMSTRINGEXT; - // Get parameter ParamStringExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStringExt + this->m_param_ParamStringExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStringExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; } + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT) { + Fw::String _val = Fw::String("external default"); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + } + } + + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMENUMEXT; - // Get parameter ParamEnumExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamEnumExt + this->m_param_ParamEnumExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMENUMEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamEnumExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMENUMEXT, + this->m_param_ParamEnumExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMARRAYEXT; - // Get parameter ParamArrayExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamArrayExt + this->m_param_ParamArrayExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamArrayExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT) { + A _val = A({1, 2, 3}); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + } + } + + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCTEXT; - // Get parameter ParamStructExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStructExt + this->m_param_ParamStructExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStructExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRUCTEXT, + this->m_param_ParamStructExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + // Call notifier this->parametersLoaded(); } @@ -1835,8 +1875,7 @@ void QueuedExternalParamsComponentBase :: QueuedExternalParamsComponentBase :: QueuedExternalParamsComponentBase(const char* compName) : - Fw::QueuedComponentBase(compName), - paramDelegatePtr(nullptr) + Fw::QueuedComponentBase(compName) { } @@ -3471,138 +3510,150 @@ void QueuedExternalParamsComponentBase :: I32 QueuedExternalParamsComponentBase :: paramGet_ParamI32Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; I32 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamI32Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } F64 QueuedExternalParamsComponentBase :: paramGet_ParamF64Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamF64Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } Fw::ParamString QueuedExternalParamsComponentBase :: paramGet_ParamStringExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStringExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } E QueuedExternalParamsComponentBase :: paramGet_ParamEnumExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamEnumExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } A QueuedExternalParamsComponentBase :: paramGet_ParamArrayExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamArrayExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } S QueuedExternalParamsComponentBase :: paramGet_ParamStructExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStructExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } @@ -4652,139 +4703,193 @@ void QueuedExternalParamsComponentBase :: Fw::CmdResponse QueuedExternalParamsComponentBase :: paramSet_ParamI32Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamI32Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMI32EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMI32EXT); + } + return _response; } Fw::CmdResponse QueuedExternalParamsComponentBase :: paramSet_ParamF64Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamF64Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMF64EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMF64EXT); + } + return _response; } Fw::CmdResponse QueuedExternalParamsComponentBase :: paramSet_ParamStringExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStringExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRINGEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRINGEXT); + } + return _response; } Fw::CmdResponse QueuedExternalParamsComponentBase :: paramSet_ParamEnumExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamEnumExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMENUMEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMENUMEXT); + } + return _response; } Fw::CmdResponse QueuedExternalParamsComponentBase :: paramSet_ParamArrayExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamArrayExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMARRAYEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMARRAYEXT); + } + return _response; } Fw::CmdResponse QueuedExternalParamsComponentBase :: paramSet_ParamStructExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStructExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); + } + return _response; } // ---------------------------------------------------------------------- @@ -4794,195 +4899,197 @@ Fw::CmdResponse QueuedExternalParamsComponentBase :: Fw::CmdResponse QueuedExternalParamsComponentBase :: paramSave_ParamI32Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamI32Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamI32Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMI32EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMI32EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMI32EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedExternalParamsComponentBase :: paramSave_ParamF64Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMF64EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedExternalParamsComponentBase :: paramSave_ParamStringExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRINGEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRINGEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRINGEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedExternalParamsComponentBase :: paramSave_ParamEnumExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnumExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnumExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUMEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMENUMEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUMEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedExternalParamsComponentBase :: paramSave_ParamArrayExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAYEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMARRAYEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAYEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedExternalParamsComponentBase :: paramSave_ParamStructExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStructExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStructExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCTEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCTEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } - -// ---------------------------------------------------------------------- -// Parameter delegate -// ---------------------------------------------------------------------- diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedExternalParamsComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedExternalParamsComponentAc.ref.hpp index 324aa3b88..773890d52 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedExternalParamsComponentAc.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedExternalParamsComponentAc.ref.hpp @@ -2160,6 +2160,30 @@ class QueuedExternalParamsComponentBase : #endif + private: + + // ---------------------------------------------------------------------- + // Parameter validity flags + // ---------------------------------------------------------------------- + + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; + private: // ---------------------------------------------------------------------- @@ -2167,7 +2191,7 @@ class QueuedExternalParamsComponentBase : // ---------------------------------------------------------------------- //! Delegate to serialize/deserialize an externally stored parameter - Fw::ParamExternalDelegate* paramDelegatePtr; + Fw::ParamExternalDelegate* paramDelegatePtr = nullptr; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedParamsComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedParamsComponentAc.ref.cpp index f784aa371..cd709ff02 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedParamsComponentAc.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedParamsComponentAc.ref.cpp @@ -1666,170 +1666,150 @@ void QueuedParamsComponentBase :: void QueuedParamsComponentBase :: loadParameters() { - Fw::ParamBuffer _buff; Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_OK; const FwPrmIdType _baseId = static_cast(this->getIdBase()); FW_ASSERT(this->isConnected_prmGetOut_OutputPort(0)); FwPrmIdType _id{}; + Fw::ParamBuffer _paramBuffer; _id = _baseId + PARAMID_PARAMU32; - // Get parameter ParamU32 + // Get serialized parameter ParamU32 this->m_param_ParamU32_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamU32_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamU32); + _stat = _paramBuffer.deserializeTo(this->m_ParamU32); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamU32_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMF64; - // Get parameter ParamF64 + // Get serialized parameter ParamF64 this->m_param_ParamF64_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamF64_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamF64); + _stat = _paramBuffer.deserializeTo(this->m_ParamF64); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamF64_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRING; - // Get parameter ParamString + // Get serialized parameter ParamString this->m_param_ParamString_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamString_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamString); + _stat = _paramBuffer.deserializeTo(this->m_ParamString); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamString = Fw::String("default"); } } else { - // Set default value this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT) { this->m_ParamString = Fw::String("default"); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMENUM; - // Get parameter ParamEnum + // Get serialized parameter ParamEnum this->m_param_ParamEnum_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamEnum); + _stat = _paramBuffer.deserializeTo(this->m_ParamEnum); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamEnum_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMARRAY; - // Get parameter ParamArray + // Get serialized parameter ParamArray this->m_param_ParamArray_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamArray_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamArray); + _stat = _paramBuffer.deserializeTo(this->m_ParamArray); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamArray = A({1, 2, 3}); } } else { - // Set default value this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT) { this->m_ParamArray = A({1, 2, 3}); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCT; - // Get parameter ParamStruct + // Get serialized parameter ParamStruct this->m_param_ParamStruct_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamStruct); + _stat = _paramBuffer.deserializeTo(this->m_ParamStruct); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamStruct_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parametersLoaded(); @@ -1843,12 +1823,7 @@ QueuedParamsComponentBase :: QueuedParamsComponentBase(const char* compName) : Fw::QueuedComponentBase(compName) { - this->m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamString_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; + } QueuedParamsComponentBase :: @@ -3481,66 +3456,84 @@ void QueuedParamsComponentBase :: U32 QueuedParamsComponentBase :: paramGet_ParamU32(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; U32 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamU32_valid; - _local = this->m_ParamU32; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamU32; + } + this->m_paramLock.unlock(); return _local; } F64 QueuedParamsComponentBase :: paramGet_ParamF64(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamF64_valid; - _local = this->m_ParamF64; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamF64; + } + this->m_paramLock.unlock(); return _local; } Fw::ParamString QueuedParamsComponentBase :: paramGet_ParamString(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamString_valid; - _local = this->m_ParamString; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamString; + } + this->m_paramLock.unlock(); return _local; } E QueuedParamsComponentBase :: paramGet_ParamEnum(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamEnum_valid; - _local = this->m_ParamEnum; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamEnum; + } + this->m_paramLock.unlock(); return _local; } A QueuedParamsComponentBase :: paramGet_ParamArray(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamArray_valid; - _local = this->m_ParamArray; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamArray; + } + this->m_paramLock.unlock(); return _local; } S QueuedParamsComponentBase :: paramGet_ParamStruct(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamStruct_valid; - _local = this->m_ParamStruct; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamStruct; + } + this->m_paramLock.unlock(); return _local; } @@ -4589,7 +4582,7 @@ Fw::CmdResponse QueuedParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamU32 = _localVal; this->m_param_ParamU32_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMU32); @@ -4609,7 +4602,7 @@ Fw::CmdResponse QueuedParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamF64 = _localVal; this->m_param_ParamF64_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMF64); @@ -4629,7 +4622,7 @@ Fw::CmdResponse QueuedParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamString = _localVal; this->m_param_ParamString_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRING); @@ -4649,7 +4642,7 @@ Fw::CmdResponse QueuedParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamEnum = _localVal; this->m_param_ParamEnum_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMENUM); @@ -4669,7 +4662,7 @@ Fw::CmdResponse QueuedParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamArray = _localVal; this->m_param_ParamArray_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMARRAY); @@ -4689,7 +4682,7 @@ Fw::CmdResponse QueuedParamsComponentBase :: this->m_paramLock.lock(); this->m_ParamStruct = _localVal; this->m_param_ParamStruct_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRUCT); @@ -4703,185 +4696,167 @@ Fw::CmdResponse QueuedParamsComponentBase :: Fw::CmdResponse QueuedParamsComponentBase :: paramSave_ParamU32() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamU32); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMU32); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamU32_valid == Fw::ParamValid::VALID) || (this->m_param_ParamU32_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamU32); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMU32), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedParamsComponentBase :: paramSave_ParamF64() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamF64); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamF64); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedParamsComponentBase :: paramSave_ParamString() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamString); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRING); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamString_valid == Fw::ParamValid::VALID) || (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamString); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRING), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedParamsComponentBase :: paramSave_ParamEnum() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamEnum); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUM); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnum_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamEnum); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUM), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedParamsComponentBase :: paramSave_ParamArray() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamArray); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAY); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArray_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamArray); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAY), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedParamsComponentBase :: paramSave_ParamStruct() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamStruct); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStruct_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamStruct); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedParamsComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedParamsComponentAc.ref.hpp index 51919de97..7adff586a 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedParamsComponentAc.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedParamsComponentAc.ref.hpp @@ -2154,23 +2154,23 @@ class QueuedParamsComponentBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedSerialComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedSerialComponentAc.ref.cpp index b6c09849d..f43aa6254 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedSerialComponentAc.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedSerialComponentAc.ref.cpp @@ -2128,323 +2128,343 @@ void QueuedSerialComponentBase :: void QueuedSerialComponentBase :: loadParameters() { - Fw::ParamBuffer _buff; Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_OK; const FwPrmIdType _baseId = static_cast(this->getIdBase()); FW_ASSERT(this->isConnected_prmGetOut_OutputPort(0)); FwPrmIdType _id{}; - - Fw::ParamValid _paramValid; + Fw::ParamBuffer _paramBuffer; _id = _baseId + PARAMID_PARAMU32; - // Get parameter ParamU32 + // Get serialized parameter ParamU32 this->m_param_ParamU32_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamU32_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamU32); + _stat = _paramBuffer.deserializeTo(this->m_ParamU32); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamU32_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMF64; - // Get parameter ParamF64 + // Get serialized parameter ParamF64 this->m_param_ParamF64_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamF64_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamF64); + _stat = _paramBuffer.deserializeTo(this->m_ParamF64); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamF64_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRING; - // Get parameter ParamString + // Get serialized parameter ParamString this->m_param_ParamString_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamString_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamString); + _stat = _paramBuffer.deserializeTo(this->m_ParamString); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamString = Fw::String("default"); } } else { - // Set default value this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT) { this->m_ParamString = Fw::String("default"); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMENUM; - // Get parameter ParamEnum + // Get serialized parameter ParamEnum this->m_param_ParamEnum_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamEnum); + _stat = _paramBuffer.deserializeTo(this->m_ParamEnum); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamEnum_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMARRAY; - // Get parameter ParamArray + // Get serialized parameter ParamArray this->m_param_ParamArray_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamArray_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamArray); + _stat = _paramBuffer.deserializeTo(this->m_ParamArray); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamArray = A({1, 2, 3}); } } else { - // Set default value this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT) { this->m_ParamArray = A({1, 2, 3}); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCT; - // Get parameter ParamStruct + // Get serialized parameter ParamStruct this->m_param_ParamStruct_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamStruct); + _stat = _paramBuffer.deserializeTo(this->m_ParamStruct); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamStruct_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMI32EXT; - // Get parameter ParamI32Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamI32Ext + this->m_param_ParamI32Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMI32EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamI32Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMI32EXT, + this->m_param_ParamI32Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMF64EXT; - // Get parameter ParamF64Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamF64Ext + this->m_param_ParamF64Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMF64EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamF64Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMF64EXT, + this->m_param_ParamF64Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMSTRINGEXT; - // Get parameter ParamStringExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStringExt + this->m_param_ParamStringExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStringExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT) { + Fw::String _val = Fw::String("external default"); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMENUMEXT; - // Get parameter ParamEnumExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamEnumExt + this->m_param_ParamEnumExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMENUMEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamEnumExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMENUMEXT, + this->m_param_ParamEnumExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMARRAYEXT; - // Get parameter ParamArrayExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamArrayExt + this->m_param_ParamArrayExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamArrayExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT) { + A _val = A({1, 2, 3}); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + } + } + + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCTEXT; - // Get parameter ParamStructExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStructExt + this->m_param_ParamStructExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStructExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRUCTEXT, + this->m_param_ParamStructExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + // Call notifier this->parametersLoaded(); } @@ -2455,8 +2475,7 @@ void QueuedSerialComponentBase :: QueuedSerialComponentBase :: QueuedSerialComponentBase(const char* compName) : - Fw::QueuedComponentBase(compName), - paramDelegatePtr(nullptr) + Fw::QueuedComponentBase(compName) { this->m_EventActivityLowThrottledThrottle = 0; this->m_EventFatalThrottledThrottle = 0; @@ -2464,13 +2483,6 @@ QueuedSerialComponentBase :: this->m_EventWarningLowThrottledIntervalThrottle = 0; this->m_EventWarningLowThrottledIntervalThrottleTime = Fw::Time(); - - this->m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamString_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; } QueuedSerialComponentBase :: @@ -7123,204 +7135,234 @@ void QueuedSerialComponentBase :: U32 QueuedSerialComponentBase :: paramGet_ParamU32(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; U32 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamU32_valid; - _local = this->m_ParamU32; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamU32; + } + this->m_paramLock.unlock(); return _local; } F64 QueuedSerialComponentBase :: paramGet_ParamF64(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamF64_valid; - _local = this->m_ParamF64; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamF64; + } + this->m_paramLock.unlock(); return _local; } Fw::ParamString QueuedSerialComponentBase :: paramGet_ParamString(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamString_valid; - _local = this->m_ParamString; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamString; + } + this->m_paramLock.unlock(); return _local; } E QueuedSerialComponentBase :: paramGet_ParamEnum(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamEnum_valid; - _local = this->m_ParamEnum; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamEnum; + } + this->m_paramLock.unlock(); return _local; } A QueuedSerialComponentBase :: paramGet_ParamArray(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamArray_valid; - _local = this->m_ParamArray; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamArray; + } + this->m_paramLock.unlock(); return _local; } S QueuedSerialComponentBase :: paramGet_ParamStruct(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamStruct_valid; - _local = this->m_ParamStruct; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamStruct; + } + this->m_paramLock.unlock(); return _local; } I32 QueuedSerialComponentBase :: paramGet_ParamI32Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; I32 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamI32Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } F64 QueuedSerialComponentBase :: paramGet_ParamF64Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamF64Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } Fw::ParamString QueuedSerialComponentBase :: paramGet_ParamStringExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStringExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } E QueuedSerialComponentBase :: paramGet_ParamEnumExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamEnumExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } A QueuedSerialComponentBase :: paramGet_ParamArrayExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamArrayExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } S QueuedSerialComponentBase :: paramGet_ParamStructExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStructExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } @@ -9080,7 +9122,7 @@ Fw::CmdResponse QueuedSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamU32 = _localVal; this->m_param_ParamU32_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMU32); @@ -9100,7 +9142,7 @@ Fw::CmdResponse QueuedSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamF64 = _localVal; this->m_param_ParamF64_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMF64); @@ -9120,7 +9162,7 @@ Fw::CmdResponse QueuedSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamString = _localVal; this->m_param_ParamString_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRING); @@ -9140,7 +9182,7 @@ Fw::CmdResponse QueuedSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamEnum = _localVal; this->m_param_ParamEnum_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMENUM); @@ -9160,7 +9202,7 @@ Fw::CmdResponse QueuedSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamArray = _localVal; this->m_param_ParamArray_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMARRAY); @@ -9180,7 +9222,7 @@ Fw::CmdResponse QueuedSerialComponentBase :: this->m_paramLock.lock(); this->m_ParamStruct = _localVal; this->m_param_ParamStruct_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRUCT); @@ -9190,139 +9232,193 @@ Fw::CmdResponse QueuedSerialComponentBase :: Fw::CmdResponse QueuedSerialComponentBase :: paramSet_ParamI32Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamI32Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMI32EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMI32EXT); + } + return _response; } Fw::CmdResponse QueuedSerialComponentBase :: paramSet_ParamF64Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamF64Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMF64EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMF64EXT); + } + return _response; } Fw::CmdResponse QueuedSerialComponentBase :: paramSet_ParamStringExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStringExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRINGEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRINGEXT); + } + return _response; } Fw::CmdResponse QueuedSerialComponentBase :: paramSet_ParamEnumExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamEnumExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMENUMEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMENUMEXT); + } + return _response; } Fw::CmdResponse QueuedSerialComponentBase :: paramSet_ParamArrayExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamArrayExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMARRAYEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMARRAYEXT); + } + return _response; } Fw::CmdResponse QueuedSerialComponentBase :: paramSet_ParamStructExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStructExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); + } + return _response; } // ---------------------------------------------------------------------- @@ -9332,381 +9428,365 @@ Fw::CmdResponse QueuedSerialComponentBase :: Fw::CmdResponse QueuedSerialComponentBase :: paramSave_ParamU32() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamU32); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMU32); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamU32_valid == Fw::ParamValid::VALID) || (this->m_param_ParamU32_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamU32); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMU32), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedSerialComponentBase :: paramSave_ParamF64() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamF64); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamF64); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedSerialComponentBase :: paramSave_ParamString() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamString); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRING); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamString_valid == Fw::ParamValid::VALID) || (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamString); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRING), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedSerialComponentBase :: paramSave_ParamEnum() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamEnum); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUM); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnum_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamEnum); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUM), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedSerialComponentBase :: paramSave_ParamArray() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamArray); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAY); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArray_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamArray); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAY), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedSerialComponentBase :: paramSave_ParamStruct() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamStruct); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStruct_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamStruct); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedSerialComponentBase :: paramSave_ParamI32Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamI32Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamI32Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMI32EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMI32EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMI32EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedSerialComponentBase :: paramSave_ParamF64Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMF64EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedSerialComponentBase :: paramSave_ParamStringExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRINGEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRINGEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRINGEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedSerialComponentBase :: paramSave_ParamEnumExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnumExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnumExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUMEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMENUMEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUMEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedSerialComponentBase :: paramSave_ParamArrayExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAYEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMARRAYEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAYEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedSerialComponentBase :: paramSave_ParamStructExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStructExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStructExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCTEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCTEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } - -// ---------------------------------------------------------------------- -// Parameter delegate -// ---------------------------------------------------------------------- diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedSerialComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedSerialComponentAc.ref.hpp index fe31f2579..292a46a93 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedSerialComponentAc.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedSerialComponentAc.ref.hpp @@ -3473,23 +3473,41 @@ class QueuedSerialComponentBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; private: @@ -3535,7 +3553,7 @@ class QueuedSerialComponentBase : // ---------------------------------------------------------------------- //! Delegate to serialize/deserialize an externally stored parameter - Fw::ParamExternalDelegate* paramDelegatePtr; + Fw::ParamExternalDelegate* paramDelegatePtr = nullptr; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedTestComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedTestComponentAc.ref.cpp index 988607896..309e596c6 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedTestComponentAc.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedTestComponentAc.ref.cpp @@ -2204,323 +2204,343 @@ void QueuedTestComponentBase :: void QueuedTestComponentBase :: loadParameters() { - Fw::ParamBuffer _buff; Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_OK; const FwPrmIdType _baseId = static_cast(this->getIdBase()); FW_ASSERT(this->isConnected_prmGetOut_OutputPort(0)); FwPrmIdType _id{}; - - Fw::ParamValid _paramValid; + Fw::ParamBuffer _paramBuffer; _id = _baseId + PARAMID_PARAMU32; - // Get parameter ParamU32 + // Get serialized parameter ParamU32 this->m_param_ParamU32_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamU32_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamU32); + _stat = _paramBuffer.deserializeTo(this->m_ParamU32); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamU32_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMF64; - // Get parameter ParamF64 + // Get serialized parameter ParamF64 this->m_param_ParamF64_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamF64_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamF64); + _stat = _paramBuffer.deserializeTo(this->m_ParamF64); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamF64_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRING; - // Get parameter ParamString + // Get serialized parameter ParamString this->m_param_ParamString_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamString_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamString); + _stat = _paramBuffer.deserializeTo(this->m_ParamString); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamString = Fw::String("default"); } } else { - // Set default value this->m_param_ParamString_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT) { this->m_ParamString = Fw::String("default"); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMENUM; - // Get parameter ParamEnum + // Get serialized parameter ParamEnum this->m_param_ParamEnum_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamEnum); + _stat = _paramBuffer.deserializeTo(this->m_ParamEnum); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamEnum_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMARRAY; - // Get parameter ParamArray + // Get serialized parameter ParamArray this->m_param_ParamArray_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter or use default value if (this->m_param_ParamArray_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamArray); + _stat = _paramBuffer.deserializeTo(this->m_ParamArray); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; - // Set default value - this->m_ParamArray = A({1, 2, 3}); } } else { - // Set default value this->m_param_ParamArray_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT) { this->m_ParamArray = A({1, 2, 3}); } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCT; - // Get parameter ParamStruct + // Get serialized parameter ParamStruct this->m_param_ParamStruct_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // Deserialize value this->m_paramLock.lock(); - // If there was a deserialization issue, mark it invalid + // Deserialize parameter if (this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) { - _stat = _buff.deserializeTo(this->m_ParamStruct); + _stat = _paramBuffer.deserializeTo(this->m_ParamStruct); if (_stat != Fw::FW_SERIALIZE_OK) { this->m_param_ParamStruct_valid = Fw::ParamValid::INVALID; } } - else { - // No default - } - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMI32EXT; - // Get parameter ParamI32Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamI32Ext + this->m_param_ParamI32Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMI32EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamI32Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMI32EXT, + this->m_param_ParamI32Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMF64EXT; - // Get parameter ParamF64Ext - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamF64Ext + this->m_param_ParamF64Ext_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMF64EXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamF64Ext - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMF64EXT, + this->m_param_ParamF64Ext_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMSTRINGEXT; - // Get parameter ParamStringExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStringExt + this->m_param_ParamStringExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStringExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamStringExt_valid = Fw::ParamValid::DEFAULT; + } + if (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT) { + Fw::String _val = Fw::String("external default"); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRINGEXT, + this->m_param_ParamStringExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMENUMEXT; - // Get parameter ParamEnumExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamEnumExt + this->m_param_ParamEnumExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMENUMEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamEnumExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMENUMEXT, + this->m_param_ParamEnumExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + _id = _baseId + PARAMID_PARAMARRAYEXT; - // Get parameter ParamArrayExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamArrayExt + this->m_param_ParamArrayExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; + this->m_paramLock.lock(); + // Deserialize parameter or use default value + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) { FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamArrayExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } } else { - _paramValid = Fw::ParamValid::INVALID; + this->m_param_ParamArrayExt_valid = Fw::ParamValid::DEFAULT; } + if (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT) { + A _val = A({1, 2, 3}); + _paramBuffer.resetSer(); + _stat = _paramBuffer.serializeFrom(_val); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMARRAYEXT, + this->m_param_ParamArrayExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + } + } + + this->m_paramLock.unlock(); _id = _baseId + PARAMID_PARAMSTRUCTEXT; - // Get parameter ParamStructExt - _paramValid = this->prmGetOut_out( + // Get serialized parameter ParamStructExt + this->m_param_ParamStructExt_valid = this->prmGetOut_out( 0, _id, - _buff + _paramBuffer ); - // If there was a deserialization issue, mark it invalid - if (_paramValid == Fw::ParamValid::VALID) { - // Pass the local ID to the delegate - constexpr FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; + this->m_paramLock.lock(); - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate deserialize function for m_ParamStructExt - _stat = this->paramDelegatePtr->deserializeParam(_baseId, _localId, _paramValid, _buff); - if (_stat != Fw::FW_SERIALIZE_OK) { - _paramValid = Fw::ParamValid::INVALID; - } - } - else { - _paramValid = Fw::ParamValid::INVALID; + // Deserialize parameter + FW_ASSERT(this->paramDelegatePtr != nullptr); + _stat = this->paramDelegatePtr->deserializeParam( + _baseId, + PARAMID_PARAMSTRUCTEXT, + this->m_param_ParamStructExt_valid, + _paramBuffer + ); + if (_stat != Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; } + this->m_paramLock.unlock(); + // Call notifier this->parametersLoaded(); } @@ -2531,8 +2551,7 @@ void QueuedTestComponentBase :: QueuedTestComponentBase :: QueuedTestComponentBase(const char* compName) : - Fw::QueuedComponentBase(compName), - paramDelegatePtr(nullptr) + Fw::QueuedComponentBase(compName) { this->m_EventActivityLowThrottledThrottle = 0; this->m_EventFatalThrottledThrottle = 0; @@ -2540,13 +2559,6 @@ QueuedTestComponentBase :: this->m_EventWarningLowThrottledIntervalThrottle = 0; this->m_EventWarningLowThrottledIntervalThrottleTime = Fw::Time(); - - this->m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamString_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - this->m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; } QueuedTestComponentBase :: @@ -6953,204 +6965,234 @@ void QueuedTestComponentBase :: U32 QueuedTestComponentBase :: paramGet_ParamU32(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; U32 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamU32_valid; - _local = this->m_ParamU32; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamU32; + } + this->m_paramLock.unlock(); return _local; } F64 QueuedTestComponentBase :: paramGet_ParamF64(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamF64_valid; - _local = this->m_ParamF64; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamF64; + } + this->m_paramLock.unlock(); return _local; } Fw::ParamString QueuedTestComponentBase :: paramGet_ParamString(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamString_valid; - _local = this->m_ParamString; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamString; + } + this->m_paramLock.unlock(); return _local; } E QueuedTestComponentBase :: paramGet_ParamEnum(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamEnum_valid; - _local = this->m_ParamEnum; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamEnum; + } + this->m_paramLock.unlock(); return _local; } A QueuedTestComponentBase :: paramGet_ParamArray(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamArray_valid; - _local = this->m_ParamArray; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamArray; + } + this->m_paramLock.unlock(); return _local; } S QueuedTestComponentBase :: paramGet_ParamStruct(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; this->m_paramLock.lock(); valid = this->m_param_ParamStruct_valid; - _local = this->m_ParamStruct; - this->m_paramLock.unLock(); + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + _local = this->m_ParamStruct; + } + this->m_paramLock.unlock(); return _local; } I32 QueuedTestComponentBase :: paramGet_ParamI32Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; I32 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamI32Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } F64 QueuedTestComponentBase :: paramGet_ParamF64Ext(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; F64 _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamF64Ext_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } Fw::ParamString QueuedTestComponentBase :: paramGet_ParamStringExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; Fw::ParamString _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStringExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } E QueuedTestComponentBase :: paramGet_ParamEnumExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; E _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamEnumExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } A QueuedTestComponentBase :: paramGet_ParamArrayExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; A _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamArrayExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } S QueuedTestComponentBase :: paramGet_ParamStructExt(Fw::ParamValid& valid) { + Fw::ParamBuffer _paramBuffer; S _local{}; - Fw::ParamBuffer _getBuff; - // Get the base ID - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - // Get the local ID to pass to the delegate - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - - FW_ASSERT(this->paramDelegatePtr != nullptr); - // Get the external parameter from the delegate - Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff); - if(_stat == Fw::FW_SERIALIZE_OK) { - _stat = _getBuff.deserializeTo(_local); - FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); - valid = Fw::ParamValid::VALID; - } else { - valid = Fw::ParamValid::INVALID; + this->m_paramLock.lock(); + valid = this->m_param_ParamStructExt_valid; + if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) { + FW_ASSERT(this->paramDelegatePtr != nullptr); + Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam( + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer + ); + if(_stat == Fw::FW_SERIALIZE_OK) { + _stat = _paramBuffer.deserializeTo(_local); + FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast(_stat)); + } else { + valid = Fw::ParamValid::INVALID; + } } + this->m_paramLock.unlock(); return _local; } @@ -8865,7 +8907,7 @@ Fw::CmdResponse QueuedTestComponentBase :: this->m_paramLock.lock(); this->m_ParamU32 = _localVal; this->m_param_ParamU32_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMU32); @@ -8885,7 +8927,7 @@ Fw::CmdResponse QueuedTestComponentBase :: this->m_paramLock.lock(); this->m_ParamF64 = _localVal; this->m_param_ParamF64_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMF64); @@ -8905,7 +8947,7 @@ Fw::CmdResponse QueuedTestComponentBase :: this->m_paramLock.lock(); this->m_ParamString = _localVal; this->m_param_ParamString_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRING); @@ -8925,7 +8967,7 @@ Fw::CmdResponse QueuedTestComponentBase :: this->m_paramLock.lock(); this->m_ParamEnum = _localVal; this->m_param_ParamEnum_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMENUM); @@ -8945,7 +8987,7 @@ Fw::CmdResponse QueuedTestComponentBase :: this->m_paramLock.lock(); this->m_ParamArray = _localVal; this->m_param_ParamArray_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMARRAY); @@ -8965,7 +9007,7 @@ Fw::CmdResponse QueuedTestComponentBase :: this->m_paramLock.lock(); this->m_ParamStruct = _localVal; this->m_param_ParamStruct_valid = Fw::ParamValid::VALID; - this->m_paramLock.unLock(); + this->m_paramLock.unlock(); // Call notifier this->parameterUpdated(PARAMID_PARAMSTRUCT); @@ -8975,139 +9017,193 @@ Fw::CmdResponse QueuedTestComponentBase :: Fw::CmdResponse QueuedTestComponentBase :: paramSet_ParamI32Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamI32Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMI32EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamI32Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMI32EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMI32EXT); + } + return _response; } Fw::CmdResponse QueuedTestComponentBase :: paramSet_ParamF64Ext(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamF64Ext const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMF64EXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; } + else { + this->m_param_ParamF64Ext_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; + } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMF64EXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMF64EXT); + } + return _response; } Fw::CmdResponse QueuedTestComponentBase :: paramSet_ParamStringExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStringExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRINGEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStringExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamStringExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRINGEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRINGEXT); + } + return _response; } Fw::CmdResponse QueuedTestComponentBase :: paramSet_ParamEnumExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamEnumExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMENUMEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamEnumExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMENUMEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMENUMEXT); + } + return _response; } Fw::CmdResponse QueuedTestComponentBase :: paramSet_ParamArrayExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamArrayExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMARRAYEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamArrayExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMARRAYEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMARRAYEXT); + } + return _response; } Fw::CmdResponse QueuedTestComponentBase :: paramSet_ParamStructExt(Fw::SerialBufferBase& val) { - const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); + Fw::CmdResponse _response{}; + this->m_paramLock.lock(); + // Update the external parameter FW_ASSERT(this->paramDelegatePtr != nullptr); - // Call the delegate serialize function for m_ParamStructExt const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam( - _baseId, - _localId, + static_cast(this->getIdBase()), + PARAMID_PARAMSTRUCTEXT, Fw::ParamValid::VALID, val ); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; + // Set response and update component state + if (_stat == Fw::FW_SERIALIZE_OK) { + this->m_param_ParamStructExt_valid = Fw::ParamValid::VALID; + _response = Fw::CmdResponse::OK; + } + else { + this->m_param_ParamStructExt_valid = Fw::ParamValid::INVALID; + _response = Fw::CmdResponse::VALIDATION_ERROR; } + this->m_paramLock.unlock(); // Call notifier - this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); - return Fw::CmdResponse::OK; + if (_response == Fw::CmdResponse::OK) { + this->parameterUpdated(PARAMID_PARAMSTRUCTEXT); + } + return _response; } // ---------------------------------------------------------------------- @@ -9117,379 +9213,367 @@ Fw::CmdResponse QueuedTestComponentBase :: Fw::CmdResponse QueuedTestComponentBase :: paramSave_ParamU32() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamU32); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMU32); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamU32_valid == Fw::ParamValid::VALID) || (this->m_param_ParamU32_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamU32); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMU32), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedTestComponentBase :: paramSave_ParamF64() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamF64); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamF64); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedTestComponentBase :: paramSave_ParamString() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamString); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRING); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamString_valid == Fw::ParamValid::VALID) || (this->m_param_ParamString_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamString); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRING), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedTestComponentBase :: paramSave_ParamEnum() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamEnum); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUM); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnum_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnum_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamEnum); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUM), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedTestComponentBase :: paramSave_ParamArray() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamArray); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAY); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArray_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArray_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamArray); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAY), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedTestComponentBase :: paramSave_ParamStruct() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - this->m_paramLock.lock(); - - _stat = _saveBuff.serializeFrom(m_ParamStruct); - - this->m_paramLock.unLock(); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff - ); - - return Fw::CmdResponse::OK; + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; } - - return Fw::CmdResponse::EXECUTION_ERROR; + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStruct_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStruct_valid == Fw::ParamValid::DEFAULT)) { + _stat = _paramBuffer.serializeFrom(m_ParamStruct); + } + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedTestComponentBase :: paramSave_ParamI32Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMI32EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamI32Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamI32Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMI32EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMI32EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMI32EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedTestComponentBase :: paramSave_ParamF64Ext() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMF64EXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamF64Ext_valid == Fw::ParamValid::VALID) || (this->m_param_ParamF64Ext_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMF64EXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMF64EXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMF64EXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedTestComponentBase :: paramSave_ParamStringExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRINGEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStringExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStringExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRINGEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRINGEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRINGEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedTestComponentBase :: paramSave_ParamEnumExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMENUMEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamEnumExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamEnumExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMENUMEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMENUMEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMENUMEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedTestComponentBase :: paramSave_ParamArrayExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMARRAYEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamArrayExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamArrayExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMARRAYEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMARRAYEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMARRAYEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } Fw::CmdResponse QueuedTestComponentBase :: paramSave_ParamStructExt() { - Fw::ParamBuffer _saveBuff; - FwPrmIdType _id; - Fw::SerializeStatus _stat; - if (this->isConnected_prmSetOut_OutputPort(0)) { - // Get the local and base ID to pass to the delegate - _id = PARAMID_PARAMSTRUCTEXT; - const FwPrmIdType _baseId = static_cast(this->getIdBase()); - + if (!this->isConnected_prmSetOut_OutputPort(0)) { + return Fw::CmdResponse::EXECUTION_ERROR; + } + Fw::ParamBuffer _paramBuffer; + const FwIdType idBase = this->getIdBase(); + Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR; + // Serialize the parameter + this->m_paramLock.lock(); + if ((this->m_param_ParamStructExt_valid == Fw::ParamValid::VALID) || (this->m_param_ParamStructExt_valid == Fw::ParamValid::DEFAULT)) { FW_ASSERT(this->paramDelegatePtr != nullptr); - _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff); - if (_stat != Fw::FW_SERIALIZE_OK) { - return Fw::CmdResponse::VALIDATION_ERROR; - } - - _id = static_cast(this->getIdBase() + PARAMID_PARAMSTRUCTEXT); - - // Save the parameter - this->prmSetOut_out( - 0, - _id, - _saveBuff + _stat = this->paramDelegatePtr->serializeParam( + static_cast(idBase), + PARAMID_PARAMSTRUCTEXT, + _paramBuffer ); - - return Fw::CmdResponse::OK; } - - return Fw::CmdResponse::EXECUTION_ERROR; + this->m_paramLock.unlock(); + if (_stat != Fw::FW_SERIALIZE_OK) { + return Fw::CmdResponse::VALIDATION_ERROR; + } + // Save the parameter + this->prmSetOut_out( + 0, + static_cast(idBase + PARAMID_PARAMSTRUCTEXT), + _paramBuffer + ); + // Return the command response + return Fw::CmdResponse::OK; } // ---------------------------------------------------------------------- @@ -9564,7 +9648,3 @@ void QueuedTestComponentBase :: break; } } - -// ---------------------------------------------------------------------- -// Parameter delegate -// ---------------------------------------------------------------------- diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedTestComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedTestComponentAc.ref.hpp index 27207703e..fca8b98fd 100644 --- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedTestComponentAc.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedTestComponentAc.ref.hpp @@ -3453,23 +3453,41 @@ class QueuedTestComponentBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; + + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; private: @@ -3515,7 +3533,7 @@ class QueuedTestComponentBase : // ---------------------------------------------------------------------- //! Delegate to serialize/deserialize an externally stored parameter - Fw::ParamExternalDelegate* paramDelegatePtr; + Fw::ParamExternalDelegate* paramDelegatePtr = nullptr; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveExternalParamsTesterBase.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveExternalParamsTesterBase.ref.cpp index 7627f863a..66854e20e 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveExternalParamsTesterBase.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveExternalParamsTesterBase.ref.cpp @@ -23,6 +23,7 @@ Fw::SerializeStatus ActiveExternalParamsTesterBase::ActiveExternalParamsComponen { Fw::SerializeStatus stat; (void) baseId; + (void) prmStat; // Serialize the parameter based on ID switch(localId) diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveExternalParamsTesterBase.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveExternalParamsTesterBase.ref.hpp index e31b94b07..6d9cf15f3 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveExternalParamsTesterBase.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveExternalParamsTesterBase.ref.hpp @@ -231,23 +231,23 @@ class ActiveExternalParamsTesterBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamI32Ext was successfully received - Fw::ParamValid m_param_ParamI32Ext_valid; + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64Ext was successfully received - Fw::ParamValid m_param_ParamF64Ext_valid; + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamStringExt was successfully received - Fw::ParamValid m_param_ParamStringExt_valid; + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnumExt was successfully received - Fw::ParamValid m_param_ParamEnumExt_valid; + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamArrayExt was successfully received - Fw::ParamValid m_param_ParamArrayExt_valid; + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamStructExt was successfully received - Fw::ParamValid m_param_ParamStructExt_valid; + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; public: diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveParamsTesterBase.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveParamsTesterBase.ref.cpp index 42959e509..6f07906e5 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveParamsTesterBase.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveParamsTesterBase.ref.cpp @@ -1189,13 +1189,7 @@ ActiveParamsTesterBase :: const char* const compName, const U32 maxHistorySize ) : - Fw::PassiveComponentBase(compName), - m_param_ParamU32_valid(Fw::ParamValid::UNINIT), - m_param_ParamF64_valid(Fw::ParamValid::UNINIT), - m_param_ParamString_valid(Fw::ParamValid::UNINIT), - m_param_ParamEnum_valid(Fw::ParamValid::UNINIT), - m_param_ParamArray_valid(Fw::ParamValid::UNINIT), - m_param_ParamStruct_valid(Fw::ParamValid::UNINIT) + Fw::PassiveComponentBase(compName) { // Initialize port histories this->fromPortHistory_typedAliasOut = new History(maxHistorySize); diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveParamsTesterBase.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveParamsTesterBase.ref.hpp index e38ad6d43..8a6da1974 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveParamsTesterBase.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveParamsTesterBase.ref.hpp @@ -1780,23 +1780,23 @@ class ActiveParamsTesterBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveSerialTesterBase.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveSerialTesterBase.ref.cpp index 45d49dec5..45dde407a 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveSerialTesterBase.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveSerialTesterBase.ref.cpp @@ -23,6 +23,7 @@ Fw::SerializeStatus ActiveSerialTesterBase::ActiveSerialComponentBaseParamExtern { Fw::SerializeStatus stat; (void) baseId; + (void) prmStat; // Serialize the parameter based on ID switch(localId) @@ -1591,13 +1592,7 @@ ActiveSerialTesterBase :: const char* const compName, const U32 maxHistorySize ) : - Fw::PassiveComponentBase(compName), - m_param_ParamU32_valid(Fw::ParamValid::UNINIT), - m_param_ParamF64_valid(Fw::ParamValid::UNINIT), - m_param_ParamString_valid(Fw::ParamValid::UNINIT), - m_param_ParamEnum_valid(Fw::ParamValid::UNINIT), - m_param_ParamArray_valid(Fw::ParamValid::UNINIT), - m_param_ParamStruct_valid(Fw::ParamValid::UNINIT) + Fw::PassiveComponentBase(compName) { // Initialize port histories this->fromPortHistory_typedAliasOut = new History(maxHistorySize); diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveSerialTesterBase.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveSerialTesterBase.ref.hpp index fd7f3b415..3f45cf1c1 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveSerialTesterBase.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveSerialTesterBase.ref.hpp @@ -343,23 +343,23 @@ class ActiveSerialTesterBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamI32Ext was successfully received - Fw::ParamValid m_param_ParamI32Ext_valid; + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64Ext was successfully received - Fw::ParamValid m_param_ParamF64Ext_valid; + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamStringExt was successfully received - Fw::ParamValid m_param_ParamStringExt_valid; + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnumExt was successfully received - Fw::ParamValid m_param_ParamEnumExt_valid; + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamArrayExt was successfully received - Fw::ParamValid m_param_ParamArrayExt_valid; + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamStructExt was successfully received - Fw::ParamValid m_param_ParamStructExt_valid; + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; public: @@ -2700,23 +2700,23 @@ class ActiveSerialTesterBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveTestTesterBase.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveTestTesterBase.ref.cpp index 08af8d0d5..82aa81fab 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveTestTesterBase.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveTestTesterBase.ref.cpp @@ -25,6 +25,7 @@ namespace M { { Fw::SerializeStatus stat; (void) baseId; + (void) prmStat; // Serialize the parameter based on ID switch(localId) @@ -1463,13 +1464,7 @@ namespace M { const char* const compName, const U32 maxHistorySize ) : - Fw::PassiveComponentBase(compName), - m_param_ParamU32_valid(Fw::ParamValid::UNINIT), - m_param_ParamF64_valid(Fw::ParamValid::UNINIT), - m_param_ParamString_valid(Fw::ParamValid::UNINIT), - m_param_ParamEnum_valid(Fw::ParamValid::UNINIT), - m_param_ParamArray_valid(Fw::ParamValid::UNINIT), - m_param_ParamStruct_valid(Fw::ParamValid::UNINIT) + Fw::PassiveComponentBase(compName) { // Initialize port histories this->fromPortHistory_typedAliasOut = new History(maxHistorySize); diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveTestTesterBase.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveTestTesterBase.ref.hpp index 59f6dde1b..624cb76d4 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveTestTesterBase.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/ActiveTestTesterBase.ref.hpp @@ -358,23 +358,23 @@ namespace M { // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamI32Ext was successfully received - Fw::ParamValid m_param_ParamI32Ext_valid; + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64Ext was successfully received - Fw::ParamValid m_param_ParamF64Ext_valid; + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamStringExt was successfully received - Fw::ParamValid m_param_ParamStringExt_valid; + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnumExt was successfully received - Fw::ParamValid m_param_ParamEnumExt_valid; + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamArrayExt was successfully received - Fw::ParamValid m_param_ParamArrayExt_valid; + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamStructExt was successfully received - Fw::ParamValid m_param_ParamStructExt_valid; + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; public: @@ -2620,23 +2620,23 @@ namespace M { // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveExternalParamsTesterBase.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveExternalParamsTesterBase.ref.cpp index 40d0bc8a1..830074212 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveExternalParamsTesterBase.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveExternalParamsTesterBase.ref.cpp @@ -23,6 +23,7 @@ Fw::SerializeStatus PassiveExternalParamsTesterBase::PassiveExternalParamsCompon { Fw::SerializeStatus stat; (void) baseId; + (void) prmStat; // Serialize the parameter based on ID switch(localId) diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveExternalParamsTesterBase.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveExternalParamsTesterBase.ref.hpp index 87435ee57..d0de33b25 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveExternalParamsTesterBase.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveExternalParamsTesterBase.ref.hpp @@ -231,23 +231,23 @@ class PassiveExternalParamsTesterBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamI32Ext was successfully received - Fw::ParamValid m_param_ParamI32Ext_valid; + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64Ext was successfully received - Fw::ParamValid m_param_ParamF64Ext_valid; + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamStringExt was successfully received - Fw::ParamValid m_param_ParamStringExt_valid; + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnumExt was successfully received - Fw::ParamValid m_param_ParamEnumExt_valid; + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamArrayExt was successfully received - Fw::ParamValid m_param_ParamArrayExt_valid; + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamStructExt was successfully received - Fw::ParamValid m_param_ParamStructExt_valid; + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; public: diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveParamsTesterBase.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveParamsTesterBase.ref.cpp index 1bd8d968f..d7eb96775 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveParamsTesterBase.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveParamsTesterBase.ref.cpp @@ -991,13 +991,7 @@ PassiveParamsTesterBase :: const char* const compName, const U32 maxHistorySize ) : - Fw::PassiveComponentBase(compName), - m_param_ParamU32_valid(Fw::ParamValid::UNINIT), - m_param_ParamF64_valid(Fw::ParamValid::UNINIT), - m_param_ParamString_valid(Fw::ParamValid::UNINIT), - m_param_ParamEnum_valid(Fw::ParamValid::UNINIT), - m_param_ParamArray_valid(Fw::ParamValid::UNINIT), - m_param_ParamStruct_valid(Fw::ParamValid::UNINIT) + Fw::PassiveComponentBase(compName) { // Initialize port histories this->fromPortHistory_typedAliasOut = new History(maxHistorySize); diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveParamsTesterBase.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveParamsTesterBase.ref.hpp index 5c55f6b93..86c93df10 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveParamsTesterBase.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveParamsTesterBase.ref.hpp @@ -1561,23 +1561,23 @@ class PassiveParamsTesterBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveSerialTesterBase.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveSerialTesterBase.ref.cpp index 280099b83..db2131c4c 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveSerialTesterBase.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveSerialTesterBase.ref.cpp @@ -23,6 +23,7 @@ Fw::SerializeStatus PassiveSerialTesterBase::PassiveSerialComponentBaseParamExte { Fw::SerializeStatus stat; (void) baseId; + (void) prmStat; // Serialize the parameter based on ID switch(localId) @@ -1261,13 +1262,7 @@ PassiveSerialTesterBase :: const char* const compName, const U32 maxHistorySize ) : - Fw::PassiveComponentBase(compName), - m_param_ParamU32_valid(Fw::ParamValid::UNINIT), - m_param_ParamF64_valid(Fw::ParamValid::UNINIT), - m_param_ParamString_valid(Fw::ParamValid::UNINIT), - m_param_ParamEnum_valid(Fw::ParamValid::UNINIT), - m_param_ParamArray_valid(Fw::ParamValid::UNINIT), - m_param_ParamStruct_valid(Fw::ParamValid::UNINIT) + Fw::PassiveComponentBase(compName) { // Initialize port histories this->fromPortHistory_typedAliasOut = new History(maxHistorySize); diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveSerialTesterBase.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveSerialTesterBase.ref.hpp index 1205c95ea..335aed220 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveSerialTesterBase.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveSerialTesterBase.ref.hpp @@ -343,23 +343,23 @@ class PassiveSerialTesterBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamI32Ext was successfully received - Fw::ParamValid m_param_ParamI32Ext_valid; + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64Ext was successfully received - Fw::ParamValid m_param_ParamF64Ext_valid; + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamStringExt was successfully received - Fw::ParamValid m_param_ParamStringExt_valid; + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnumExt was successfully received - Fw::ParamValid m_param_ParamEnumExt_valid; + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamArrayExt was successfully received - Fw::ParamValid m_param_ParamArrayExt_valid; + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamStructExt was successfully received - Fw::ParamValid m_param_ParamStructExt_valid; + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; public: @@ -2333,23 +2333,23 @@ class PassiveSerialTesterBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveTestTesterBase.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveTestTesterBase.ref.cpp index 5494236f5..1e75dee5e 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveTestTesterBase.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveTestTesterBase.ref.cpp @@ -23,6 +23,7 @@ Fw::SerializeStatus PassiveTestTesterBase::PassiveTestComponentBaseParamExternal { Fw::SerializeStatus stat; (void) baseId; + (void) prmStat; // Serialize the parameter based on ID switch(localId) @@ -1263,13 +1264,7 @@ PassiveTestTesterBase :: const char* const compName, const U32 maxHistorySize ) : - Fw::PassiveComponentBase(compName), - m_param_ParamU32_valid(Fw::ParamValid::UNINIT), - m_param_ParamF64_valid(Fw::ParamValid::UNINIT), - m_param_ParamString_valid(Fw::ParamValid::UNINIT), - m_param_ParamEnum_valid(Fw::ParamValid::UNINIT), - m_param_ParamArray_valid(Fw::ParamValid::UNINIT), - m_param_ParamStruct_valid(Fw::ParamValid::UNINIT) + Fw::PassiveComponentBase(compName) { // Initialize port histories this->fromPortHistory_typedAliasOut = new History(maxHistorySize); diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveTestTesterBase.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveTestTesterBase.ref.hpp index 342f185d6..948d3eddb 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveTestTesterBase.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/PassiveTestTesterBase.ref.hpp @@ -356,23 +356,23 @@ class PassiveTestTesterBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamI32Ext was successfully received - Fw::ParamValid m_param_ParamI32Ext_valid; + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64Ext was successfully received - Fw::ParamValid m_param_ParamF64Ext_valid; + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamStringExt was successfully received - Fw::ParamValid m_param_ParamStringExt_valid; + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnumExt was successfully received - Fw::ParamValid m_param_ParamEnumExt_valid; + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamArrayExt was successfully received - Fw::ParamValid m_param_ParamArrayExt_valid; + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamStructExt was successfully received - Fw::ParamValid m_param_ParamStructExt_valid; + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; public: @@ -2367,23 +2367,23 @@ class PassiveTestTesterBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedExternalParamsTesterBase.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedExternalParamsTesterBase.ref.cpp index c443c7ad0..576d43517 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedExternalParamsTesterBase.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedExternalParamsTesterBase.ref.cpp @@ -23,6 +23,7 @@ Fw::SerializeStatus QueuedExternalParamsTesterBase::QueuedExternalParamsComponen { Fw::SerializeStatus stat; (void) baseId; + (void) prmStat; // Serialize the parameter based on ID switch(localId) diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedExternalParamsTesterBase.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedExternalParamsTesterBase.ref.hpp index be830e6e6..70956805d 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedExternalParamsTesterBase.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedExternalParamsTesterBase.ref.hpp @@ -231,23 +231,23 @@ class QueuedExternalParamsTesterBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamI32Ext was successfully received - Fw::ParamValid m_param_ParamI32Ext_valid; + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64Ext was successfully received - Fw::ParamValid m_param_ParamF64Ext_valid; + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamStringExt was successfully received - Fw::ParamValid m_param_ParamStringExt_valid; + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnumExt was successfully received - Fw::ParamValid m_param_ParamEnumExt_valid; + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamArrayExt was successfully received - Fw::ParamValid m_param_ParamArrayExt_valid; + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamStructExt was successfully received - Fw::ParamValid m_param_ParamStructExt_valid; + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; public: diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedParamsTesterBase.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedParamsTesterBase.ref.cpp index 442d3c441..cb87c5f92 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedParamsTesterBase.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedParamsTesterBase.ref.cpp @@ -1189,13 +1189,7 @@ QueuedParamsTesterBase :: const char* const compName, const U32 maxHistorySize ) : - Fw::PassiveComponentBase(compName), - m_param_ParamU32_valid(Fw::ParamValid::UNINIT), - m_param_ParamF64_valid(Fw::ParamValid::UNINIT), - m_param_ParamString_valid(Fw::ParamValid::UNINIT), - m_param_ParamEnum_valid(Fw::ParamValid::UNINIT), - m_param_ParamArray_valid(Fw::ParamValid::UNINIT), - m_param_ParamStruct_valid(Fw::ParamValid::UNINIT) + Fw::PassiveComponentBase(compName) { // Initialize port histories this->fromPortHistory_typedAliasOut = new History(maxHistorySize); diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedParamsTesterBase.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedParamsTesterBase.ref.hpp index 42617537e..d17701651 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedParamsTesterBase.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedParamsTesterBase.ref.hpp @@ -1764,23 +1764,23 @@ class QueuedParamsTesterBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedSerialTesterBase.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedSerialTesterBase.ref.cpp index 8627180c2..e0783d008 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedSerialTesterBase.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedSerialTesterBase.ref.cpp @@ -23,6 +23,7 @@ Fw::SerializeStatus QueuedSerialTesterBase::QueuedSerialComponentBaseParamExtern { Fw::SerializeStatus stat; (void) baseId; + (void) prmStat; // Serialize the parameter based on ID switch(localId) @@ -1591,13 +1592,7 @@ QueuedSerialTesterBase :: const char* const compName, const U32 maxHistorySize ) : - Fw::PassiveComponentBase(compName), - m_param_ParamU32_valid(Fw::ParamValid::UNINIT), - m_param_ParamF64_valid(Fw::ParamValid::UNINIT), - m_param_ParamString_valid(Fw::ParamValid::UNINIT), - m_param_ParamEnum_valid(Fw::ParamValid::UNINIT), - m_param_ParamArray_valid(Fw::ParamValid::UNINIT), - m_param_ParamStruct_valid(Fw::ParamValid::UNINIT) + Fw::PassiveComponentBase(compName) { // Initialize port histories this->fromPortHistory_typedAliasOut = new History(maxHistorySize); diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedSerialTesterBase.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedSerialTesterBase.ref.hpp index 959d3fb23..76dbfad40 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedSerialTesterBase.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedSerialTesterBase.ref.hpp @@ -343,23 +343,23 @@ class QueuedSerialTesterBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamI32Ext was successfully received - Fw::ParamValid m_param_ParamI32Ext_valid; + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64Ext was successfully received - Fw::ParamValid m_param_ParamF64Ext_valid; + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamStringExt was successfully received - Fw::ParamValid m_param_ParamStringExt_valid; + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnumExt was successfully received - Fw::ParamValid m_param_ParamEnumExt_valid; + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamArrayExt was successfully received - Fw::ParamValid m_param_ParamArrayExt_valid; + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamStructExt was successfully received - Fw::ParamValid m_param_ParamStructExt_valid; + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; public: @@ -2684,23 +2684,23 @@ class QueuedSerialTesterBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; private: diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedTestTesterBase.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedTestTesterBase.ref.cpp index dc8a03af8..d95d2e233 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedTestTesterBase.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedTestTesterBase.ref.cpp @@ -23,6 +23,7 @@ Fw::SerializeStatus QueuedTestTesterBase::QueuedTestComponentBaseParamExternalDe { Fw::SerializeStatus stat; (void) baseId; + (void) prmStat; // Serialize the parameter based on ID switch(localId) @@ -1461,13 +1462,7 @@ QueuedTestTesterBase :: const char* const compName, const U32 maxHistorySize ) : - Fw::PassiveComponentBase(compName), - m_param_ParamU32_valid(Fw::ParamValid::UNINIT), - m_param_ParamF64_valid(Fw::ParamValid::UNINIT), - m_param_ParamString_valid(Fw::ParamValid::UNINIT), - m_param_ParamEnum_valid(Fw::ParamValid::UNINIT), - m_param_ParamArray_valid(Fw::ParamValid::UNINIT), - m_param_ParamStruct_valid(Fw::ParamValid::UNINIT) + Fw::PassiveComponentBase(compName) { // Initialize port histories this->fromPortHistory_typedAliasOut = new History(maxHistorySize); diff --git a/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedTestTesterBase.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedTestTesterBase.ref.hpp index 451e7ff30..ede3a793d 100644 --- a/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedTestTesterBase.ref.hpp +++ b/compiler/tools/fpp-to-cpp/test/component/test-base/QueuedTestTesterBase.ref.hpp @@ -356,23 +356,23 @@ class QueuedTestTesterBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamI32Ext was successfully received - Fw::ParamValid m_param_ParamI32Ext_valid; + //! The validity flag for ParamI32Ext + Fw::ParamValid m_param_ParamI32Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64Ext was successfully received - Fw::ParamValid m_param_ParamF64Ext_valid; + //! The validity flag for ParamF64Ext + Fw::ParamValid m_param_ParamF64Ext_valid = Fw::ParamValid::UNINIT; - //! True if ParamStringExt was successfully received - Fw::ParamValid m_param_ParamStringExt_valid; + //! The validity flag for ParamStringExt + Fw::ParamValid m_param_ParamStringExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnumExt was successfully received - Fw::ParamValid m_param_ParamEnumExt_valid; + //! The validity flag for ParamEnumExt + Fw::ParamValid m_param_ParamEnumExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamArrayExt was successfully received - Fw::ParamValid m_param_ParamArrayExt_valid; + //! The validity flag for ParamArrayExt + Fw::ParamValid m_param_ParamArrayExt_valid = Fw::ParamValid::UNINIT; - //! True if ParamStructExt was successfully received - Fw::ParamValid m_param_ParamStructExt_valid; + //! The validity flag for ParamStructExt + Fw::ParamValid m_param_ParamStructExt_valid = Fw::ParamValid::UNINIT; public: @@ -2602,23 +2602,23 @@ class QueuedTestTesterBase : // Parameter validity flags // ---------------------------------------------------------------------- - //! True if ParamU32 was successfully received - Fw::ParamValid m_param_ParamU32_valid; + //! The validity flag for ParamU32 + Fw::ParamValid m_param_ParamU32_valid = Fw::ParamValid::UNINIT; - //! True if ParamF64 was successfully received - Fw::ParamValid m_param_ParamF64_valid; + //! The validity flag for ParamF64 + Fw::ParamValid m_param_ParamF64_valid = Fw::ParamValid::UNINIT; - //! True if ParamString was successfully received - Fw::ParamValid m_param_ParamString_valid; + //! The validity flag for ParamString + Fw::ParamValid m_param_ParamString_valid = Fw::ParamValid::UNINIT; - //! True if ParamEnum was successfully received - Fw::ParamValid m_param_ParamEnum_valid; + //! The validity flag for ParamEnum + Fw::ParamValid m_param_ParamEnum_valid = Fw::ParamValid::UNINIT; - //! True if ParamArray was successfully received - Fw::ParamValid m_param_ParamArray_valid; + //! The validity flag for ParamArray + Fw::ParamValid m_param_ParamArray_valid = Fw::ParamValid::UNINIT; - //! True if ParamStruct was successfully received - Fw::ParamValid m_param_ParamStruct_valid; + //! The validity flag for ParamStruct + Fw::ParamValid m_param_ParamStruct_valid = Fw::ParamValid::UNINIT; private: