/ - Diff - AMiRo-OS - Research for Cognitive Interaction

Revision 982056f7

     /*
     µRtWare is a lightweight publish/subscribe middleware for real-time
     applications. It was developed as part of the software habitat for the
     Autonomous Mini Robot [1] (AMiRo) but can be used for other purposes as well.
     Copyright (C) 2018..2020  Thomas Schöpping et al.
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation, either version 3 of the License, or
     (at your option) any later version.
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #ifndef URTWARE_BASESUBSCRIBER_H
     #define URTWARE_BASESUBSCRIBER_H
     #include <urt_osal.h>
     #include <urt_confcheck.h>
     /******************************************************************************/
     /* CONSTANTS                                                                  */
     /******************************************************************************/
     /******************************************************************************/
     /* SETTINGS                                                                   */
     /******************************************************************************/
     /******************************************************************************/
     /* CHECKS                                                                     */
     /******************************************************************************/
     /******************************************************************************/
     /* DATA STRUCTURES AND TYPES                                                  */
     /******************************************************************************/
     struct urt_topic;
     /**
      * @brief  Base subscriber
      * @details The base subscriber is included in each specialized subscriber
      */
     typedef struct urt_basesubscriber
+    {
       struct urt_topic* topic;
       urt_osEventListener_t evtListener;
       urt_message_t* lastMessage;
       urt_osTime_t lastMessageTime;
       #if (URT_CFG_PUBSUB_PROFILING)
         uint64_t sumLatencies;
         uint64_t numMessagesReceived;
       #endif /* URT_CFG_PUBSUB_PROFILING */
     }urt_basesubscriber_t;
     /******************************************************************************/
     /* MACROS                                                                     */
     /******************************************************************************/
     /******************************************************************************/
     /* EXTERN DECLARATIONS                                                        */
     /******************************************************************************/
     /******************************************************************************/
     /* INLINE FUNCTIONS                                                           */
     /******************************************************************************/
     #endif /* URTWARE_BASESUBSCRIBER_H */

       urt_service_t urtCoreGetService(urt_serviceid_t id);
     #endif /* URT_CFG_RPC_ENABLED */
     #if (URT_CFG_PUBSUB_QOS_DEADLINECHECKS)
       urtCoreCallbackDefault(void* params)
     #endif /* URT_CFG_PUBSUB_QOS_DEADLINECHECKS */
     #if defined(__cplusplus)
+    }
     #endif /* defined(__cplusplus) */

     #define URTWARE_SUBSCRIBER_H
     #include <urtware.h>
     #include <urt_basesubscriber.h>
     /******************************************************************************/
     /* CONSTANTS                                                                  */
-...
     /******************************************************************************/
     /**
      * @brief  Base subscriber
      * @details The base subscriber is included in each specialized subscriber
      */
     typedef struct urt_basesubscriber
+    {
       urt_topic_t* topic;
       urt_osEventListener_t evtListener;
       urt_message_t* lastMessage;
       urt_osTime_t lastMessageTime;
       #if (URT_CFG_PUBSUB_PROFILING)
         uint64_t sumLatencies;
         uint64_t numMessagesReceived;
       #endif /* URT_CFG_PUBSUB_PROFILING */
     }urt_basesubscriber_t;
     /**
      * @brief  nrt subscriber
      */
     typedef struct urt_nrtsubscriber

       urt_message_t mandatoryMessage;
       urt_message_t* latestMessage;
       #if (URT_CFG_PUBSUB_QOS_RATECHECKS)
         struct urt_hrtsubscriber* hrtSubscribers;
         urt_hrtsubscriber_t* hrtSubscribers;
         urt_osTimer_t qosRateTimer;
       #endif /* URT_CFG_PUBSUB_QOS_RATECHECKS */
       #if (URT_CFG_PUBSUB_PROFILING)

     */
     #include <urtware.h>
     #include <stdio.h>
     /******************************************************************************/
     /* LOCAL DEFINITIONS                                                          */
-...
     /* LOCAL FUNCTIONS                                                            */
     /******************************************************************************/
     void urtFetchMessage ()
     void urtFetchMessage (urt_message_t* message, urt_nrtsubscriber_t* subscriber, void* const payload, size_t bytes)
+    {
         //TODO: Update message pointer
         //TODO: Copy message origin time
         //TODO: Copy message payload
       subscriber->base.lastMessage = message;
       *subscriber->base.lastMessageTime = message->originTime;
       memcpy(message->payload, payload, bytes);
+    }
     urt_message_t* urtFindOldestMessage(urt_message_t* oldestMessage)
-...
+      }
+    }
     void urtContributeMessages(urt_message_t* messages)
+    {
       urt_message_t* lastMessageContribute = messages;
       while (lastMessageContribute->next)
+      {
         lastMessageContribute = lastMessageContribute->next;
+      }
       lastMessageContribute->next = topic->latestMessage->next;
       topic->latestMessage->next = messages;
+    }
     /******************************************************************************/
     /* EXPORTED FUNCTIONS                                                         */
     /******************************************************************************/
-...
       urtDebugAssert(subscriber);
       urtDebugAssert(topic);
       if (!subscriber->base.topic)
           return URT_STATUS_SUBSCRIBE_TOPICSET;
       if (!subscriber->base.topic) {
         return URT_STATUS_SUBSCRIBE_TOPICSET;
+      }
       subscriber->base.topic = topic;
       urtMutexLock(topic->lock);
       if (messages)
+      {
         urt_message_t* lastMessageContribute = messages;
         while (lastMessageContribute->next)
+        {
             lastMessageContribute = lastMessageContribute->next;
+        }
         lastMessageContribute->next = topic->latestMessage->next;
         topic->latestMessage->next = messages;
       if (messages) {
         urtContributeMessages(messages);
+      }
       subscriber->base.lastMessage = topic->latestMessage;
-...
      *          Returns URT_STATUS_FETCH_NOTOPIC if the subscriber is not associated to a topic.
      *          Retruns URT_STATUS_FETCH_NOMESSAGE if there is no new message to fetch.
      */
     urt_status_t urtNrtSubscriberFetchNextMessage (urt_nrtsubscriber_t* subscriber, void* payload, size_t bytes, urt_delay_t* latency)
     urt_status_t urtNrtSubscriberFetchNextMessage (urt_nrtsubscriber_t* subscriber, void* const payload, size_t bytes, urt_delay_t* latency)
+    {
       urtDebugAssert(subscriber);
       if (!subscriber->base.topic)
           return URT_STATUS_FETCH_NOTOPIC;
       if (!subscriber->base.topic) {
         return URT_STATUS_FETCH_NOTOPIC;
+      }
       urtMutexLock(subscriber->base.topic->lock);
       urt_message_t* messageTemp = subscriber->base.lastMessage;
       if(messageTemp->originTime == subscriber->base.lastMessageTime)
+      {
         if (subscriber->base.lastMessage->next->originTime > subscriber->base.lastMessageTime)
+        {
       urt_message_t* oldestMessage = subscriber->base.lastMessage;
       if(oldestMessage->originTime == subscriber->base.lastMessageTime) {
         if (subscriber->base.lastMessage->next->originTime > subscriber->base.lastMessageTime) {
           urtMutexUnlock(subscriber->base.topic->lock);
           return URT_STATUS_FETCH_NOMESSAGE;
+        }
         messageTemp = messageTemp->next;
         oldestMessage = oldestMessage->next;
+      }
       else
+      {
         messageTemp = urtFindOldestMessage(messageTemp->next);
       else {
         oldestMessage = urtFindOldestMessage(oldestMessage->next);
+      }
       urtFetchMessage();
       urtFetchMessage(oldestMessage, subscriber, payload, bytes);
       if (URT_CFG_PUBSUB_PROFILING == true || latency) {
         uint64_t calculatedLatency = urtTimeNow() - oldestMessage->originTime;
       uint64_t calculatedLatency = NULL; //TODO: Calculate message latency
     #if(URT_CFG_PUBSUB_PROFILING == true)
       subscriber->base.sumLatencies += calculatedLatency;
       if (calculatedLatency < subscriber->minLatency)
+      {
       if (calculatedLatency < subscriber->minLatency) {
         subscriber->minLatency = calculatedLatency;
+      }
       else if (calculatedLatency > subscriber->maxLatency)
+      {
       else if (calculatedLatency > subscriber->maxLatency) {
         subscriber->maxLatency = calculatedLatency;
+      }
     #endif /* URT_CFG_PUBSUB_PROFILING */
       bool temp = false;
       if (temp/*optional latency output argument given*/)
+      {
         latency = calculatedLatency;
         if (latency) {
           latency = calculatedLatency;
+        }
+      }
     #if (URT_CFG_PUBSUB_PROFILING == true)
-...
      *          Returns URT_STATUS_FETCH_NOTOPIC if the subscriber is not associated to a topic.
      *          Returns URT_STATUS_FETCH_NOMESSAGE if there is no new message to fetch.
      */
     urt_status_t urtNrtSubscriberFetchLatestMessage (urt_nrtsubscriber_t* subscriber, void* payload, size_t bytes, urt_delay_t* latency) {
     urt_status_t urtNrtSubscriberFetchLatestMessage (urt_nrtsubscriber_t* subscriber, void* const payload, size_t bytes, urt_delay_t* latency) {
       urtDebugAssert(subscriber);
       if (!subscriber->base.topic)
-...
         return URT_STATUS_FETCH_NOMESSAGE;
+      }
       urtFetchMessage();
       urtFetchMessage(lastMessage, subscriber, payload, bytes);
       if (URT_CFG_PUBSUB_PROFILING == true || latency) {
         uint64_t calculatedLatency = urtTimeNow() - lastMessage->originTime;
       uint64_t calculatedLatency = NULL; //TODO: Calculate message latency
     #if(URT_CFG_PUBSUB_PROFILING == true)
       subscriber->base.sumLatencies += calculatedLatency;
       if (calculatedLatency < subscriber->minLatency)
+      {
       if (calculatedLatency < subscriber->minLatency) {
         subscriber->minLatency = calculatedLatency;
+      }
       else if (calculatedLatency > subscriber->maxLatency)
+      {
       else if (calculatedLatency > subscriber->maxLatency) {
         subscriber->maxLatency = calculatedLatency;
+      }
     #endif /* URT_CFG_PUBSUB_PROFILING */
       bool temp = false;
       if (temp/*optional latency output argument given*/)
+      {
         latency = calculatedLatency;
         if (latency) {
           latency = calculatedLatency;
+        }
+      }
       urtMutexUnlock(subscriber->base.topic->lock);
-...
       urtMutexLock(topic->lock);
       if (messages)
+      {
         urt_message_t* lastMessageContribute = messages;
         while (lastMessageContribute->next)
+        {
             lastMessageContribute = lastMessageContribute->next;
+        }
         lastMessageContribute->next = topic->latestMessage->next;
         topic->latestMessage->next = messages;
         urtContributeMessages(messages);
+      }
       subscriber->base.lastMessage = topic->latestMessage;
-...
      *          Returns URT_STATUS_FETCH_NOTOPIC if the subscriber is not associated to a topic.
      *          Returns URT_STATUS_FETCH_NOMESSAGE if there is no new message to fetch.
      */
     urt_status_t urtSrtSubscriberFetchNextMessage(urt_srtsubscriber_t* subscriber, void* payload,
     urt_status_t urtSrtSubscriberFetchNextMessage(urt_srtsubscriber_t* subscriber, void* const payload,
                                                   size_t bytes, urt_delay_t* latency)
+    {
       urtDebugAssert(subscriber);
-...
       urtMutexLock(subscriber->base.topic->lock);
       urt_message_t* messageTemp = subscriber->base.lastMessage;
       if(messageTemp->originTime == subscriber->base.lastMessageTime)
       urt_message_t* oldestMessage = subscriber->base.lastMessage;
       if(oldestMessage->originTime == subscriber->base.lastMessageTime)
+      {
         if (subscriber->base.lastMessage->next->originTime > subscriber->base.lastMessageTime)
+        {
           urtMutexUnlock(subscriber->base.topic->lock);
           return URT_STATUS_FETCH_NOMESSAGE;
+        }
         messageTemp = messageTemp->next;
         oldestMessage = oldestMessage->next;
+      }
       else
+      {
         messageTemp = urtFindOldestMessage(messageTemp->next);
         oldestMessage = urtFindOldestMessage(oldestMessage->next);
+      }
       urtFetchMessage();
       urtFetchMessage(oldestMessage, subscriber, payload, bytes);
       if (URT_CFG_PUBSUB_PROFILING == true || latency) {
         uint64_t calculatedLatency = urtTimeNow() - oldestMessage->originTime;
       uint64_t calculatedLatency = NULL; //TODO: Calculate message latency
     #if(URT_CFG_PUBSUB_PROFILING == true)
       subscriber->base.sumLatencies += calculatedLatency;
       if (calculatedLatency < subscriber->minLatency)
+      {
       if (calculatedLatency < subscriber->minLatency) {
         subscriber->minLatency = calculatedLatency;
+      }
       else if (calculatedLatency > subscriber->maxLatency)
+      {
       else if (calculatedLatency > subscriber->maxLatency) {
         subscriber->maxLatency = calculatedLatency;
+      }
     #endif /* URT_CFG_PUBSUB_PROFILING */
       bool temp = false;
       if (temp/*optional latency output argument given*/)
+      {
         latency = calculatedLatency;
         if (latency) {
           latency = calculatedLatency;
+        }
+      }
     #if (URT_CFG_PUBSUB_PROFILING == true)
-...
      *          Returns URT_STATUS_FETCH_NOTOPIC if the subscriber is not associated to a topic.
      *          Returns URT_STATUS_FETCH_NOMESSAGE if there is no new message to fetch.
      */
     urt_status_t urtSrtSubscriberFetchLatestMessage(urt_srtsubscriber_t* subscriber, void* payload,
     urt_status_t urtSrtSubscriberFetchLatestMessage(urt_srtsubscriber_t* subscriber, void* const payload,
                                                     size_t bytes, urt_delay_t* latency)
+    {
       urtDebugAssert(subscriber);
       if (!subscriber->base.topic)
           return URT_STATUS_FETCH_NOTOPIC;
       if (!subscriber->base.topic) {
         return URT_STATUS_FETCH_NOTOPIC;
+      }
       urtMutexLock(subscriber->base.topic->lock);
       urt_message_t* lastMessage = urtFindLatestMessage(subscriber->base.lastMessage);
-...
         return URT_STATUS_FETCH_NOMESSAGE;
+      }
       urtFetchMessage();
       urtFetchMessage(lastMessage, subscriber, payload, bytes);
       if (URT_CFG_PUBSUB_PROFILING == true || latency) {
         uint64_t calculatedLatency = urtTimeNow() - lastMessage->originTime;
       uint64_t calculatedLatency = NULL; //TODO: Calculate message latency
     #if(URT_CFG_PUBSUB_PROFILING == true)
       subscriber->base.sumLatencies += calculatedLatency;
       if (calculatedLatency < subscriber->minLatency)
+      {
       if (calculatedLatency < subscriber->minLatency) {
         subscriber->minLatency = calculatedLatency;
+      }
       else if (calculatedLatency > subscriber->maxLatency)
+      {
       else if (calculatedLatency > subscriber->maxLatency) {
         subscriber->maxLatency = calculatedLatency;
+      }
     #endif /* URT_CFG_PUBSUB_PROFILING */
       bool temp = false;
       if (temp/*optional latency output argument given*/)
+      {
         latency = calculatedLatency;
         if (latency) {
           latency = calculatedLatency;
+        }
+      }
       urtMutexUnlock(subscriber->base.topic->lock);
-...
       urtMutexLock(topic->lock);
       if (messages)
+      {
         urt_message_t* lastMessageContribute = messages;
         while (lastMessageContribute->next)
+        {
           lastMessageContribute = lastMessageContribute->next;
+        }
         lastMessageContribute->next = topic->latestMessage->next;
         topic->latestMessage->next = messages;
         urtContributeMessages(messages);
+      }
       subscriber->base.lastMessage = topic->latestMessage;
-...
      *          Returns URT_STATUS_FETCH_NOTOPIC if the subscriber is not associated to a topic.
      *          Returns URT_STATUS_FETCH_NOMESSAGE if there is no new message to fetch.
      */
     urt_status_t urtFrtSubscriberFetchNextMessage(urt_frtsubscriber_t* subscriber, void* payload,
     urt_status_t urtFrtSubscriberFetchNextMessage(urt_frtsubscriber_t* subscriber, void* const payload,
                                                   size_t bytes, urt_delay_t* latency)
+    {
       urtDebugAssert(subscriber);
-...
       urtMutexLock(subscriber->base.topic->lock);
       urt_message_t* messageTemp = subscriber->base.lastMessage;
       if(messageTemp->originTime == subscriber->base.lastMessageTime)
       urt_message_t* oldestMessage = subscriber->base.lastMessage;
       if(oldestMessage->originTime == subscriber->base.lastMessageTime)
+      {
         if (subscriber->base.lastMessage->next->originTime > subscriber->base.lastMessageTime)
+        {
           urtMutexUnlock(subscriber->base.topic->lock);
           return URT_STATUS_FETCH_NOMESSAGE;
+        }
         messageTemp = messageTemp->next;
         oldestMessage = oldestMessage->next;
+      }
       else
+      {
         messageTemp = urtFindOldestMessage(messageTemp->next);
         oldestMessage = urtFindOldestMessage(oldestMessage->next);
+      }
       urtFetchMessage();
       urtFetchMessage(oldestMessage, subscriber, payload, bytes);
       uint64_t calculatedLatency = NULL; //TODO: Calculate message latency
     #if(URT_CFG_PUBSUB_PROFILING == true)
       if (URT_CFG_PUBSUB_PROFILING == true || URT_CFG_PUBSUB_QOS_JITTERCHECKS == true || latency) {
         uint64_t calculatedLatency = urtTimeNow() - oldestMessage->originTime;
     #if(URT_CFG_PUBSUB_PROFILING == true && URT_CFG_PUBSUB_QOS_JITTERCHECKS == false)
       subscriber->base.sumLatencies += calculatedLatency;
       if (calculatedLatency < subscriber->minLatency) {
         subscriber->minLatency = calculatedLatency;
+      }
       else if (calculatedLatency > subscriber->maxLatency) {
         subscriber->maxLatency = calculatedLatency;
+      }
     #endif /* URT_CFG_PUBSUB_PROFILING */
     #if (URT_CFG_PUBSUB_PROFILING == true && URT_CFG_PUBSUB_QOS_JITTERCHECKS == true) //TODO: Both must be true? otherwise jitter does not exist
       if (calculatedLatency < subscriber->minLatency && calculatedLatency > subscriber->minLatency-subscriber->maxJitter)
+      {
     #if (URT_CFG_PUBSUB_QOS_JITTERCHECKS == true)
       if (calculatedLatency < subscriber->minLatency && calculatedLatency > subscriber->minLatency - subscriber->maxJitter) {
         subscriber->minLatency = calculatedLatency;
+      }
       else if (calculatedLatency > subscriber->maxLatency && calculatedLatency < subscriber->maxLatency+subscriber->maxJitter)
+      {
       else if (calculatedLatency > subscriber->maxLatency && calculatedLatency < subscriber->maxLatency + subscriber->maxJitter) {
         subscriber->maxLatency = calculatedLatency;
+      }
     #endif /* URT_CFG_PUBSUB_PROFILING && URT_CFG_PUBSUB_QOS_JITTERCHECKS */
       else if (calculatedLatency > subscriber->maxLatency || calculatedLatency < subscriber->minLatency) {
         urtMutexUnlock(subscriber->base.topic);
         return URT_STATUS_JITTERVIOLATION;
+      }
     #endif /* URT_CFG_PUBSUB_QOS_JITTERCHECKS */
       bool temp = false;
       if (temp/*optional latency output argument given*/)
+      {
         latency = calculatedLatency;
         if (latency) {
           latency = calculatedLatency;
+        }
+      }
     #if (URT_CFG_PUBSUB_PROFILING == true)
-...
     #endif /* URT_CFG_PUBSUB_PROFILING */
       urtMutexUnlock(subscriber->base.topic->lock);
       return URT_STATUS_OK; //TODO: or urt_status_jitterviolation
       return URT_STATUS_OK;
+    }
     /**
-...
      *          Returns URT_STATUS_FETCH_NOTOPIC if the subscriber is not associated to a topic.
      *          Returns URT_STATUS_FETCH_NOMESSAGE if there is no new message to fetch.
      */
     urt_status_t urtFrtSubscriberFetchLatestMessage(urt_frtsubscriber_t* subscriber, void* payload,
     urt_status_t urtFrtSubscriberFetchLatestMessage(urt_frtsubscriber_t* subscriber, void* const payload,
                                                     size_t bytes, urt_delay_t* latency)
+    {
       urtDebugAssert(subscriber);
-...
         return URT_STATUS_FETCH_NOMESSAGE;
+      }
       urtFetchMessage();
       urtFetchMessage(lastMessage, subscriber, payload, bytes);
       uint64_t calculatedLatency = NULL; //TODO: Calculate message latency
     #if(URT_CFG_PUBSUB_PROFILING == true)
       if (URT_CFG_PUBSUB_PROFILING == true || URT_CFG_PUBSUB_QOS_JITTERCHECKS == true || latency) {
         uint64_t calculatedLatency = urtTimeNow() - oldestMessage->originTime;
     #if(URT_CFG_PUBSUB_PROFILING == true && URT_CFG_PUBSUB_QOS_JITTERCHECKS == false)
       subscriber->base.sumLatencies += calculatedLatency;
       if (calculatedLatency < subscriber->minLatency) {
         subscriber->minLatency = calculatedLatency;
+      }
       else if (calculatedLatency > subscriber->maxLatency) {
         subscriber->maxLatency = calculatedLatency;
+      }
     #endif /* URT_CFG_PUBSUB_PROFILING */
     #if (URT_CFG_PUBSUB_PROFILING == true && URT_CFG_PUBSUB_QOS_JITTERCHECKS == true) //TODO: Both must be true? otherwise jitter does not exist
       if (calculatedLatency < subscriber->minLatency && calculatedLatency > subscriber->minLatency-subscriber->maxJitter)
+      {
     #if (URT_CFG_PUBSUB_QOS_JITTERCHECKS == true)
       if (calculatedLatency < subscriber->minLatency && calculatedLatency > subscriber->minLatency - subscriber->maxJitter) {
         subscriber->minLatency = calculatedLatency;
+      }
       else if (calculatedLatency > subscriber->maxLatency && calculatedLatency < subscriber->maxLatency+subscriber->maxJitter)
+      {
       else if (calculatedLatency > subscriber->maxLatency && calculatedLatency < subscriber->maxLatency + subscriber->maxJitter) {
         subscriber->maxLatency = calculatedLatency;
+      }
     #endif /* URT_CFG_PUBSUB_PROFILING && URT_CFG_PUBSUB_QOS_JITTERCHECKS */
       else if (calculatedLatency > subscriber->maxLatency || calculatedLatency < subscriber->minLatency) {
         urtMutexUnlock(subscriber->base.topic);
         return URT_STATUS_JITTERVIOLATION;
+      }
     #endif /* URT_CFG_PUBSUB_QOS_JITTERCHECKS */
       bool temp = false;
       if (temp/*optional latency output argument given*/)
+      {
         latency = calculatedLatency;
         if (latency) {
           latency = calculatedLatency;
+        }
+      }
       urtMutexUnlock(subscriber->base.topic->lock);
-...
+    {
       urtDebugAssert(subscriber);
       if (subscriber->base.topic)
+      {
         urtMutexLock(topic->lock);
         urtEventUnregister(subscriber->base.topic->evtSource, subscriber->base.evtListener);
         //TODO: decrement topic's HRT counter
       if (!subscriber->base.topic) {
         return URT_STATUS_UNSUBSCRIBE_NOTOPIC;
+      }
     #if (URT_CFG_PUBSUB_PROFILING == true)
       urtMutexLock(topic->lock);
     #endif /* URT_CFG_PUBSUB_PROFILING */
       urtEventUnregister(subscriber->base.topic->evtSource, subscriber->base.evtListener);
     # if (URT_CFG_PUBSUB_PROFILING == true)
         subscriber->base.topic->numSubscribers--;
       subscriber->base.topic->numSubscribers--;
     # endif /* URT_CFG_PUBSUB_PROFILING */
     //Hier weiter
     # if (URT_CFG_PUBSUB_PROFILING == true)
         urtMutexUnlock(topic->lock);
       urtMutexUnlock(topic->lock);
     # endif /* URT_CFG_PUBSUB_PROFILING */
         subscriber->base.topic = NULL;
         subscriber->base.lastMessage = NULL;
         subscriber->base.lastMessageTime = 0;
         return URT_STATUS_OK;
+      }
       return URT_STATUS_UNSUBSCRIBE_NOTOPIC;
       subscriber->base.topic = NULL;
       subscriber->base.lastMessage = NULL;
       subscriber->base.lastMessageTime = 0;
       return URT_STATUS_OK;
+    }
-...
       urtMutexLock(topic->lock);
       if (messages)
+      {
         urt_message_t* lastMessageContribute = messages;
         while (lastMessageContribute->next)
+        {
           lastMessageContribute = lastMessageContribute->next;
+        }
         lastMessageContribute->next = topic->latestMessage->next;
         topic->latestMessage->next = messages;
         urtContributeMessages(messages);
+      }
       subscriber->base.lastMessage = topic->latestMessage;
-...
      *          Returns URT_STATUS_FETCH_NOTOPIC if the subscriber is not associated to a topic.
      *          Returns URT_STATUS_FETCH_NOMESSAGE if there is no new message to fetch.
      */
     urt_status_t urtHrtSubscriberFetchNextMessage(urt_hrtsubscriber_t* subscriber, void* payload,
     urt_status_t urtHrtSubscriberFetchNextMessage(urt_hrtsubscriber_t* subscriber, void* const payload,
                                                   size_t bytes, urt_delay_t* latency)
+    {
       urtDebugAssert(subscriber);
       if (!subscriber->base.topic)
           return URT_STATUS_FETCH_NOTOPIC;
       if (!subscriber->base.topic) {
         return URT_STATUS_FETCH_NOTOPIC;
+      }
       urtMutexLock(subscriber->base.topic->lock);
       urt_message_t* messageTemp = subscriber->base.lastMessage;
-...
+      }
       messageTemp = messageTemp->next;
       uint64_t calculatedLatency = NULL; //TODO: Calculate message latency
     #if (URT_CFG_PUBSUB_PROFILING == true)
       if (URT_CFG_PUBSUB_PROFILING == true || latency) {
         uint64_t calculatedLatency = urtTimeNow() - messageTemp->originTime;
     #if(URT_CFG_PUBSUB_PROFILING == true)
       subscriber->base.sumLatencies += calculatedLatency;
       if (calculatedLatency < subscriber->minLatency) {
         subscriber->minLatency = calculatedLatency;
+      }
       else if (calculatedLatency > subscriber->maxLatency) {
         subscriber->maxLatency = calculatedLatency;
+      }
     #endif /* URT_CFG_PUBSUB_PROFILING */
       bool temp = false;
       if (temp /* optional latency output argument given */)
+      {
         latency = calculatedLatency
         if (latency) {
           latency = calculatedLatency;
+        }
+      }
       subscriber->base.lastMessage->numHrtConsumersLeft--;
-...
       subscriber->base->numMessagesReceived++;
     #endif /* URT_CFG_PUBSUB_PROFILING */
     #if (URT_CFG_PUBSUB_QOS_JITTERCHECKS == true || URT_CFG_PUBSUB_PROFILING == true)
       if (temp /*latency is within allowed jitter range*/)
+      {
         if (calculatedLatency < subscriber->minLatency)
+        {
           subscriber->minLatency = calculatedLatency;
+        }
         else if (calculatedLatency > subscriber->maxLatency)
+        {
           subscriber->maxLatency = calculatedLatency;
+        }
+      }
       else
+      {
     #if (URT_CFG_PUBSUB_QOS_JITTERCHECKS == true)
         urtMutexUnlock(subscriber->base.topic->lock);
       if (calculatedLatency < subscriber->minLatency && calculatedLatency > subscriber->minLatency - subscriber->maxJitter) {
         subscriber->minLatency = calculatedLatency;
+      }
       else if (calculatedLatency > subscriber->maxLatency && calculatedLatency < subscriber->maxLatency + subscriber->maxJitter) {
         subscriber->maxLatency = calculatedLatency;
+      }
       else if (calculatedLatency > subscriber->maxLatency || calculatedLatency < subscriber->minLatency) {
         urtMutexUnlock(subscriber->base.topic);
         urtCoreStopNodes(URT_STATUS_JITTERVIOLATION);
         return URT_STATUS_JITTERVIOLATION;
+      }
     #endif /* URT_CFG_PUBSUB_QOS_JITTERCHECKS */
     #if (URT_CFG_PUBSUB_PROFILING == true && URT_CFG_PUBSUB_QOS_JITTERCHECKS == false)
       if (calculatedLatency < subscriber->minLatency) {
         subscriber->minLatency = calculatedLatency;
+      }
     #endif /* URT_CFG_PUBSUB_QOS_JITTERCHECKS || URT_CFG_PUBSUB_PROFILING */
       else if (calculatedLatency > subscriber->maxLatency) {
         subscriber->maxLatency = calculatedLatency;
+      }
     #endif /* URT_CFG_PUBSUB_PROFILING */
       urtFetchMessage();
       urtFetchMessage(messageTemp, subscriber, payload, bytes);
     #if (URT_CFG_PUBSUB_QOS_DEADLINECHECKS == true)
       if (messageTemp->next->originTime < messageTemp->originTime)
+      {
         //TODO: update qos deadliner timer wrt. next message
         //TODO: first reset?! (when ... set)
         urtTimerSet(subscriber->qosDeadlineTimer, subscriber->deadlineOffset, urtCoreCallbackDefault, NULL);
+      }
       else
+      {
         //TODO: reset qos deadline timer
         urtTimerReset(subscriber->qosDeadlineTimer);
+      }
     #endif /* URT_CFG_PUBSUB_QOS_DEADLINECHECKS */
-...
      *          Returns URT_STATUS_FETCH_NOTOPIC if the subscriber is not associated to a topic.
      *          Returns URT_STATUS_FETCH_NOMESSAGE if there is no new message to fetch.
      */
     urt_status_t urtHrtSubscriberFetchLatestMessage(urt_hrtsubscriber_t* subscriber, void* payload,
                                                     size_t bytes, urt_delay_t* latency){return URT_STATUS_OK;}
     urt_status_t urtHrtSubscriberFetchLatestMessage(urt_hrtsubscriber_t* subscriber, void* const payload,
                                                     size_t bytes, urt_delay_t* latency)
+    {
       if (!subscriber->base.topic) {
         return URT_STATUS_FETCH_NOTOPIC;
+      }
       urtMutexLock(subscriber->base.topic->lock);
       urt_message_t* lastMessage = subscriber->base.lastMessage;
       bool hrtZero = false;
       while (lastMessage->next->originTime < lastMessage->originTime) {
         lastMessage = lastMessage->next;
         lastMessage->numHrtConsumersLeft--;
         if (lastMessage->numHrtConsumersLeft == 0) {
             hertZero = true;
+        }
     #if (URT_CFG_PUBSUB_PROFILING == true)
         lastMessage->numConsumersLeft--;
         subscriber->base.numMessagesReceived++;
     #endif /* URT_CFG_PUBSUB_PROFILING */
     #if (URT_CFG_PUBSUB_QOS_DEADLINECHECKS == true)
         urtTimerReset(subscriber->qosDeadlineTimer);
     #endif /* URT_CFG_PUBSUB_QOS_DEADLINECHECKS */
+      }
       if (hrtZero) {
         urtCondvarSignal(subscriber->base.topic->hrtReleased);
+      }
       if (lastMessage->originTime == subscriber->base.lastMessageTime) {
         urtMutexUnlock(subscriber->base.topic);
         return URT_STATUS_FETCH_NOMESSAGE;
+      }
       if (URT_CFG_PUBSUB_PROFILING == true || latency) {
         uint64_t calculatedLatency = urtTimeNow() - messageTemp->originTime;
     #if(URT_CFG_PUBSUB_PROFILING == true)
       subscriber->base.sumLatencies += calculatedLatency;
       if (calculatedLatency < subscriber->minLatency) {
         subscriber->minLatency = calculatedLatency;
+      }
       else if (calculatedLatency > subscriber->maxLatency) {
         subscriber->maxLatency = calculatedLatency;
+      }
     #endif /* URT_CFG_PUBSUB_PROFILING */
         if (latency) {
           latency = calculatedLatency;
+        }
+      }
     #if (URT_CFG_PUBSUB_QOS_JITTERCHECKS == true)
       if (calculatedLatency < subscriber->minLatency && calculatedLatency > subscriber->minLatency - subscriber->maxJitter) {
         subscriber->minLatency = calculatedLatency;
+      }
       else if (calculatedLatency > subscriber->maxLatency && calculatedLatency < subscriber->maxLatency + subscriber->maxJitter) {
         subscriber->maxLatency = calculatedLatency;
+      }
       else if (calculatedLatency > subscriber->maxLatency || calculatedLatency < subscriber->minLatency) {
         urtMutexUnlock(subscriber->base.topic);
         urtCoreStopNodes(URT_STATUS_JITTERVIOLATION);
         return URT_STATUS_JITTERVIOLATION;
+      }
     #endif /* URT_CFG_PUBSUB_QOS_JITTERCHECKS */
     #if (URT_CFG_PUBSUB_PROFILING == true && URT_CFG_PUBSUB_QOS_JITTERCHECKS == false)
       if (calculatedLatency < subscriber->minLatency) {
         subscriber->minLatency = calculatedLatency;
+      }
       else if (calculatedLatency > subscriber->maxLatency) {
         subscriber->maxLatency = calculatedLatency;
+      }
     #endif /* URT_CFG_PUBSUB_PROFILING */
       urtFetchMessage(lastMessage, subscriber, payload, bytes);
     #if (URT_CFG_PUBSUB_QOS_DEADLINECHECKS == true)
       urtTimerReset(subscriber->qosDeadlineTimer);
     #endif /* URT_CFG_PUBSUB_QOS_DEADLINECHECKS */
+    }
     /**
      * @brief  Unsubscribes from a subscriber.

Also available in: Unified diff