Merge remote-tracking branch 'ksat/mueller_framework' into mueller_prototyping

action/ActionHelper.cpp

@@ -1,9 +1,9 @@
 #include <framework/action/ActionHelper.h>
 #include <framework/action/HasActionsIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
+
 ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :
-		owner(setOwner), queueToUse(useThisQueue), ipcStore(
+		owner(setOwner), queueToUse(useThisQueue), ipcStore(nullptr) {
-				NULL) {
 }
 
 ActionHelper::~ActionHelper() {
@@ -22,10 +22,12 @@ ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
 
 ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
 	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == NULL) {
+	if (ipcStore == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	setQueueToUse(queueToUse_);
+	if(queueToUse_ != nullptr) {
+		setQueueToUse(queueToUse_);
+	}
 
 	return HasReturnvaluesIF::RETURN_OK;
 }

action/ActionHelper.h

@@ -38,7 +38,7 @@ public:
 	 * @param queueToUse_ Pointer to the messageQueue to be used
 	 * @return Returns RETURN_OK if successful
 	 */
-	ReturnValue_t initialize(MessageQueueIF* queueToUse_);
+	ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
 	/**
 	 * Function to be called from the owner to send a step message. Success or failure will be determined by the result value.
 	 *

container/FIFO.h

@@ -70,13 +70,8 @@ public:
 	}
 
 	ReturnValue_t pop() {
-	    if(empty()) {
+		T value;
-	        return EMPTY;
+		return this->retrieve(&value);
-	    } else {
-	        readIndex = next(readIndex);
-	        --currentSize;
-	        return HasReturnvaluesIF::RETURN_OK;
-	    }
 	}
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::FIFO_CLASS;

devicehandlers/FixedSlotSequence.cpp

@@ -90,14 +90,8 @@ uint32_t FixedSlotSequence::getLengthMs() const {
 ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
 	    sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
-	    // does check sequence have to be const?
+	    return HasReturnvaluesIF::RETURN_FAILED;
-	    // if I want to check a class, I need the ability to set
-	    // internal class states.
-	    //isEmpty = true;
-	    std::exit(0);
 	}
-    // Iterate through slotList and check successful creation.
-	// Checks if timing is ok (must be ascending) and if all handlers were found.
 	auto slotIt = slotList.begin();
 	uint32_t count = 0;
 	uint32_t time = 0;

devicehandlers/FixedSlotSequence.h

@@ -12,14 +12,19 @@ using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
 
 /**
  * @brief	This class is the representation of a Polling Sequence Table in software.
+ * @details
+ * The FixedSlotSequence object maintains the dynamic execution of
+ * device handler objects.
  *
- * @details	The FixedSlotSequence object maintains the dynamic execution of device handler objects.
+ * The main idea is to create a list of device handlers, to announce all
- * 			The main idea is to create a list of device handlers, to announce all handlers to the
+ * handlers to thepolling sequence and to maintain a list of
- * 			polling sequence and to maintain a list of polling slot objects. This slot list represents the
+ * polling slot objects. This slot list represents the Polling Sequence Table
- * 			Polling Sequence Table in software. Each polling slot contains information to indicate when and
+ * in software.
- * 			which device handler shall be executed within a given polling period.
+ *
- * 			The sequence is then executed by iterating through this slot list.
+ * Each polling slot contains information to indicate when and
- * 			Handlers are invoking by calling a certain function stored in the handler list.
+ * which device handler shall be executed within a given polling period.
+ * The sequence is then executed by iterating through this slot list.
+ * Handlers are invoking by calling a certain function stored in the handler list.
  */
 class FixedSlotSequence {
 public:
@@ -112,7 +117,13 @@ public:
 	 */
 	SlotListIter current;
 
-	virtual ReturnValue_t checkSequence() const;
+	/**
+	 * Iterate through slotList and check successful creation.
+	 * Checks if timing is ok (must be ascending) and if all handlers were found.
+	 * @return
+	 */
+	ReturnValue_t checkSequence() const;
+
 protected:
 
 	/**

objectmanager/ObjectManagerIF.h

@@ -12,6 +12,7 @@
 #include <config/objects/systemObjectList.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 /**
  * @brief	This class provides an interface to the global object manager.
@@ -24,9 +25,12 @@
  */
 class ObjectManagerIF : public HasReturnvaluesIF {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
-	static const ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
+	static constexpr ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
-	static const ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 );
+	static constexpr ReturnValue_t INTERNAL_ERR_REPORTER_UNINIT = MAKE_RETURN_CODE( 4 );
+
 protected:
 	/**
 	 * @brief	This method is used to hide the template-based get call from
@@ -79,16 +83,21 @@ public:
 };
 
 
-/*Documentation can be found in the class method declaration above.*/
-template <typename T>
-T* ObjectManagerIF::get( object_id_t id ) {
-	SystemObjectIF* temp = this->getSystemObject(id);
-	return dynamic_cast<T*>(temp);
-}
-
 /**
  * @brief	This is the forward declaration of the global objectManager instance.
  */
 extern ObjectManagerIF *objectManager;
 
+/*Documentation can be found in the class method declaration above.*/
+template <typename T>
+T* ObjectManagerIF::get( object_id_t id ) {
+	if(objectManager == nullptr) {
+		sif::error << "ObjectManagerIF: Global object manager has not "
+				"been initialized yet!" << std::endl;
+		std::exit(0);
+	}
+	SystemObjectIF* temp = this->getSystemObject(id);
+	return dynamic_cast<T*>(temp);
+}
+
 #endif /* OBJECTMANAGERIF_H_ */

osal/FreeRTOS/FixedTimeslotTask.cpp

@@ -57,10 +57,10 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
-	if (objectManager->get<ExecutableObjectIF>(componentId) != NULL) {
+	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
 		if(slotTimeMs == 0) {
-			// TODO: FreeRTOS throws errors for zero values.
+			// FreeRTOS throws a sanity error for zero values, so we set
-			// maybe there is a better solution than this.
+			// the time to one millisecond.
 			slotTimeMs = 1;
 		}
 		pst.addSlot(componentId, slotTimeMs, executionStep, this);

osal/linux/FixedTimeslotTask.cpp

@@ -42,14 +42,14 @@ uint32_t FixedTimeslotTask::getPeriodMs() const {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
-	if (!objectManager->get<ExecutableObjectIF>(componentId)) {
+	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		sif::error << "Component " << std::hex << componentId
+		pst.addSlot(componentId, slotTimeMs, executionStep, this);
-				   << " not found, not adding it to pst" << std::endl;
+		return HasReturnvaluesIF::RETURN_OK;
-		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
-	pst.addSlot(componentId, slotTimeMs, executionStep, this);
+	sif::error << "Component " << std::hex << componentId <<
-	return HasReturnvaluesIF::RETURN_OK;
+			" not found, not adding it to pst" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 ReturnValue_t FixedTimeslotTask::checkSequence() const {

osal/rtems/PollingTask.cpp

@@ -66,10 +66,16 @@ ReturnValue_t PollingTask::startTask() {
 	}
 }
 
-ReturnValue_t PollingTask::addSlot(object_id_t componentId, uint32_t slotTimeMs,
+ReturnValue_t PollingTask::addSlot(object_id_t componentId,
-		int8_t executionStep) {
+		uint32_t slotTimeMs, int8_t executionStep) {
-	pst.addSlot(componentId, slotTimeMs, executionStep, this);
+	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-	return HasReturnvaluesIF::RETURN_OK;
+		pst.addSlot(componentId, slotTimeMs, executionStep, this);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	sif::error << "Component " << std::hex << componentId <<
+			" not found, not adding it to pst" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 uint32_t PollingTask::getPeriodMs() const {

returnvalues/HasReturnvaluesIF.h

@@ -13,9 +13,7 @@ class HasReturnvaluesIF {
 public:
 	static const ReturnValue_t RETURN_OK = 0;
 	static const ReturnValue_t RETURN_FAILED = 0xFFFF;
-	virtual ~HasReturnvaluesIF() {
+	virtual ~HasReturnvaluesIF() {}
-	}
-
 };
 
 #endif /* HASRETURNVALUESIF_H_ */

storagemanager/LocalPool.tpp

@@ -242,8 +242,8 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
 	}
 	internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
 			objects::INTERNAL_ERROR_REPORTER);
-	if (internalErrorReporter == NULL){
+	if (internalErrorReporter == nullptr){
-		return RETURN_FAILED;
+		return ObjectManagerIF::INTERNAL_ERR_REPORTER_UNINIT;
 	}
 
 	//Check if any pool size is large than the maximum allowed.
@@ -251,7 +251,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
 		if (element_sizes[count] >= STORAGE_FREE) {
 			sif::error << "LocalPool::initialize: Pool is too large! "
 					"Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
-			return RETURN_FAILED;
+			return StorageManagerIF::POOL_TOO_LARGE;
 		}
 	}
 	return RETURN_OK;

storagemanager/StorageManagerIF.h

@@ -71,6 +71,7 @@ public:
 	static const ReturnValue_t ILLEGAL_STORAGE_ID = MAKE_RETURN_CODE(3); //!< This return code indicates that data was requested with an illegal storage ID.
 	static const ReturnValue_t DATA_DOES_NOT_EXIST = MAKE_RETURN_CODE(4); //!< This return code indicates that the requested ID was valid, but no data is stored there.
 	static const ReturnValue_t ILLEGAL_ADDRESS = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t POOL_TOO_LARGE = MAKE_RETURN_CODE(6); //!< Pool size too large on initialization.
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
 	static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);