refactor: Heavy refactoring of SPIT

components/spit/include/spit_object.hpp

@@ -0,0 +1,122 @@
+#pragma once 
+
+#include "spit_type.hpp"
+#include "spit_message.hpp"
+#include "spit_repo.hpp"
+
+using namespace std;
+namespace spit {
+
+class SObjectListener;
+
+class SObject {
+  public:
+    template <typename T>
+    struct Property {
+        friend SObject;
+        Property(bool &confirmed) 
+          : rConfirmed(confirmed) {
+        }
+        bool set(const T& val) {
+            if (mValue == val)
+              return false;
+            mValue = val;
+            rConfirmed = false;
+            return true;
+        }
+        T get () const {
+            return mValue;
+        }
+        private:
+          bool & rConfirmed;
+          T mValue{};
+    };
+
+    Property<string> Name{mConfirmed};
+    Property<string> Remark{mConfirmed};
+    Property<string> ServerParams{mConfirmed};
+    Property<string> SPITTypeID{mConfirmed};
+    // Returns if the SPITType triggers an action on the Server or on the client.
+    // @return false = the action is triggered on the client The client waits for the server to play objects of this SPITType
+    // true = the action is triggered on the server. The server waits for the client to play objects of this SPITType.
+    Property<bool> ServerRemote{mConfirmed};
+    Property<bool> Fixed{mConfirmed};
+    Property<uint64_t> FrameStart{mConfirmed};
+    Property<uint64_t> FrameLength{mConfirmed};
+    Property<uint64_t> FrameFadeInLength{mConfirmed};
+    Property<uint64_t> FrameFadeOutLength{mConfirmed};
+    Property<char> ValueUse{mConfirmed};
+    Property<int> ValueFactor{mConfirmed};
+    Property<int> Track{mConfirmed};
+    Property<uint64_t> Delay{mConfirmed};
+    Property<uint64_t> Duration{mConfirmed};
+
+    static void clearUnconfirmedObjects(SpitRepo<SObject> &repo);
+    static void setConfirmedFalse(SpitRepo<SObject> &repo);
+    static void eventProjectClosed(SpitRepo<SObject> &repo, SpitRepo<SObject> &remoteRepo);
+
+    SObject(string iD) {
+        mID = iD;
+    }
+
+  private:
+    string mID;
+    bool mConfirmed{};
+    bool mCreatedByClient{};
+    bool mActionAssigned{};
+    bool mActionAssignedType{}; // Virtual construct
+    char mValueUse{0x01};
+    int mValueFactor{1000000}; // Values are given in ppm -> 1000000 = 1/1;
+    bool mPlayPrePosition;
+    uint64_t mPlayTimeInsideFrames;
+    int mPlayValue;
+    char mPlayValueFlag;
+
+  public:
+    string getID() const { return mID; }
+   
+    /**
+     * This is used by the server and client to tell if the other side has registered the changes.
+     * @return true = other side has registered the changes.
+     */
+    bool getConfirmed() const { return mConfirmed; }
+    bool getCreatedByClient() const { return mCreatedByClient; }
+    /**
+     * This is a virtual construct - ActionAssignedType is not implemented in the SPITProtocol.
+     * This is used when an action is associated with a SPITType.
+     * Then this action is done for every SObject with the SPITType.
+     * @return true = an action is assigned for the SPITType.
+     */
+    bool getActionAssignedType() const { return mActionAssignedType; }
+    /** Returns if this SObject has an associated action or not.
+     * @return true = the user has asscociated an action with this SObject or
+     *  the user has asscociated an action with the SPITType of this SObject
+     */
+    bool getActionAssigned() const { return mActionAssigned || mActionAssignedType; }
+
+    bool getProjectIndepended(SpitRepo<SType> &repo, SpitRepo<SType> &remoteRepo) const {
+        SType *ptrSPITType;
+        if (ServerRemote.get() == false) {
+            ptrSPITType = repo.getEntry(SPITTypeID.get());
+            if (ptrSPITType == nullptr)
+                return true;
+            return ptrSPITType->ProjectIndepended.get();
+        } else {
+            ptrSPITType = remoteRepo.getEntry(SPITTypeID.get());
+            if (ptrSPITType == nullptr)
+                return true;
+            return ptrSPITType->ProjectIndepended.get();
+        }
+    };
+
+    bool setConfirmed(bool confirmed);
+    void setCreatedByClient(bool createdByClient) { mCreatedByClient = createdByClient; }
+    bool setActionAssignedType(bool actionAssigned);
+    bool setActionAssigned(bool actionAssigned);
+
+    bool setMessageOP(Message::ReportObject *message);
+    void fillMessageOP(Message::ReportObject &message);
+    void fillMessageOP(Message::RemoveObject &message);
+};
+
+}