Merge branch 'mueller/ipc-updates' into mueller/MQMQ_IF_UpdateFreeRTOS
This commit is contained in:
commit
20279169ed
@ -5,7 +5,7 @@ HealthDevice::HealthDevice(object_id_t setObjectId,
|
|||||||
MessageQueueId_t parentQueue) :
|
MessageQueueId_t parentQueue) :
|
||||||
SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue(
|
SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue(
|
||||||
parentQueue), commandQueue(), healthHelper(this, setObjectId) {
|
parentQueue), commandQueue(), healthHelper(this, setObjectId) {
|
||||||
commandQueue = QueueFactory::instance()->createMessageQueue(3, CommandMessage::COMMAND_MESSAGE_SIZE);
|
commandQueue = QueueFactory::instance()->createMessageQueue(3);
|
||||||
}
|
}
|
||||||
|
|
||||||
HealthDevice::~HealthDevice() {
|
HealthDevice::~HealthDevice() {
|
||||||
|
|||||||
@ -1,131 +1,111 @@
|
|||||||
/**
|
#include "CommandMessage.h"
|
||||||
* @file CommandMessage.cpp
|
#include "CommandMessageCleaner.h"
|
||||||
* @brief This file defines the CommandMessage class.
|
#include <cstring>
|
||||||
* @date 20.06.2013
|
|
||||||
* @author baetz
|
CommandMessage::CommandMessage() {
|
||||||
*/
|
MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
|
||||||
|
setCommand(CMD_NONE);
|
||||||
#include "../devicehandlers/DeviceHandlerMessage.h"
|
}
|
||||||
#include "../health/HealthMessage.h"
|
|
||||||
#include "CommandMessage.h"
|
CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
|
||||||
#include "../memory/MemoryMessage.h"
|
uint32_t parameter2) {
|
||||||
#include "../modes/ModeMessage.h"
|
MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
|
||||||
#include "../monitoring/MonitoringMessage.h"
|
setCommand(command);
|
||||||
#include "../subsystem/modes/ModeSequenceMessage.h"
|
setParameter(parameter1);
|
||||||
#include "../tmstorage/TmStoreMessage.h"
|
setParameter2(parameter2);
|
||||||
#include "../parameters/ParameterMessage.h"
|
}
|
||||||
|
|
||||||
namespace messagetypes {
|
Command_t CommandMessage::getCommand() const {
|
||||||
void clearMissionMessage(CommandMessage* message);
|
Command_t command;
|
||||||
}
|
std::memcpy(&command, MessageQueueMessage::getData(), sizeof(Command_t));
|
||||||
|
return command;
|
||||||
|
}
|
||||||
CommandMessage::CommandMessage() {
|
|
||||||
this->messageSize = COMMAND_MESSAGE_SIZE;
|
void CommandMessage::setCommand(Command_t command) {
|
||||||
setCommand(CMD_NONE);
|
std::memcpy(MessageQueueMessage::getData(), &command, sizeof(Command_t));
|
||||||
}
|
}
|
||||||
|
|
||||||
CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
|
uint8_t CommandMessage::getMessageType() const {
|
||||||
uint32_t parameter2) {
|
// first byte of command ID.
|
||||||
this->messageSize = COMMAND_MESSAGE_SIZE;
|
return getCommand() >> 8 & 0xff;
|
||||||
setCommand(command);
|
}
|
||||||
setParameter(parameter1);
|
|
||||||
setParameter2(parameter2);
|
uint32_t CommandMessage::getParameter() const {
|
||||||
}
|
uint32_t parameter1;
|
||||||
|
std::memcpy(¶meter1, this->getData(), sizeof(parameter1));
|
||||||
Command_t CommandMessage::getCommand() const {
|
return parameter1;
|
||||||
Command_t command;
|
}
|
||||||
memcpy(&command, getData(), sizeof(Command_t));
|
|
||||||
return command;
|
void CommandMessage::setParameter(uint32_t parameter1) {
|
||||||
}
|
std::memcpy(this->getData(), ¶meter1, sizeof(parameter1));
|
||||||
|
}
|
||||||
void CommandMessage::setCommand(Command_t command) {
|
|
||||||
memcpy(getData(), &command, sizeof(command));
|
uint32_t CommandMessage::getParameter2() const {
|
||||||
}
|
uint32_t parameter2;
|
||||||
|
std::memcpy(¶meter2, this->getData() + sizeof(uint32_t),
|
||||||
uint32_t CommandMessage::getParameter() const {
|
sizeof(parameter2));
|
||||||
uint32_t parameter1;
|
return parameter2;
|
||||||
memcpy(¶meter1, getData() + sizeof(Command_t), sizeof(parameter1));
|
}
|
||||||
return parameter1;
|
|
||||||
}
|
void CommandMessage::setParameter2(uint32_t parameter2) {
|
||||||
|
std::memcpy(this->getData() + sizeof(uint32_t), ¶meter2,
|
||||||
void CommandMessage::setParameter(uint32_t parameter1) {
|
sizeof(parameter2));
|
||||||
memcpy(getData() + sizeof(Command_t), ¶meter1, sizeof(parameter1));
|
}
|
||||||
}
|
|
||||||
|
uint32_t CommandMessage::getParameter3() const {
|
||||||
uint32_t CommandMessage::getParameter2() const {
|
uint32_t parameter3;
|
||||||
uint32_t parameter2;
|
std::memcpy(¶meter3, this->getData() + 2 * sizeof(uint32_t),
|
||||||
memcpy(¶meter2, getData() + sizeof(Command_t) + sizeof(uint32_t),
|
sizeof(parameter3));
|
||||||
sizeof(parameter2));
|
return parameter3;
|
||||||
return parameter2;
|
}
|
||||||
}
|
|
||||||
|
void CommandMessage::setParameter3(uint32_t parameter3) {
|
||||||
void CommandMessage::setParameter2(uint32_t parameter2) {
|
std::memcpy(this->getData() + 2 * sizeof(uint32_t), ¶meter3,
|
||||||
memcpy(getData() + sizeof(Command_t) + sizeof(uint32_t), ¶meter2,
|
sizeof(parameter3));
|
||||||
sizeof(parameter2));
|
}
|
||||||
}
|
|
||||||
|
size_t CommandMessage::getMinimumMessageSize() const {
|
||||||
void CommandMessage::clearCommandMessage() {
|
return MINIMUM_COMMAND_MESSAGE_SIZE;
|
||||||
switch((getCommand()>>8) & 0xff){
|
}
|
||||||
case messagetypes::MODE_COMMAND:
|
|
||||||
ModeMessage::clear(this);
|
void CommandMessage::clearCommandMessage() {
|
||||||
break;
|
clear();
|
||||||
case messagetypes::HEALTH_COMMAND:
|
}
|
||||||
HealthMessage::clear(this);
|
|
||||||
break;
|
void CommandMessage::clear() {
|
||||||
case messagetypes::MODE_SEQUENCE:
|
CommandMessageCleaner::clearCommandMessage(this);
|
||||||
ModeSequenceMessage::clear(this);
|
}
|
||||||
break;
|
|
||||||
case messagetypes::ACTION:
|
bool CommandMessage::isClearedCommandMessage() {
|
||||||
ActionMessage::clear(this);
|
return getCommand() == CMD_NONE;
|
||||||
break;
|
}
|
||||||
case messagetypes::DEVICE_HANDLER_COMMAND:
|
|
||||||
DeviceHandlerMessage::clear(this);
|
void CommandMessage::setToUnknownCommand() {
|
||||||
break;
|
Command_t initialCommand = getCommand();
|
||||||
case messagetypes::MEMORY:
|
this->clear();
|
||||||
MemoryMessage::clear(this);
|
setReplyRejected(UNKNOWN_COMMAND, initialCommand);
|
||||||
break;
|
}
|
||||||
case messagetypes::MONITORING:
|
|
||||||
MonitoringMessage::clear(this);
|
void CommandMessage::setReplyRejected(ReturnValue_t reason,
|
||||||
break;
|
Command_t initialCommand) {
|
||||||
case messagetypes::TM_STORE:
|
setCommand(REPLY_REJECTED);
|
||||||
TmStoreMessage::clear(this);
|
setParameter(reason);
|
||||||
break;
|
setParameter2(initialCommand);
|
||||||
case messagetypes::PARAMETER:
|
}
|
||||||
ParameterMessage::clear(this);
|
|
||||||
break;
|
ReturnValue_t CommandMessage::getReplyRejectedReason(
|
||||||
default:
|
Command_t *initialCommand) const {
|
||||||
messagetypes::clearMissionMessage(this);
|
ReturnValue_t reason = getParameter();
|
||||||
break;
|
if(initialCommand != nullptr) {
|
||||||
}
|
*initialCommand = getParameter2();
|
||||||
}
|
}
|
||||||
|
return reason;
|
||||||
bool CommandMessage::isClearedCommandMessage() {
|
}
|
||||||
return getCommand() == CMD_NONE;
|
|
||||||
}
|
uint8_t* CommandMessage::getData() {
|
||||||
|
return MessageQueueMessage::getData() + sizeof(Command_t);
|
||||||
size_t CommandMessage::getMinimumMessageSize() const {
|
}
|
||||||
return COMMAND_MESSAGE_SIZE;
|
|
||||||
}
|
const uint8_t* CommandMessage::getData() const {
|
||||||
|
return MessageQueueMessage::getData() + sizeof(Command_t);
|
||||||
void CommandMessage::setToUnknownCommand() {
|
}
|
||||||
Command_t initialCommand = getCommand();
|
|
||||||
clearCommandMessage();
|
|
||||||
setReplyRejected(UNKNOWN_COMMAND, initialCommand);
|
|
||||||
}
|
|
||||||
|
|
||||||
void CommandMessage::setReplyRejected(ReturnValue_t reason,
|
|
||||||
Command_t initialCommand) {
|
|
||||||
setCommand(REPLY_REJECTED);
|
|
||||||
setParameter(reason);
|
|
||||||
setParameter2(initialCommand);
|
|
||||||
}
|
|
||||||
|
|
||||||
ReturnValue_t CommandMessage::getReplyRejectedReason(
|
|
||||||
Command_t *initialCommand) const {
|
|
||||||
ReturnValue_t reason = getParameter();
|
|
||||||
if(initialCommand != nullptr) {
|
|
||||||
*initialCommand = getParameter2();
|
|
||||||
}
|
|
||||||
return reason;
|
|
||||||
}
|
|
||||||
|
|||||||
@ -1,134 +1,129 @@
|
|||||||
/**
|
#ifndef FSFW_IPC_COMMANDMESSAGE_H_
|
||||||
* @file CommandMessage.h
|
#define FSFW_IPC_COMMANDMESSAGE_H_
|
||||||
* @brief This file defines the CommandMessage class.
|
|
||||||
* @date 20.06.2013
|
#include "CommandMessageIF.h"
|
||||||
* @author baetz
|
#include "MessageQueueMessage.h"
|
||||||
*/
|
#include "FwMessageTypes.h"
|
||||||
|
|
||||||
#ifndef COMMANDMESSAGE_H_
|
/**
|
||||||
#define COMMANDMESSAGE_H_
|
* @brief Default command message used to pass command messages between tasks.
|
||||||
|
* Primary message type for IPC. Contains sender, 2-byte command ID
|
||||||
|
* field, and 2 4-byte parameters.
|
||||||
#include "FwMessageTypes.h"
|
* @details
|
||||||
#include <config/ipc/MissionMessageTypes.h>
|
* It operates on an external memory which is contained inside a
|
||||||
|
* class implementing MessageQueueMessageIF by taking its address.
|
||||||
#include "MessageQueueMessage.h"
|
* This allows for a more flexible designs of message implementations.
|
||||||
|
* The pointer can be passed to different message implementations without
|
||||||
#define MAKE_COMMAND_ID( number ) ((MESSAGE_ID << 8) + (number))
|
* the need of unnecessary copying.
|
||||||
typedef ReturnValue_t Command_t;
|
*
|
||||||
|
* The command message is based of the generic MessageQueueMessage which
|
||||||
class CommandMessage : public MessageQueueMessage {
|
* currently has an internal message size of 28 bytes.
|
||||||
public:
|
* @author Bastian Baetz
|
||||||
static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
|
*/
|
||||||
static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
|
class CommandMessage: public MessageQueueMessage, public CommandMessageIF {
|
||||||
|
public:
|
||||||
|
/**
|
||||||
static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
|
* Default size can accomodate 2 4-byte parameters.
|
||||||
static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );//!< Used internally, will be ignored
|
*/
|
||||||
static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 3 );
|
static constexpr size_t DEFAULT_COMMAND_MESSAGE_SIZE =
|
||||||
static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 0xD1 );//!< Reply indicating that the current command was rejected, par1 should contain the error code
|
CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE + sizeof(uint32_t);
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* This is the size of a message as it is seen by the MessageQueue
|
* @brief Default Constructor, does not initialize anything.
|
||||||
*/
|
* @details
|
||||||
static const size_t COMMAND_MESSAGE_SIZE = HEADER_SIZE
|
* This constructor should be used when receiving a Message, as the
|
||||||
+ sizeof(Command_t) + 2 * sizeof(uint32_t);
|
* content is filled by the MessageQueue.
|
||||||
|
*/
|
||||||
/**
|
CommandMessage();
|
||||||
* Default Constructor, does not initialize anything.
|
/**
|
||||||
*
|
* This constructor creates a new message with all message content
|
||||||
* This constructor should be used when receiving a Message, as the content is filled by the MessageQueue.
|
* initialized
|
||||||
*/
|
*
|
||||||
CommandMessage();
|
* @param command The DeviceHandlerCommand_t that will be sent
|
||||||
/**
|
* @param parameter1 The first parameter
|
||||||
* This constructor creates a new message with all message content initialized
|
* @param parameter2 The second parameter
|
||||||
*
|
*/
|
||||||
* @param command The DeviceHandlerCommand_t that will be sent
|
CommandMessage(Command_t command, uint32_t parameter1, uint32_t parameter2);
|
||||||
* @param parameter1 The first parameter
|
|
||||||
* @param parameter2 The second parameter
|
/**
|
||||||
*/
|
* @brief Default Destructor
|
||||||
CommandMessage(Command_t command,
|
*/
|
||||||
uint32_t parameter1, uint32_t parameter2);
|
virtual ~CommandMessage() {}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Default Destructor
|
* Read the DeviceHandlerCommand_t that is stored in the message,
|
||||||
*/
|
* usually used after receiving.
|
||||||
virtual ~CommandMessage() {
|
*
|
||||||
}
|
* @return the Command stored in the Message
|
||||||
|
*/
|
||||||
/**
|
virtual Command_t getCommand() const override;
|
||||||
* Read the DeviceHandlerCommand_t that is stored in the message, usually used after receiving
|
/**
|
||||||
*
|
* Set the command type of the message. Default implementation also
|
||||||
* @return the Command stored in the Message
|
* sets the message type, which will be the first byte of the command ID.
|
||||||
*/
|
* @param the Command to be sent
|
||||||
Command_t getCommand() const;
|
*/
|
||||||
|
virtual void setCommand(Command_t command);
|
||||||
/**
|
|
||||||
* Set the DeviceHandlerCOmmand_t of the message
|
virtual uint8_t* getData() override;
|
||||||
*
|
virtual const uint8_t* getData() const override;
|
||||||
* @param the Command to be sent
|
|
||||||
*/
|
/**
|
||||||
void setCommand(Command_t command);
|
* Get the first parameter of the message
|
||||||
|
* @return the first Parameter of the message
|
||||||
/**
|
*/
|
||||||
* Get the first parameter of the message
|
uint32_t getParameter() const;
|
||||||
*
|
/**
|
||||||
* @return the first Parameter of the message
|
* Set the first parameter of the message
|
||||||
*/
|
* @param the first parameter of the message
|
||||||
uint32_t getParameter() const;
|
*/
|
||||||
|
void setParameter(uint32_t parameter1);
|
||||||
/**
|
uint32_t getParameter2() const;
|
||||||
* Set the first parameter of the message
|
void setParameter2(uint32_t parameter2);
|
||||||
*
|
uint32_t getParameter3() const;
|
||||||
* @param the first parameter of the message
|
void setParameter3(uint32_t parameter3);
|
||||||
*/
|
|
||||||
void setParameter(uint32_t parameter1);
|
/**
|
||||||
|
* check if a message was cleared
|
||||||
/**
|
*
|
||||||
* Get the second parameter of the message
|
* @return if the command is CMD_NONE
|
||||||
*
|
*/
|
||||||
* @return the second Parameter of the message
|
bool isClearedCommandMessage();
|
||||||
*/
|
|
||||||
uint32_t getParameter2() const;
|
/**
|
||||||
|
* Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND.
|
||||||
/**
|
* Is needed quite often, so we better code it once only.
|
||||||
* Set the second parameter of the message
|
*/
|
||||||
*
|
void setToUnknownCommand() override;
|
||||||
* @param the second parameter of the message
|
|
||||||
*/
|
/**
|
||||||
void setParameter2(uint32_t parameter2);
|
* A command message can be rejected and needs to offer a function
|
||||||
|
* to set a rejected reply
|
||||||
/**
|
* @param reason
|
||||||
* Set the command to CMD_NONE and try to find
|
* @param initialCommand
|
||||||
* the correct class to handle a more detailed
|
*/
|
||||||
* clear.
|
void setReplyRejected(ReturnValue_t reason,
|
||||||
* Also, calls a mission-specific clearMissionMessage
|
Command_t initialCommand) override;
|
||||||
* function to separate between framework and mission
|
/**
|
||||||
* messages. Not optimal, may be replaced by totally
|
* Corrensonding getter function.
|
||||||
* different auto-delete solution (e.g. smart pointers).
|
* @param initialCommand
|
||||||
*
|
* @return
|
||||||
*/
|
*/
|
||||||
void clearCommandMessage();
|
ReturnValue_t getReplyRejectedReason(
|
||||||
|
Command_t* initialCommand = nullptr) const override;
|
||||||
/**
|
|
||||||
* check if a message was cleared
|
|
||||||
*
|
virtual void clear() override;
|
||||||
* @return if the command is CMD_NONE
|
void clearCommandMessage();
|
||||||
*/
|
|
||||||
bool isClearedCommandMessage();
|
/**
|
||||||
|
* Extract message ID, which is the first byte of the command ID for the
|
||||||
|
* default implementation.
|
||||||
/**
|
* @return
|
||||||
* Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND.
|
*/
|
||||||
* Is needed quite often, so we better code it once only.
|
virtual uint8_t getMessageType() const override;
|
||||||
*/
|
|
||||||
void setToUnknownCommand();
|
/** MessageQueueMessageIF functions used for minimum size check. */
|
||||||
void setReplyRejected(ReturnValue_t reason, Command_t initialCommand = CMD_NONE);
|
size_t getMinimumMessageSize() const override;
|
||||||
ReturnValue_t getReplyRejectedReason(
|
};
|
||||||
Command_t *initialCommand = nullptr) const;
|
|
||||||
|
#endif /* FSFW_IPC_COMMANDMESSAGE_H_ */
|
||||||
size_t getMinimumMessageSize() const;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
#endif /* COMMANDMESSAGE_H_ */
|
|
||||||
|
|||||||
45
ipc/CommandMessageCleaner.cpp
Normal file
45
ipc/CommandMessageCleaner.cpp
Normal file
@ -0,0 +1,45 @@
|
|||||||
|
#include "../ipc/CommandMessageCleaner.h"
|
||||||
|
|
||||||
|
#include "../devicehandlers/DeviceHandlerMessage.h"
|
||||||
|
#include "../health/HealthMessage.h"
|
||||||
|
#include "../memory/MemoryMessage.h"
|
||||||
|
#include "../modes/ModeMessage.h"
|
||||||
|
#include "../monitoring/MonitoringMessage.h"
|
||||||
|
#include "../subsystem/modes/ModeSequenceMessage.h"
|
||||||
|
#include "../tmstorage/TmStoreMessage.h"
|
||||||
|
#include "../parameters/ParameterMessage.h"
|
||||||
|
|
||||||
|
void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
|
||||||
|
switch(message->getMessageType()){
|
||||||
|
case messagetypes::MODE_COMMAND:
|
||||||
|
ModeMessage::clear(message);
|
||||||
|
break;
|
||||||
|
case messagetypes::HEALTH_COMMAND:
|
||||||
|
HealthMessage::clear(message);
|
||||||
|
break;
|
||||||
|
case messagetypes::MODE_SEQUENCE:
|
||||||
|
ModeSequenceMessage::clear(message);
|
||||||
|
break;
|
||||||
|
case messagetypes::ACTION:
|
||||||
|
ActionMessage::clear(message);
|
||||||
|
break;
|
||||||
|
case messagetypes::DEVICE_HANDLER_COMMAND:
|
||||||
|
DeviceHandlerMessage::clear(message);
|
||||||
|
break;
|
||||||
|
case messagetypes::MEMORY:
|
||||||
|
MemoryMessage::clear(message);
|
||||||
|
break;
|
||||||
|
case messagetypes::MONITORING:
|
||||||
|
MonitoringMessage::clear(message);
|
||||||
|
break;
|
||||||
|
case messagetypes::TM_STORE:
|
||||||
|
TmStoreMessage::clear(message);
|
||||||
|
break;
|
||||||
|
case messagetypes::PARAMETER:
|
||||||
|
ParameterMessage::clear(message);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
messagetypes::clearMissionMessage(message);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
16
ipc/CommandMessageCleaner.h
Normal file
16
ipc/CommandMessageCleaner.h
Normal file
@ -0,0 +1,16 @@
|
|||||||
|
#ifndef FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
|
||||||
|
#define FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
|
||||||
|
#include "../ipc/CommandMessage.h"
|
||||||
|
|
||||||
|
namespace messagetypes {
|
||||||
|
// Implemented in config.
|
||||||
|
void clearMissionMessage(CommandMessage* message);
|
||||||
|
}
|
||||||
|
|
||||||
|
class CommandMessageCleaner {
|
||||||
|
public:
|
||||||
|
static void clearCommandMessage(CommandMessage* message);
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
#endif /* FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ */
|
||||||
73
ipc/CommandMessageIF.h
Normal file
73
ipc/CommandMessageIF.h
Normal file
@ -0,0 +1,73 @@
|
|||||||
|
#ifndef FSFW_IPC_COMMANDMESSAGEIF_H_
|
||||||
|
#define FSFW_IPC_COMMANDMESSAGEIF_H_
|
||||||
|
|
||||||
|
#include "MessageQueueMessageIF.h"
|
||||||
|
#include "FwMessageTypes.h"
|
||||||
|
#include "../returnvalues/HasReturnvaluesIF.h"
|
||||||
|
|
||||||
|
#define MAKE_COMMAND_ID( number ) ((MESSAGE_ID << 8) + (number))
|
||||||
|
typedef uint16_t Command_t;
|
||||||
|
|
||||||
|
class CommandMessageIF {
|
||||||
|
public:
|
||||||
|
/**
|
||||||
|
* Header consists of sender ID and command ID.
|
||||||
|
*/
|
||||||
|
static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE +
|
||||||
|
sizeof(Command_t);
|
||||||
|
/**
|
||||||
|
* This minimum size is derived from the interface requirement to be able
|
||||||
|
* to set a rejected reply, which contains a returnvalue and the initial
|
||||||
|
* command.
|
||||||
|
*/
|
||||||
|
static constexpr size_t MINIMUM_COMMAND_MESSAGE_SIZE =
|
||||||
|
CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_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() {};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A command message shall have a uint16_t command ID field.
|
||||||
|
* @return
|
||||||
|
*/
|
||||||
|
virtual Command_t getCommand() const = 0;
|
||||||
|
/**
|
||||||
|
* A command message shall have a uint8_t message type ID field.
|
||||||
|
* @return
|
||||||
|
*/
|
||||||
|
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;
|
||||||
|
|
||||||
|
virtual void setToUnknownCommand() = 0;
|
||||||
|
|
||||||
|
virtual void clear() = 0;
|
||||||
|
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif /* FSFW_IPC_COMMANDMESSAGEIF_H_ */
|
||||||
@ -1,65 +1,84 @@
|
|||||||
#include "MessageQueueMessage.h"
|
#include "MessageQueueMessage.h"
|
||||||
#include "../serviceinterface/ServiceInterfaceStream.h"
|
#include "../serviceinterface/ServiceInterfaceStream.h"
|
||||||
|
#include "../globalfunctions/arrayprinter.h"
|
||||||
#include <string.h>
|
#include <cstring>
|
||||||
|
|
||||||
MessageQueueMessage::MessageQueueMessage() :
|
MessageQueueMessage::MessageQueueMessage() :
|
||||||
messageSize(this->HEADER_SIZE) {
|
messageSize(getMinimumMessageSize()) {
|
||||||
memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
|
memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
|
||||||
}
|
}
|
||||||
|
|
||||||
MessageQueueMessage::~MessageQueueMessage() {
|
MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) :
|
||||||
}
|
messageSize(this->HEADER_SIZE + size) {
|
||||||
|
if (size <= this->MAX_DATA_SIZE) {
|
||||||
const uint8_t* MessageQueueMessage::getBuffer() const {
|
memcpy(this->getData(), data, size);
|
||||||
return this->internalBuffer;
|
this->messageSize = this->HEADER_SIZE + size;
|
||||||
}
|
}
|
||||||
|
else {
|
||||||
uint8_t* MessageQueueMessage::getBuffer() {
|
sif::warning << "MessageQueueMessage: Passed size larger than maximum"
|
||||||
return this->internalBuffer;
|
"allowed size! Setting content to 0" << std::endl;
|
||||||
}
|
memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
|
||||||
|
this->messageSize = this->HEADER_SIZE;
|
||||||
const uint8_t* MessageQueueMessage::getData() const {
|
}
|
||||||
return this->internalBuffer + this->HEADER_SIZE;
|
}
|
||||||
}
|
|
||||||
|
MessageQueueMessage::~MessageQueueMessage() {
|
||||||
uint8_t* MessageQueueMessage::getData() {
|
}
|
||||||
return this->internalBuffer + this->HEADER_SIZE;
|
|
||||||
}
|
const uint8_t* MessageQueueMessage::getBuffer() const {
|
||||||
|
return this->internalBuffer;
|
||||||
MessageQueueId_t MessageQueueMessage::getSender() const {
|
}
|
||||||
MessageQueueId_t temp_id;
|
|
||||||
memcpy(&temp_id, this->internalBuffer, sizeof(MessageQueueId_t));
|
uint8_t* MessageQueueMessage::getBuffer() {
|
||||||
return temp_id;
|
return this->internalBuffer;
|
||||||
}
|
}
|
||||||
|
|
||||||
void MessageQueueMessage::setSender(MessageQueueId_t setId) {
|
const uint8_t* MessageQueueMessage::getData() const {
|
||||||
memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
|
return this->internalBuffer + this->HEADER_SIZE;
|
||||||
}
|
}
|
||||||
|
|
||||||
MessageQueueMessage::MessageQueueMessage(uint8_t* data, uint32_t size) :
|
uint8_t* MessageQueueMessage::getData() {
|
||||||
messageSize(this->HEADER_SIZE + size) {
|
return this->internalBuffer + this->HEADER_SIZE;
|
||||||
if (size <= this->MAX_DATA_SIZE) {
|
}
|
||||||
memcpy(this->getData(), data, size);
|
|
||||||
} else {
|
MessageQueueId_t MessageQueueMessage::getSender() const {
|
||||||
memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
|
MessageQueueId_t temp_id;
|
||||||
this->messageSize = this->HEADER_SIZE;
|
memcpy(&temp_id, this->internalBuffer, sizeof(MessageQueueId_t));
|
||||||
}
|
return temp_id;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t MessageQueueMessage::getMinimumMessageSize() {
|
void MessageQueueMessage::setSender(MessageQueueId_t setId) {
|
||||||
return this->HEADER_SIZE;
|
memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
|
||||||
}
|
}
|
||||||
|
|
||||||
void MessageQueueMessage::print() {
|
void MessageQueueMessage::print(bool printWholeMessage) {
|
||||||
sif::debug << "MessageQueueMessage has size: " << this->messageSize << std::hex
|
sif::debug << "MessageQueueMessage content: " << std::endl;
|
||||||
<< std::endl;
|
if(printWholeMessage) {
|
||||||
for (uint8_t count = 0; count < this->messageSize; count++) {
|
arrayprinter::print(getData(), getMaximumMessageSize());
|
||||||
sif::debug << (uint32_t) this->internalBuffer[count] << ":";
|
}
|
||||||
}
|
else {
|
||||||
sif::debug << std::dec << std::endl;
|
arrayprinter::print(getData(), getMessageSize());
|
||||||
}
|
}
|
||||||
|
|
||||||
void MessageQueueMessage::clear() {
|
}
|
||||||
memset(this->getBuffer(), 0, this->MAX_MESSAGE_SIZE);
|
|
||||||
}
|
void MessageQueueMessage::clear() {
|
||||||
|
memset(this->getBuffer(), 0, this->MAX_MESSAGE_SIZE);
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t MessageQueueMessage::getMessageSize() const {
|
||||||
|
return this->messageSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
void MessageQueueMessage::setMessageSize(size_t messageSize) {
|
||||||
|
this->messageSize = messageSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t MessageQueueMessage::getMinimumMessageSize() const {
|
||||||
|
return this->MIN_MESSAGE_SIZE;
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t MessageQueueMessage::getMaximumMessageSize() const {
|
||||||
|
return this->MAX_MESSAGE_SIZE;
|
||||||
|
}
|
||||||
|
|
||||||
|
|||||||
@ -1,118 +1,150 @@
|
|||||||
#ifndef MESSAGEQUEUEMESSAGE_H_
|
#ifndef FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
|
||||||
#define MESSAGEQUEUEMESSAGE_H_
|
#define FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
|
||||||
|
|
||||||
#include "MessageQueueSenderIF.h"
|
#include "../ipc/MessageQueueMessageIF.h"
|
||||||
#include <stddef.h>
|
#include "../ipc/MessageQueueSenderIF.h"
|
||||||
|
#include <cstddef>
|
||||||
/**
|
|
||||||
* \brief This class is the representation and data organizer for interprocess messages.
|
/**
|
||||||
*
|
* @brief This class is the representation and data organizer
|
||||||
* \details To facilitate and standardize interprocess communication, this class was created
|
* for interprocess messages.
|
||||||
* to handle a lightweight "interprocess message protocol". It adds a header with the
|
* @details
|
||||||
* sender's queue id to every sent message and defines the maximum total message size.
|
* To facilitate and standardize interprocess communication, this class was
|
||||||
* Specialized messages, such as device commanding messages, can be created by inheriting
|
* created to handle a lightweight "interprocess message protocol".
|
||||||
* from this class and filling the buffer provided by getData with additional content.
|
*
|
||||||
* If larger amounts of data must be sent between processes, the data shall be stored in
|
* It adds a header with the sender's queue id to every sent message and
|
||||||
* the IPC Store object and only the storage id is passed in a queue message.
|
* defines the maximum total message size. Specialized messages, such as
|
||||||
* The class is used both to generate and send messages and to receive messages from
|
* device commanding messages, can be created by inheriting from this class
|
||||||
* other tasks.
|
* and filling the buffer provided by getData with additional content.
|
||||||
* \ingroup message_queue
|
*
|
||||||
*/
|
* If larger amounts of data must be sent between processes, the data shall
|
||||||
class MessageQueueMessage {
|
* be stored in the IPC Store object and only the storage id is passed in a
|
||||||
public:
|
* queue message.The class is used both to generate and send messages and to
|
||||||
/**
|
* receive messages from other tasks.
|
||||||
* \brief This constant defines the maximum size of the data content, excluding the header.
|
* @ingroup message_queue
|
||||||
* \details It may be changed if necessary, but in general should be kept as small as possible.
|
*/
|
||||||
*/
|
class MessageQueueMessage: public MessageQueueMessageIF {
|
||||||
static const size_t MAX_DATA_SIZE = 24;
|
public:
|
||||||
/**
|
/**
|
||||||
* \brief This constants defines the size of the header, which is added to every message.
|
* @brief The class is initialized empty with this constructor.
|
||||||
*/
|
* @details
|
||||||
static const size_t HEADER_SIZE = sizeof(MessageQueueId_t);
|
* The messageSize attribute is set to the header's size and the whole
|
||||||
/**
|
* content is set to zero.
|
||||||
* \brief This constant defines the maximum total size in bytes of a sent message.
|
*/
|
||||||
* \details It is the sum of the maximum data and the header size. Be aware that this constant
|
MessageQueueMessage();
|
||||||
* is used to define the buffer sizes for every message queue in the system. So, a change
|
/**
|
||||||
* here may have significant impact on the required resources.
|
* @brief With this constructor the class is initialized with
|
||||||
*/
|
* the given content.
|
||||||
static const size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
|
* @details
|
||||||
private:
|
* If the passed message size fits into the buffer, the passed data is
|
||||||
/**
|
* copied to the internal buffer and the messageSize information is set.
|
||||||
* \brief This is the internal buffer that contains the actual message data.
|
* Otherwise, messageSize is set to the header's size and the whole
|
||||||
*/
|
* content is set to zero.
|
||||||
uint8_t internalBuffer[MAX_MESSAGE_SIZE];
|
* @param data The data to be put in the message.
|
||||||
public:
|
* @param size Size of the data to be copied. Must be smaller than
|
||||||
/**
|
* MAX_MESSAGE_SIZE and larger than MIN_MESSAGE_SIZE.
|
||||||
* \brief The size information of each message is stored in this attribute.
|
*/
|
||||||
* \details It is public to simplify usage and to allow for passing the variable's address as a
|
MessageQueueMessage(uint8_t* data, size_t size);
|
||||||
* pointer. Care must be taken when inheriting from this class, as every child class is
|
|
||||||
* responsible for managing the size information by itself. When using the class to
|
/**
|
||||||
* receive a message, the size information is updated automatically.
|
* @brief As no memory is allocated in this class,
|
||||||
*/
|
* the destructor is empty.
|
||||||
size_t messageSize;
|
*/
|
||||||
/**
|
virtual ~MessageQueueMessage();
|
||||||
* \brief The class is initialized empty with this constructor.
|
|
||||||
* \details The messageSize attribute is set to the header's size and the whole content is set to
|
/**
|
||||||
* zero.
|
* @brief The size information of each message is stored in
|
||||||
*/
|
* this attribute.
|
||||||
MessageQueueMessage();
|
* @details
|
||||||
/**
|
* It is public to simplify usage and to allow for passing the size
|
||||||
* \brief With this constructor the class is initialized with the given content.
|
* address as a pointer. Care must be taken when inheriting from this class,
|
||||||
* \details If the passed message size fits into the buffer, the passed data is copied to the
|
* as every child class is responsible for managing the size information by
|
||||||
* internal buffer and the messageSize information is set. Otherwise, messageSize
|
* itself. When using the class to receive a message, the size information
|
||||||
* is set to the header's size and the whole content is set to zero.
|
* is updated automatically.
|
||||||
* \param data The data to be put in the message.
|
*
|
||||||
* \param size Size of the data to be copied. Must be smaller than MAX_MESSAGE_SIZE.
|
* Please note that the minimum size is limited by the size of the header
|
||||||
*/
|
* while the maximum size is limited by the maximum allowed message size.
|
||||||
MessageQueueMessage(uint8_t* data, uint32_t size);
|
*/
|
||||||
/**
|
size_t messageSize;
|
||||||
* \brief As no memory is allocated in this class, the destructor is empty.
|
/**
|
||||||
*/
|
* @brief This constant defines the maximum size of the data content,
|
||||||
virtual ~MessageQueueMessage();
|
* excluding the header.
|
||||||
/**
|
* @details
|
||||||
* \brief This method is used to get the complete data of the message.
|
* It may be changed if necessary, but in general should be kept
|
||||||
*/
|
* as small as possible.
|
||||||
const uint8_t* getBuffer() const;
|
*/
|
||||||
/**
|
static const size_t MAX_DATA_SIZE = 24;
|
||||||
* \brief This method is used to get the complete data of the message.
|
|
||||||
*/
|
/**
|
||||||
uint8_t* getBuffer();
|
* @brief This constant defines the maximum total size in bytes
|
||||||
/**
|
* of a sent message.
|
||||||
* \brief This method is used to fetch the data content of the message.
|
* @details
|
||||||
* \details It shall be used by child classes to add data at the right position.
|
* It is the sum of the maximum data and the header size. Be aware that
|
||||||
*/
|
* this constant is used to define the buffer sizes for every message
|
||||||
const uint8_t* getData() const;
|
* queue in the system. So, a change here may have significant impact on
|
||||||
/**
|
* the required resources.
|
||||||
* \brief This method is used to fetch the data content of the message.
|
*/
|
||||||
* \details It shall be used by child classes to add data at the right position.
|
static constexpr size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
|
||||||
*/
|
/**
|
||||||
uint8_t* getData();
|
* @brief Defines the minimum size of a message where only the
|
||||||
/**
|
* header is included
|
||||||
* \brief This method is used to extract the sender's message queue id information from a
|
*/
|
||||||
* received message.
|
static constexpr size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
|
||||||
*/
|
private:
|
||||||
MessageQueueId_t getSender() const;
|
/**
|
||||||
/**
|
* @brief This is the internal buffer that contains the
|
||||||
* \brief With this method, the whole content and the message size is set to zero.
|
* actual message data.
|
||||||
*/
|
*/
|
||||||
void clear();
|
uint8_t internalBuffer[MAX_MESSAGE_SIZE];
|
||||||
/**
|
public:
|
||||||
* \brief This is a debug method that prints the content (till messageSize) to the debug output.
|
/**
|
||||||
*/
|
* @brief This method is used to get the complete data of the message.
|
||||||
void print();
|
*/
|
||||||
/**
|
const uint8_t* getBuffer() const override;
|
||||||
* \brief This method is used to set the sender's message queue id information prior to
|
/**
|
||||||
* sending the message.
|
* @brief This method is used to get the complete data of the message.
|
||||||
* \param setId The message queue id that identifies the sending message queue.
|
*/
|
||||||
*/
|
uint8_t* getBuffer() override;
|
||||||
void setSender(MessageQueueId_t setId);
|
/**
|
||||||
/**
|
* @brief This method is used to fetch the data content of the message.
|
||||||
* \brief This helper function is used by the MessageQueue class to check the size of an
|
* @details
|
||||||
* incoming message.
|
* It shall be used by child classes to add data at the right position.
|
||||||
* \details The method must be overwritten by child classes if size checks shall be more strict.
|
*/
|
||||||
* @return The default implementation returns HEADER_SIZE.
|
const uint8_t* getData() const override;
|
||||||
*/
|
/**
|
||||||
virtual size_t getMinimumMessageSize();
|
* @brief This method is used to fetch the data content of the message.
|
||||||
};
|
* @details
|
||||||
|
* It shall be used by child classes to add data at the right position.
|
||||||
#endif /* MESSAGEQUEUEMESSAGE_H_ */
|
*/
|
||||||
|
uint8_t* getData() override;
|
||||||
|
/**
|
||||||
|
* @brief This method is used to extract the sender's message
|
||||||
|
* queue id information from a received message.
|
||||||
|
*/
|
||||||
|
MessageQueueId_t getSender() const override;
|
||||||
|
/**
|
||||||
|
* @brief With this method, the whole content
|
||||||
|
* and the message size is set to zero.
|
||||||
|
*/
|
||||||
|
void clear() override;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief This method is used to set the sender's message queue id
|
||||||
|
* information prior to ing the message.
|
||||||
|
* @param setId
|
||||||
|
* The message queue id that identifies the sending message queue.
|
||||||
|
*/
|
||||||
|
void setSender(MessageQueueId_t setId) override;
|
||||||
|
|
||||||
|
virtual size_t getMessageSize() const override;
|
||||||
|
virtual void setMessageSize(size_t messageSize) override;
|
||||||
|
virtual size_t getMinimumMessageSize() const override;
|
||||||
|
virtual size_t getMaximumMessageSize() const override;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief This is a debug method that prints the content.
|
||||||
|
*/
|
||||||
|
void print(bool printWholeMessage);
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif /* FSFW_IPC_MESSAGEQUEUEMESSAGE_H_ */
|
||||||
|
|||||||
91
ipc/MessageQueueMessageIF.h
Normal file
91
ipc/MessageQueueMessageIF.h
Normal file
@ -0,0 +1,91 @@
|
|||||||
|
#ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
|
||||||
|
#define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
|
||||||
|
#include <cstddef>
|
||||||
|
#include <cstdint>
|
||||||
|
|
||||||
|
/*
|
||||||
|
* TODO: Actually, the definition of this ID to be a uint32_t is not ideal and
|
||||||
|
* breaks layering. However, it is difficult to keep layering, as the ID is
|
||||||
|
* stored in many places and sent around in MessageQueueMessage.
|
||||||
|
* Ideally, one would use the (current) object_id_t only, however, doing a
|
||||||
|
* lookup of queueIDs for every call does not sound ideal.
|
||||||
|
* In a first step, I'll circumvent the issue by not touching it,
|
||||||
|
* maybe in a second step. This also influences Interface design
|
||||||
|
* (getCommandQueue) and some other issues..
|
||||||
|
*/
|
||||||
|
|
||||||
|
typedef uint32_t MessageQueueId_t;
|
||||||
|
|
||||||
|
class MessageQueueMessageIF {
|
||||||
|
public:
|
||||||
|
static const MessageQueueId_t NO_QUEUE = -1;
|
||||||
|
/**
|
||||||
|
* @brief This constants defines the size of the header,
|
||||||
|
* which is added to every message.
|
||||||
|
*/
|
||||||
|
static const size_t HEADER_SIZE = sizeof(MessageQueueId_t);
|
||||||
|
|
||||||
|
virtual ~MessageQueueMessageIF() {};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief With this method, the whole content and the message
|
||||||
|
* size is set to zero.
|
||||||
|
* @details
|
||||||
|
* Implementations should also take care to clear data which is stored
|
||||||
|
* indirectly (e.g. storage data).
|
||||||
|
*/
|
||||||
|
virtual void clear() = 0;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Get read-only pointer to the complete data of the message.
|
||||||
|
* @return
|
||||||
|
*/
|
||||||
|
virtual const uint8_t* getBuffer() const = 0;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief This method is used to get the complete data of the message.
|
||||||
|
*/
|
||||||
|
virtual uint8_t* getBuffer() = 0;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief This method is used to set the sender's message queue id
|
||||||
|
* information prior to sending the message.
|
||||||
|
* @param setId
|
||||||
|
* The message queue id that identifies the sending message queue.
|
||||||
|
*/
|
||||||
|
virtual void setSender(MessageQueueId_t setId) = 0;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief This method is used to extract the sender's message queue id
|
||||||
|
* information from a received message.
|
||||||
|
*/
|
||||||
|
virtual MessageQueueId_t getSender() const = 0;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief This method is used to fetch the data content of the message.
|
||||||
|
* @details
|
||||||
|
* It shall be used by child classes to add data at the right position.
|
||||||
|
*/
|
||||||
|
virtual const uint8_t* getData() const = 0;
|
||||||
|
/**
|
||||||
|
* @brief This method is used to fetch the data content of the message.
|
||||||
|
* @details
|
||||||
|
* It shall be used by child classes to add data at the right position.
|
||||||
|
*/
|
||||||
|
virtual uint8_t* getData() = 0;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get constant message size of current message implementation.
|
||||||
|
* @return
|
||||||
|
*/
|
||||||
|
virtual size_t getMessageSize() const = 0;
|
||||||
|
|
||||||
|
virtual void setMessageSize(size_t messageSize) = 0;
|
||||||
|
virtual size_t getMinimumMessageSize() const = 0;
|
||||||
|
virtual size_t getMaximumMessageSize() const = 0;
|
||||||
|
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
#endif /* FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_ */
|
||||||
Loading…
Reference in New Issue
Block a user