command message only passed IF now

ipc/CommandMessage.cpp

@@ -1,13 +1,5 @@
 #include <framework/ipc/CommandMessage.h>
-
+#include <cstring>
-#include <framework/devicehandlers/DeviceHandlerMessage.h>
-#include <framework/health/HealthMessage.h>
-#include <framework/memory/MemoryMessage.h>
-#include <framework/modes/ModeMessage.h>
-#include <framework/monitoring/MonitoringMessage.h>
-#include <framework/subsystem/modes/ModeSequenceMessage.h>
-#include <framework/tmstorage/TmStoreMessage.h>
-#include <framework/parameters/ParameterMessage.h>
 
 CommandMessage::CommandMessage(MessageQueueMessageIF* receiverMessage):
 			CommandMessageBase(receiverMessage) {
@@ -50,23 +42,23 @@ CommandMessage::CommandMessage(MessageQueueMessageIF* messageToSet,
 
 uint32_t CommandMessage::getParameter() const {
 	uint32_t parameter1;
-	memcpy(&parameter1, CommandMessageBase::getData(), sizeof(parameter1));
+	std::memcpy(&parameter1, CommandMessageBase::getData(), sizeof(parameter1));
 	return parameter1;
 }
 
 void CommandMessage::setParameter(uint32_t parameter1) {
-	memcpy(CommandMessageBase::getData(), &parameter1, sizeof(parameter1));
+	std::memcpy(CommandMessageBase::getData(), &parameter1, sizeof(parameter1));
 }
 
 uint32_t CommandMessage::getParameter2() const {
 	uint32_t parameter2;
-	memcpy(&parameter2, CommandMessageBase::getData() + sizeof(uint32_t),
+	std::memcpy(&parameter2, CommandMessageBase::getData() + sizeof(uint32_t),
 			sizeof(parameter2));
 	return parameter2;
 }
 
 void CommandMessage::setParameter2(uint32_t parameter2) {
-	memcpy(CommandMessageBase::getData()  + sizeof(uint32_t), &parameter2,
+	std::memcpy(CommandMessageBase::getData()  + sizeof(uint32_t), &parameter2,
 			sizeof(parameter2));
 }
 
@@ -84,60 +76,6 @@ bool CommandMessage::isClearedCommandMessage() {
 
 void CommandMessage::setToUnknownCommand() {
 	Command_t initialCommand = getCommand();
-	clearCommandMessage();
+	this->clear();
 	setReplyRejected(UNKNOWN_COMMAND, initialCommand);
 }
-
-void CommandMessage::setReplyRejected(ReturnValue_t reason,
-		Command_t initialCommand) {
-	setCommand(REPLY_REJECTED);
-	setParameter(reason);
-	setParameter2(initialCommand);
-}
-
-ReturnValue_t CommandMessage::getRejectedReplyReason(
-		Command_t* initialCommand) const {
-	if(initialCommand != nullptr) {
-		*initialCommand  = getParameter2();
-	}
-	return getParameter();
-}
-
-void CommandMessage::clear() {
-	clearCommandMessage();
-}
-
-void CommandMessage::clearCommandMessage() {
-	switch(this->getMessageType()){
-	case  messagetypes::MODE_COMMAND:
-		ModeMessage::clear(this);
-		break;
-	case messagetypes::HEALTH_COMMAND:
-		HealthMessage::clear(this);
-		break;
-	case messagetypes::MODE_SEQUENCE:
-		ModeSequenceMessage::clear(this);
-		break;
-	case messagetypes::ACTION:
-		ActionMessage::clear(this);
-		break;
-	case messagetypes::DEVICE_HANDLER_COMMAND:
-		DeviceHandlerMessage::clear(this);
-		break;
-	case messagetypes::MEMORY:
-		MemoryMessage::clear(this);
-		break;
-	case messagetypes::MONITORING:
-		MonitoringMessage::clear(this);
-		break;
-	case messagetypes::TM_STORE:
-		TmStoreMessage::clear(this);
-		break;
-	case messagetypes::PARAMETER:
-		ParameterMessage::clear(this);
-		break;
-	default:
-		messagetypes::clearMissionMessage(this);
-		break;
-	}
-}

ipc/CommandMessage.h

@@ -5,11 +5,6 @@
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/ipc/FwMessageTypes.h>
 
-namespace messagetypes {
-// Implemented in config.
-void clearMissionMessage(CommandMessageIF* message);
-}
-
 /**
  * @brief 	Default command message used to pass command messages between tasks.
  * 			Primary message type for IPC. Contains sender, 2-byte command ID
@@ -27,17 +22,6 @@ void clearMissionMessage(CommandMessageIF* message);
  */
 class CommandMessage: public CommandMessageBase {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
-	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
-
-	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
-	//! Used internally, will be ignored
-	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
-	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 3 );
-	//! Reply indicating that the current command was rejected,
-	//! par1 should contain the error code
-	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 0xD1 );
-
 	/**
 	 * This is the size of a message as it is seen by the MessageQueue.
 	 * 14 of the 24 available MessageQueueMessage bytes are used.
@@ -98,18 +82,6 @@ public:
 	 */
 	void setParameter2(uint32_t parameter2);
 
-	void clear() override;
-
-	/**
-	 * Set the command to CMD_NONE and try to find the correct class to handle
-	 * a more detailed clear.
-	 * Also, calls a mission-specific clearMissionMessage function to separate
-	 * between framework and mission messages. Not optimal, may be replaced by
-	 * totally different auto-delete solution (e.g. smart pointers).
-	 *
-	 */
-	void clearCommandMessage();
-
 	/**
 	 * check if a message was cleared
 	 *
@@ -122,11 +94,6 @@ public:
 	 * Is needed quite often, so we better code it once only.
 	 */
 	void setToUnknownCommand();
-
-	void setReplyRejected(ReturnValue_t reason,
-			Command_t initialCommand = CMD_NONE);
-	ReturnValue_t getRejectedReplyReason(
-			Command_t* initialCommand = nullptr) const;
 };
 
 

ipc/CommandMessageBase.cpp

@@ -1,4 +1,5 @@
 #include <framework/ipc/CommandMessageBase.h>
+#include <framework/ipc/CommandMessageCleaner.h>
 #include <cstring>
 
 CommandMessageBase::CommandMessageBase(MessageQueueMessageIF *message):
@@ -57,3 +58,25 @@ size_t CommandMessageBase::getMessageSize() const {
 MessageQueueMessageIF* CommandMessageBase::getInternalMessage() const {
 	return internalMessage;
 }
+
+void CommandMessageBase::setReplyRejected(ReturnValue_t reason,
+		Command_t initialCommand) {
+	std::memcpy(getData(), &reason, sizeof(reason));
+	std::memcpy(getData() + sizeof(reason), &initialCommand,
+			sizeof(initialCommand));
+}
+
+ReturnValue_t CommandMessageBase::getReplyRejectedReason(
+		Command_t *initialCommand) const {
+	ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED;
+	std::memcpy(&reason, getData(), sizeof(reason));
+	if(initialCommand != nullptr) {
+		std::memcpy(initialCommand, getData() + sizeof(reason),
+				sizeof(Command_t));
+	}
+	return reason;
+}
+
+void CommandMessageBase::clear() {
+	CommandMessageCleaner::clearCommandMessage(this);
+}

ipc/CommandMessageBase.h

@@ -22,9 +22,6 @@
  */
 class CommandMessageBase: public CommandMessageIF {
 public:
-	static constexpr size_t HEADER_SIZE = sizeof(MessageQueueId_t) +
-			sizeof(Command_t);
-
 	CommandMessageBase(MessageQueueMessageIF* message);
 
 	/**
@@ -61,7 +58,25 @@ public:
 	virtual void setMessageSize(size_t messageSize) override;
 	virtual size_t getMessageSize() const override;
 
+	/**
+	 * A command message can be rejected and needs to offer a function
+	 * to set a rejected reply
+	 * @param reason
+	 * @param initialCommand
+	 */
+	void setReplyRejected(ReturnValue_t reason,
+			Command_t initialCommand) override;
+	/**
+	 * Corrensonding getter function.
+	 * @param initialCommand
+	 * @return
+	 */
+	ReturnValue_t getReplyRejectedReason(
+			Command_t* initialCommand = nullptr) const override;
+
 	virtual MessageQueueMessageIF* getInternalMessage() const override;
+
+	virtual void clear() override;
 protected:
 	/**
 	 * @brief 	Pointer to the message containing the data.

ipc/CommandMessageCleaner.cpp

@@ -0,0 +1,45 @@
+#include <framework/ipc/CommandMessageCleaner.h>
+
+#include <framework/devicehandlers/DeviceHandlerMessage.h>
+#include <framework/health/HealthMessage.h>
+#include <framework/memory/MemoryMessage.h>
+#include <framework/modes/ModeMessage.h>
+#include <framework/monitoring/MonitoringMessage.h>
+#include <framework/subsystem/modes/ModeSequenceMessage.h>
+#include <framework/tmstorage/TmStoreMessage.h>
+#include <framework/parameters/ParameterMessage.h>
+
+void CommandMessageCleaner::clearCommandMessage(CommandMessageIF* message) {
+	switch(message->getMessageType()){
+	case  messagetypes::MODE_COMMAND:
+		ModeMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::HEALTH_COMMAND:
+		HealthMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::MODE_SEQUENCE:
+		ModeSequenceMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::ACTION:
+		ActionMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::DEVICE_HANDLER_COMMAND:
+		DeviceHandlerMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::MEMORY:
+		MemoryMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::MONITORING:
+		MonitoringMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::TM_STORE:
+		TmStoreMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::PARAMETER:
+		ParameterMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	default:
+		messagetypes::clearMissionMessage(message);
+		break;
+	}
+}

ipc/CommandMessageCleaner.h

@@ -0,0 +1,16 @@
+#ifndef FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
+#define FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
+#include <framework/ipc/CommandMessageIF.h>
+
+namespace messagetypes {
+// Implemented in config.
+void clearMissionMessage(CommandMessageIF* message);
+}
+
+class CommandMessageCleaner {
+public:
+	static void clearCommandMessage(CommandMessageIF* message);
+};
+
+
+#endif /* FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ */

ipc/CommandMessageIF.h

@@ -2,6 +2,9 @@
 #define FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
 
 #include <framework/ipc/MessageQueueMessageIF.h>
+#include <framework/ipc/FwMessageTypes.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+
 
 #define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
 typedef uint16_t Command_t;
@@ -14,6 +17,20 @@ typedef uint16_t Command_t;
 // we should just leave it like that.
 class CommandMessageIF: public MessageQueueMessageIF {
 public:
+	static constexpr size_t HEADER_SIZE = sizeof(MessageQueueId_t) +
+			sizeof(Command_t);
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
+	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
+
+	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
+	//! Used internally, shall be ignored
+	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
+	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 1 );
+	//! Reply indicating that the current command was rejected,
+	//! par1 should contain the error code
+	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 2 );
+
 	virtual ~CommandMessageIF() {};
 
 	/**
@@ -27,6 +44,22 @@ public:
 	 */
 	virtual uint8_t getMessageType() const = 0;
 
+	/**
+	 * A command message can be rejected and needs to offer a function
+	 * to set a rejected reply
+	 * @param reason
+	 * @param initialCommand
+	 */
+	virtual void setReplyRejected(ReturnValue_t reason,
+			Command_t initialCommand) = 0;
+	/**
+	 * Corrensonding getter function.
+	 * @param initialCommand
+	 * @return
+	 */
+	virtual ReturnValue_t getReplyRejectedReason(
+			Command_t* initialCommand = nullptr) const  = 0;
+
 	/**
 	 * This function is used to get a pointer to the internal message, as
 	 * the command message implementations always operate on the memory
@@ -36,6 +69,7 @@ public:
 	 * @return
 	 */
 	virtual MessageQueueMessageIF* getInternalMessage() const = 0;
+
 };
 
 #endif /* FRAMEWORK_IPC_COMMANDMESSAGEIF_H_ */

memory/MemoryHelper.cpp

@@ -119,7 +119,7 @@ void MemoryHelper::completeDump(ReturnValue_t errorCode,
 		break;
 	}
 	if (queueToUse->sendMessage(lastSender, &reply) != RETURN_OK) {
-		reply.clearCommandMessage();
+		reply.clear();
 	}
 }
 

tmtcservices/CommandingServiceBase.cpp

@@ -94,7 +94,7 @@ void CommandingServiceBase::handleCommandQueue() {
 }
 
 
-void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
+void CommandingServiceBase::handleCommandMessage(CommandMessageIF* reply) {
 	bool isStep = false;
 	MessageQueueMessage message;
 	CommandMessage nextCommand(&message);
@@ -119,7 +119,7 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	 * command as failure parameter 1 */
 	if(reply->getCommand() == CommandMessage::REPLY_REJECTED and
 			result == RETURN_FAILED) {
-		result = reply->getRejectedReplyReason(
+		result = reply->getReplyRejectedReason(
 				reinterpret_cast<Command_t*>(&failureParameter1));
 	}
 
@@ -156,8 +156,8 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 }
 
 void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
-		CommandMapIter iter, CommandMessage* nextCommand, CommandMessage* reply,
+		CommandMapIter iter, CommandMessageIF* nextCommand,
-		bool& isStep) {
+		CommandMessageIF* reply, bool& isStep) {
 	iter->command = nextCommand->getCommand();
 
 	// In case a new command is to be sent immediately, this is performed here.
@@ -186,14 +186,14 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 	}
 	else {
 		if (isStep) {
-			nextCommand->clearCommandMessage();
+			nextCommand->clear();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
 					iter->tcInfo.tcPacketId,
 					iter->tcInfo.tcSequenceControl, sendResult,
 					++iter->step, failureParameter1, failureParameter2);
 		} else {
-			nextCommand->clearCommandMessage();
+			nextCommand->clear();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE,
 					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
@@ -329,7 +329,7 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 					storedPacket->getPacketSequenceControl();
 			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
 		} else {
-			command.clearCommandMessage();
+			command.clear();
 			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}
@@ -346,7 +346,7 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
 			checkAndExecuteFifo(iter);
 		} else {
-			command.clearCommandMessage();
+			command.clear();
 			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}

tmtcservices/CommandingServiceBase.h

@@ -141,7 +141,7 @@ protected:
 	 * @param objectId Target object ID
 	 * @return
 	 */
-	virtual ReturnValue_t prepareCommand(CommandMessage *message,
+	virtual ReturnValue_t prepareCommand(CommandMessageIF *message,
 			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
 			uint32_t *state, object_id_t objectId) = 0;
 
@@ -172,7 +172,7 @@ protected:
 	 */
 	virtual ReturnValue_t handleReply(const CommandMessageIF *reply,
 			Command_t previousCommand, uint32_t *state,
-			CommandMessage *optionalNextCommand, object_id_t objectId,
+			CommandMessageIF *optionalNextCommand, object_id_t objectId,
 			bool *isStep) = 0;
 
 	/**
@@ -312,9 +312,9 @@ private:
 
 	void startExecution(TcPacketStored *storedPacket, CommandMapIter iter);
 
-	void handleCommandMessage(CommandMessage* reply);
+	void handleCommandMessage(CommandMessageIF* reply);
 	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
-			CommandMessage* nextCommand,CommandMessage* reply, bool& isStep);
+			CommandMessageIF* nextCommand,CommandMessageIF* reply, bool& isStep);
 
 	void checkTimeout();
 };