Adding Code for Linux

action/ActionHelper.cpp

@@ -20,11 +20,13 @@ ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
 	}
 }
 
-ReturnValue_t ActionHelper::initialize() {
+ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
 	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	if (ipcStore == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+	setQueueToUse(queueToUse_);
+
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -100,3 +102,6 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
 	}
 	return result;
 }
+
+void ActionHelper::resetHelper() {
+}

action/ActionHelper.h

@@ -4,26 +4,90 @@
 #include <framework/action/ActionMessage.h>
 #include <framework/serialize/SerializeIF.h>
 #include <framework/ipc/MessageQueueIF.h>
-
+/**
+ * \brief Action Helper is a helper class which handles action messages
+ *
+ * Components which use the HasActionIF this helper can be used to handle the action messages.
+ * It does handle step messages as well as other answers to action calls. It uses the executeAction function
+ * of its owner as callback. The call of the initialize function is mandatory and it needs a valid messageQueueIF pointer!
+ */
 class HasActionsIF;
 
 class ActionHelper {
 public:
+	/**
+	 * Constructor of the action helper
+	 * @param setOwner Pointer to the owner of the interface
+	 * @param useThisQueue messageQueue to be used, can be set during initialize function as well.
+	 */
 	ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
+
 	virtual ~ActionHelper();
+	/**
+	 * Function to be called from the owner with a new command message
+	 *
+	 * If the message is a valid action message the helper will use the executeAction function from HasActionsIF.
+	 * If the message is invalid or the callback fails a message reply will be send to the sender of the message automatically.
+	 *
+	 * @param command Pointer to a command message received by the owner
+	 * @return HasReturnvaluesIF::RETURN_OK if the message is a action message, CommandMessage::UNKNOW_COMMAND if this message ID is unkown
+	 */
 	ReturnValue_t handleActionMessage(CommandMessage* command);
-	ReturnValue_t initialize();
+	/**
+	 * Helper initialize function. Must be called before use of any other helper function
+	 * @param queueToUse_ Pointer to the messageQueue to be used
+	 * @return Returns RETURN_OK if successful
+	 */
+	ReturnValue_t initialize(MessageQueueIF* queueToUse_);
+	/**
+	 * Function to be called from the owner to send a step message. Success or failure will be determined by the result value.
+	 *
+	 * @param step Number of steps already done
+	 * @param reportTo The messageQueueId to report the step message to
+	 * @param commandId ID of the executed command
+	 * @param result Result of the execution
+	 */
 	void step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	/**
+	 * Function to be called by the owner to send a action completion message
+	 *
+	 * @param reportTo MessageQueueId_t to report the action completion message to
+	 * @param commandId ID of the executed command
+	 * @param result Result of the execution
+	 */
 	void finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	/**
+	 * Function to be called by the owner if an action does report data
+	 *
+	 * @param reportTo MessageQueueId_t to report the action completion message to
+	 * @param replyId ID of the executed command
+	 * @param data Pointer to the data
+	 * @return Returns RETURN_OK if successful, otherwise failure code
+	 */
 	ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId, SerializeIF* data, bool hideSender = false);
+	/**
+	 * Function to setup the MessageQueueIF* of the helper. Can be used to set the messageQueueIF* if
+	 * message queue is unavailable at construction and initialize but must be setup before first call of other functions.
+	 * @param queue Queue to be used by the helper
+	 */
 	void setQueueToUse(MessageQueueIF *queue);
 protected:
-	static const uint8_t STEP_OFFSET = 1;
-	HasActionsIF* owner;
-	MessageQueueIF* queueToUse;
-	StorageManagerIF* ipcStore;
+	static const uint8_t STEP_OFFSET = 1;//!< Increase of value of this per step
+	HasActionsIF* owner;//!< Pointer to the owner
+	MessageQueueIF* queueToUse;//!< Queue to be used as response sender, has to be set with
+	StorageManagerIF* ipcStore;//!< Pointer to an IPC Store, initialized during construction or initialize(MessageQueueIF* queueToUse_) or with setQueueToUse(MessageQueueIF *queue)
+	/**
+	 *Internal function called by handleActionMessage(CommandMessage* command)
+	 *
+	 * @param commandedBy MessageQueueID of Commander
+	 * @param actionId ID of action to be done
+	 * @param dataAddress Address of additional data in IPC Store
+	 */
 	virtual void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, store_address_t dataAddress);
-	void resetHelper();
+	/**
+	 *
+	 */
+	virtual void resetHelper();
 };
 
 #endif /* ACTIONHELPER_H_ */

action/CommandActionHelper.cpp

@@ -5,7 +5,7 @@
 #include <framework/objectmanager/ObjectManagerIF.h>
 
 CommandActionHelper::CommandActionHelper(CommandsActionsIF* setOwner) :
-		owner(setOwner), queueToUse(setOwner->getCommandQueuePtr()), ipcStore(
+		owner(setOwner), queueToUse(NULL), ipcStore(
 				NULL), commandCount(0), lastTarget(0) {
 }
 
@@ -66,11 +66,15 @@ ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
 
 ReturnValue_t CommandActionHelper::initialize() {
 	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore != NULL) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
+	if (ipcStore == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+
+	queueToUse = owner->getCommandQueuePtr();
+	if(queueToUse == NULL){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {

action/HasActionsIF.h

@@ -6,14 +6,36 @@
 #include <framework/action/SimpleActionHelper.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/ipc/MessageQueueIF.h>
+/**
+ * \brief Interface for component which uses actions
+ *
+ * This interface is used to execute actions in the component. Actions, in the sense of this interface, are activities with a well-defined beginning and
+ * end in time. They may adjust sub-states of components, but are not supposed to change
+ * the main mode of operation, which is handled with the HasModesIF described below.
+ *
+ * The HasActionsIF allows components to define such actions and make them available
+ * for other components to use. Implementing the interface is straightforward: There’s a
+ * single executeAction call, which provides an identifier for the action to execute, as well
+ * as arbitrary parameters for input. Aside from direct, software-based
+ * actions, it is used in device handler components as an interface to forward commands to
+ * devices.
+ * Implementing components of the interface are supposed to check identifier (ID) and
+ * parameters and immediately start execution of the action. It is, however, not required to
+ * immediately finish execution. Instead, this may be deferred to a later point in time, at
+ * which the component needs to inform the caller about finished or failed execution.
+ */
 class HasActionsIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_ACTIONS_IF;
-	static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);//!<
 	static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
 	static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
 	static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
 	virtual ~HasActionsIF() { }
+	/**
+	 * Function to get the MessageQueueId_t of the implementing object
+	 * @return MessageQueueId_t of the object
+	 */
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	/**
 	 * Execute or initialize the execution of a certain function.

action/SimpleActionHelper.h

@@ -10,9 +10,10 @@ public:
 	void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
 	void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
 	ReturnValue_t reportData(SerializeIF* data);
-	void resetHelper();
+
 protected:
 	void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, store_address_t dataAddress);
+	virtual  void resetHelper();
 private:
 	bool isExecuting;
 	MessageQueueId_t lastCommander;