refactor: player construct

components/spit/include/SAD_DetectedServer.hpp

@@ -107,7 +107,7 @@ class SAD_DetectedServer {
     static void removeDetectedServer(SAD_DetectedServer &server) {
         auto i = sKnownServers.find(server.getID());
         if (i != sKnownServers.end()) {
-            i = sKnownServers.erase(i);
+            sKnownServers.erase(i);
         }
     }
     static void clearDetectedServers() {

components/spit/include/SPITPlayer.h

@@ -23,13 +23,10 @@ class SPITPlayer {
   public:
     class PlaySPITType {
       public:
-        PlaySPITType();
+         PlaySPITType(SPITPlayer *p_SPITPlayer, string p_SPITObjectID);
-        PlaySPITType(SPITPlayer *p_SPITPlayer, string p_SPITObjectID);
         PlaySPITType(const PlaySPITType &orig);
 
-        string getSPITTypeID() const {
+        string getSPITTypeID() const { return m_SPITTypeID; }
-            return m_SPITTypeID;
-        }
 
         void startPlaySequence();
         bool getIsNew() const { return m_IsNew; }
@@ -57,9 +54,9 @@ class SPITPlayer {
     //----- SPITPlayer ------
   public:
     // list the SPITPlayers
-    static unordered_map<string, SPITPlayer *> s_SPITPlayers; // all actual played objects
+    static unordered_map<string, unique_ptr<SPITPlayer>> s_SPITPlayers; // all actual played objects
     static SPITPlayer &getSPITPlayer(string p_PlayerID);      // if a player does not exist creates a new one
-    static void clearPlayers();
+    static void clearPlayers() { s_SPITPlayers.clear(); }
 
     SPITPlayer(string p_PlayerID);
     virtual ~SPITPlayer();
@@ -72,21 +69,22 @@ class SPITPlayer {
         return m_ID;
     }
 
-    unordered_map<string, PlaySPITType *> *getPlaySPITTypes();
+    unordered_map<string, unique_ptr<PlaySPITType>> &getPlaySPITTypes() { return m_PlaySPITTypes; }
     void setIsRunning(bool p_IsRunning) { m_IsRunning = p_IsRunning; }
     void setName(string p_Name) { m_Name = p_Name; }
     void setType(char p_Type) { m_Type = p_Type; }
     void setTime(long long p_Frames) { m_TimeFrames = p_Frames; }
-    bool getIsRunning() { return m_IsRunning; }
+    bool getIsRunning() const { return m_IsRunning; }
-    string getName() { return m_Name; }
+    string getName() const { return m_Name; }
-    char getType() { return m_Type; }
+    char getType() const { return m_Type; }
-    long long getTime() { return m_TimeFrames; }
+    long long getTime() const { return m_TimeFrames; }
 
   private:
     string m_ID;
     string m_Name;
     char m_Type;
-    unordered_map<string, PlaySPITType *> m_PlaySPITTypes;
+    unordered_map<string, unique_ptr<PlaySPITType>> m_PlaySPITTypes;
+
     bool m_IsRunning;
     long long m_TimeFrames;
 };

components/spit/include/SpitRepo.hpp

@@ -48,7 +48,7 @@ class SpitRepo {
         if (i == mEntries.end()) {
             return false;
         }
-        i = mEntries.erase(i);
+        mEntries.erase(i);
         return true;
     }
     int getEntryCount() {

components/spit/src/SPITObject.cpp

@@ -21,19 +21,22 @@
  */
 void SPITObject::clearUnconfirmedSPITObjects(SpitRepo<SPITObject> &repo) {
     auto &entries = repo.getRepo();
-    for (auto i = entries.begin(); i != entries.end(); i++) {
+    for (auto i = entries.begin(); i != entries.end();) {
         SPITObject *ptrSPITObject = i->second.get();
         if (ptrSPITObject->getCreatedByClient() == false && ptrSPITObject->getConfirmed() == false) {
             i = entries.erase(i);
+        } else {
+            i++;
         }
     }
 }
 
 void SPITObject::eventProjectClosed(SpitRepo<SPITObject> &repo, SpitRepo<SPITObject> &remoteRepo) {
     auto &entries = repo.getRepo();
-    for (auto i = entries.begin(); i != entries.end(); i++) {
+    for (auto i = entries.begin(); i != entries.end(); ) {
         SPITObject *ptrSPITObject = i->second.get();
         if (ptrSPITObject->getCreatedByClient() == true) {
+            i++;
             continue;
         }
         i = entries.erase(i);

components/spit/src/SPITPlayer.cpp

@@ -13,52 +13,29 @@
  */
 
 #include "SPITPlayer.h"
+#include <memory>
 #include <vector>
 
-unordered_map<string, SPITPlayer *> SPITPlayer::s_SPITPlayers;
+using namespace std;
+
+unordered_map<string, unique_ptr<SPITPlayer>> SPITPlayer::s_SPITPlayers;
 
 SPITPlayer &SPITPlayer::getSPITPlayer(string p_PlayerID) {
     auto i = s_SPITPlayers.find(p_PlayerID);
     if (i == s_SPITPlayers.end()) {
-        s_SPITPlayers[p_PlayerID] = new SPITPlayer(p_PlayerID);
+        s_SPITPlayers[p_PlayerID] = make_unique<SPITPlayer>(p_PlayerID);
     }
     return *s_SPITPlayers.at(p_PlayerID);
 }
 
-void SPITPlayer::clearPlayers() {
-    ;
-    vector<SPITPlayer *> o_SPITPlayers;
-    for (auto i = s_SPITPlayers.begin(); i != s_SPITPlayers.end(); i++) {
-        SPITPlayer *ptrSPITPlayer = i->second;
-        o_SPITPlayers.push_back(ptrSPITPlayer);
-    }
-    for (auto i = o_SPITPlayers.begin(); i != o_SPITPlayers.end(); i++) {
-        SPITPlayer *ptrSPITPlayer = *i;
-        delete ptrSPITPlayer;
-    }
-    o_SPITPlayers.clear();
-}
-
 SPITPlayer::SPITPlayer(string p_PlayerID) {
     m_ID = p_PlayerID;
-    s_SPITPlayers[p_PlayerID] = this;
 }
 
 SPITPlayer::~SPITPlayer() {
-    PlaySPITType *ptrPlaySPITType;
+    m_PlaySPITTypes.clear();
-    for (auto i = m_PlaySPITTypes.begin(); i != m_PlaySPITTypes.end(); i++) {
-        ptrPlaySPITType = i->second;
-        i = m_PlaySPITTypes.erase(i);
-        delete ptrPlaySPITType;
-        if (i == m_PlaySPITTypes.end()) {
-            break;
-        }
-    }
 }
 
-unordered_map<string, SPITPlayer::PlaySPITType *> *SPITPlayer::getPlaySPITTypes() {
-    return &m_PlaySPITTypes;
-}
 /**
  *
  * @param p_SPITObjectID
@@ -67,46 +44,38 @@ unordered_map<string, SPITPlayer::PlaySPITType *> *SPITPlayer::getPlaySPITTypes(
  */
 SPITPlayer::PlaySPITType *SPITPlayer::addSPITType_Playing(string p_SPITTypeID) {
     PlaySPITType *ptrPlaySPITType;
-
     auto i = m_PlaySPITTypes.find(p_SPITTypeID);
     if (i == m_PlaySPITTypes.end()) {
-        ptrPlaySPITType = new PlaySPITType(this, p_SPITTypeID);
+        auto playSpitType = make_unique<PlaySPITType>(this, p_SPITTypeID);
-        ptrPlaySPITType->setIsPlayed(true);
+        ptrPlaySPITType = playSpitType.get();
-        ptrPlaySPITType->setIsNew(true);
+        m_PlaySPITTypes[p_SPITTypeID] = move(playSpitType);
-        m_PlaySPITTypes[p_SPITTypeID] = ptrPlaySPITType;
     } else {
-        ptrPlaySPITType = i->second;
+        ptrPlaySPITType = i->second.get();
-        ptrPlaySPITType->setIsPlayed(true);
     }
+    ptrPlaySPITType->setIsPlayed(true);
     return ptrPlaySPITType;
 }
 
 void SPITPlayer::startPlaySequence() {
-    PlaySPITType *ptrPlaySPITType;
     for (auto i = m_PlaySPITTypes.begin(); i != m_PlaySPITTypes.end(); i++) {
-        ptrPlaySPITType = i->second;
+        PlaySPITType *ptrPlaySPITType = i->second.get();
         ptrPlaySPITType->startPlaySequence();
     }
 }
 
 void SPITPlayer::endPlaySequence() {
-    PlaySPITType *ptrPlaySPITType;
+    for (auto i = m_PlaySPITTypes.begin(); i != m_PlaySPITTypes.end(); ) {
-
+        if (i->second.get()->getIsPlayed() == false) {
-    for (auto i = m_PlaySPITTypes.begin(); i != m_PlaySPITTypes.end(); i++) {
-        ptrPlaySPITType = i->second;
-        if (ptrPlaySPITType->getIsPlayed() == false) {
             i = m_PlaySPITTypes.erase(i);
-            delete ptrPlaySPITType;
+        } else {
-            if (i == m_PlaySPITTypes.end()) {
+            ++i;
-                break;
-            }
         }
     }
 }
 
-SPITPlayer::PlaySPITType::PlaySPITType() {
-}
 SPITPlayer::PlaySPITType::PlaySPITType(SPITPlayer *p_SPITPlayer, string p_SPITTypeID) {
+    m_IsNew = true;
+
     m_SPITTypeID = p_SPITTypeID;
     m_PlayerID = p_SPITPlayer->getID();
     m_PlayerName = p_SPITPlayer->getName();

components/spit/src/SPITType.cpp

@@ -19,9 +19,10 @@ static const char *TAG = "SPIT";
 
 void SPITType::eventProjectClosed(SpitRepo<SPITType> &repo, SpitRepo<SPITType> &remoteRepo) {
     auto &entries = repo.getRepo();
-    for (auto i = entries.begin(); i != entries.end(); i++) {
+    for (auto i = entries.begin(); i != entries.end();) {
         SPITType *ptrSPITType = i->second.get();
         if (ptrSPITType->getCreatedByClient() == true) {
+            i++;
             continue;
         }
         i = entries.erase(i);

components/spit/src/SPIT_Client.cpp

@@ -153,6 +153,7 @@ void SPIT_Client::eventServerDetected(SAD_DetectedServer &server) {
         startServerAutoDetect();
     }
 }
+
 /**
  * If a SPITServer is not more found, this function is called.
  * To do so the SAD_Client ServerAutoDetect has to be startet - see SAD_Client::startServerAutoDetect.
@@ -239,12 +240,11 @@ int SPIT_Client::sendSPITMessage(SPIT_Message::OPPart &opPart) {
 }
 
 bool SPIT_Client::startReceiveSPITMessages() {
-    {
+    if (!mSPITSocket->getIsBound())
-        if (!mSPITSocket->getIsBound())
+        return false;
-            return false;
+    m_StopReceiveSPITMessages = false;
-        m_StopReceiveSPITMessages = false;
+    m_ThreadReceive = new fos::TaskT<SPIT_Client &>(receiveSPITMessage, *this, "receiveTask", fos::Task::DefaultStackSize * 4);
-        m_ThreadReceive = new fos::TaskT<SPIT_Client &>(receiveSPITMessage, *this, "receiveTask", fos::Task::DefaultStackSize * 4);
+
-    }
     return true;
 }
 
@@ -477,7 +477,6 @@ void SPIT_Client::disconnect() {
 
 void SPIT_Client::disconnectInternal(Connection p_Cause) {
     Connection intOldConnectionStatus = m_ConnectionStatus;
-    int intResult;
 
     m_ConnectionStatus = p_Cause;
     switch (m_ConnectionStatus) {
@@ -527,8 +526,6 @@ void SPIT_Client::disconnectInternal(Connection p_Cause) {
 }
 
 void SPIT_Client::parseConnectAnswer(SPIT_Message::ConnectAnswer &p_ConnectAnswer) {
-    Connection intOldConnectionStatus = m_ConnectionStatus;
-
     if (p_ConnectAnswer.getClientID() != m_ID)
         return;
 
@@ -587,8 +584,7 @@ void SPIT_Client::parseWatchdog(SPIT_Message::Watchdog &p_Watchdog) {
  * @param p_Watchdog
  */
 void SPIT_Client::parseWatchdogAnswer(SPIT_Message::WatchdogAnswer &p_WatchdogAnswer) {
-    answerWatchdog();
+    answerWatchdog(); // is also done by parseSPIT_Message
-    ; // is also done by parseSPIT_Message
 }
 void SPIT_Client::sendWatchdog() {
     int intResult;
@@ -647,8 +643,7 @@ void SPIT_Client::parseRequestProjectTransfer(SPIT_Message::RequestProjectTransf
     //	printf("parse RequestProjectTransfer \n");
     // StartProjectTransfer
     SPIT_Message::StartProjectTransfer sMStartProjectTransfer;
-    int intResult = sendSPITMessage(sMStartProjectTransfer);
+    if (sendSPITMessage(sMStartProjectTransfer) < 0) {
-    if (intResult < 0) {
         return;
     }
 
@@ -1195,41 +1190,10 @@ void SPIT_Client::parsePlaySPITObject(SPIT_Message::PlaySPITObject &p_PlaySPITOb
 
 void SPIT_Client::parsePlaySPITEnd(SPIT_Message::PlaySPITEnd &p_PlaySPITEnd) {
     SPITPlayer &ptrSPITPlayer = SPITPlayer::getSPITPlayer(p_PlaySPITEnd.getPlayerID());
-    // unordered_map<string, SPITPlayer::PlaySPITType*>* ptrPlayObjects;
-    // bool boolStarted;
-    // bool boolStopped;
 
-    // SPITPlayer::PlaySPITType* ptrPlayObject = ptrSPITPlayer->getPlayObjects();
+    auto &ptrPlaySPITTypes = ptrSPITPlayer.getPlaySPITTypes();
-    // for (auto i = ptrPlayObjects->begin(); i != ptrPlayObjects->end(); i++) {
+    for (auto i = ptrPlaySPITTypes.begin(); i != ptrPlaySPITTypes.end(); i++) {
-    //     ptrPlayObject = i->second;
+        SPITPlayer::PlaySPITType *ptrPlaySPITType = i->second.get();
-    //     boolStarted = false;
-    //     boolStopped = false;
-    //     if (ptrPlayObject->getIsNew()) {
-    //         boolStarted = true;
-    //     }
-    //     if (ptrPlayObject->getIsPlayed() == false) {
-    //         boolStopped = true;
-    //     }
-    //     {
-    //         ptrSPITObject = mSpitObjects.getEntry(ptrPlayObject->getSPITObjectID());
-    //         if (ptrSPITObject == nullptr) {
-    //             return;
-    //         }
-    //         SPITType *ptrSPITType = mSpitTypes.getEntry(ptrSPITObject->getSPITTypeID());
-    //         if (ptrSPITType == nullptr) {
-    //             return;
-    //         }
-
-    //         mCallbacks.onPlaySpitType(ptrPlayObject->getPlayerID(), boolStarted, boolStopped, *ptrSPITType, *ptrSPITObject, *ptrPlayObject);
-    //     }
-    // }
-    // ptrSPITPlayer.endPlaySequence();
-
-    // SPITPlayer &ptrSPITPlayer = SPITPlayer::getSPITPlayer(p_PlaySPITEnd->getPlayerID());
-
-    unordered_map<string, SPITPlayer::PlaySPITType *> *ptrPlaySPITTypes = ptrSPITPlayer.getPlaySPITTypes();
-    for (auto i = ptrPlaySPITTypes->begin(); i != ptrPlaySPITTypes->end(); i++) {
-        SPITPlayer::PlaySPITType *ptrPlaySPITType = i->second;
         bool boolStarted = ptrPlaySPITType->getIsNew();
         bool boolStopped = (ptrPlaySPITType->getIsPlayed() == false);
         SPITType *ptrSPITType = mSpitTypes.getEntry(ptrPlaySPITType->getSPITTypeID());