Core/Misc: Reduce amount of virtual functions and copypasting in Reference<> implementations

3 files changed, 24 insertions, 23 deletions

diff --git a/src/server/shared/Dynamic/LinkedList.h b/src/server/shared/Dynamic/LinkedList.h
index 8bfac0347a0..bc4a10da741 100644
--- a/src/server/shared/Dynamic/LinkedList.h
+++ b/src/server/shared/Dynamic/LinkedList.h
@@ -83,7 +83,7 @@ class LinkedListElement
         LinkedListElement& operator=(LinkedListElement&&) = delete;
 
     protected:
-        ~LinkedListElement()
+        virtual ~LinkedListElement()
         {
             delink();
         }
diff --git a/src/server/shared/Dynamic/LinkedReference/RefManager.h b/src/server/shared/Dynamic/LinkedReference/RefManager.h
index 5661b5dc95e..0c26d5d0d69 100644
--- a/src/server/shared/Dynamic/LinkedReference/RefManager.h
+++ b/src/server/shared/Dynamic/LinkedReference/RefManager.h
@@ -21,17 +21,17 @@
 #include "Dynamic/LinkedList.h"
 #include "Dynamic/LinkedReference/Reference.h"
 
-template <class TO, class FROM>
+template <class ReferenceType>
 class RefManager : public LinkedListHead
 {
 public:
-    typedef LinkedListHead::Iterator<Reference<TO, FROM>> iterator;
-    typedef LinkedListHead::Iterator<Reference<TO, FROM> const> const_iterator;
+    typedef LinkedListHead::Iterator<ReferenceType> iterator;
+    typedef LinkedListHead::Iterator<ReferenceType const> const_iterator;
     RefManager() { }
 
-    Reference<TO, FROM>* getFirst() { return static_cast<Reference<TO, FROM>*>(LinkedListHead::getFirst()); }
+    ReferenceType* getFirst() { return static_cast<ReferenceType*>(LinkedListHead::getFirst()); }
 
-    Reference<TO, FROM> const* getFirst() const { return static_cast<Reference<TO, FROM> const*>(LinkedListHead::getFirst()); }
+    ReferenceType const* getFirst() const { return static_cast<ReferenceType const*>(LinkedListHead::getFirst()); }
 
     iterator begin() { return iterator(getFirst()); }
     iterator end() { return iterator(nullptr); }
@@ -46,7 +46,7 @@ public:
 
     void clearReferences()
     {
-        while (Reference<TO, FROM>* ref = getFirst())
+        while (ReferenceType* ref = getFirst())
             ref->invalidate();
     }
 };
diff --git a/src/server/shared/Dynamic/LinkedReference/Reference.h b/src/server/shared/Dynamic/LinkedReference/Reference.h
index 255a510f050..0c86386f5e2 100644
--- a/src/server/shared/Dynamic/LinkedReference/Reference.h
+++ b/src/server/shared/Dynamic/LinkedReference/Reference.h
@@ -23,24 +23,25 @@
 
 //=====================================================
 
-template <class TO, class FROM> class Reference : public LinkedListElement
+template <class TO, class FROM, class Derived> class Reference : public LinkedListElement
 {
     private:
         TO* iRefTo;
         FROM* iRefFrom;
 
     protected:
+        // Notification functions are found by CRTP
         // Tell our refTo (target) object that we have a link
-        virtual void targetObjectBuildLink() = 0;
+        //virtual void targetObjectBuildLink() = 0;
 
         // Tell our refTo (taget) object, that the link is cut
-        virtual void targetObjectDestroyLink() = 0;
+        //virtual void targetObjectDestroyLink() = 0;
 
         // Tell our refFrom (source) object, that the link is cut (Target destroyed)
-        virtual void sourceObjectDestroyLink() = 0;
+        //virtual void sourceObjectDestroyLink() = 0;
     public:
         Reference() { iRefTo = nullptr; iRefFrom = nullptr; }
-        virtual ~Reference() { }
+        ~Reference() { }
 
         // Create new link
         void link(TO* toObj, FROM* fromObj)
@@ -52,7 +53,7 @@ template <class TO, class FROM> class Reference : public LinkedListElement
             {
                 iRefTo = toObj;
                 iRefFrom = fromObj;
-                targetObjectBuildLink();
+                static_cast<Derived*>(this)->targetObjectBuildLink();
             }
         }
 
@@ -60,7 +61,7 @@ template <class TO, class FROM> class Reference : public LinkedListElement
         // Tell our refTo object, that the link is cut
         void unlink()
         {
-            targetObjectDestroyLink();
+            static_cast<Derived*>(this)->targetObjectDestroyLink();
             delink();
             iRefTo = nullptr;
             iRefFrom = nullptr;
@@ -70,7 +71,7 @@ template <class TO, class FROM> class Reference : public LinkedListElement
         // Tell our refFrom object, that the link is cut
         void invalidate()                                   // the iRefFrom MUST remain!!
         {
-            sourceObjectDestroyLink();
+            static_cast<Derived*>(this)->sourceObjectDestroyLink();
             delink();
             iRefTo = nullptr;
         }
@@ -80,15 +81,15 @@ template <class TO, class FROM> class Reference : public LinkedListElement
             return iRefTo != nullptr;
         }
 
-        Reference<TO, FROM>       * next()       { return((Reference<TO, FROM>       *) LinkedListElement::next()); }
-        Reference<TO, FROM> const* next() const { return((Reference<TO, FROM> const*) LinkedListElement::next()); }
-        Reference<TO, FROM>       * prev()       { return((Reference<TO, FROM>       *) LinkedListElement::prev()); }
-        Reference<TO, FROM> const* prev() const { return((Reference<TO, FROM> const*) LinkedListElement::prev()); }
+        Derived      * next()       { return static_cast<Derived*>(LinkedListElement::next()); }
+        Derived const* next() const { return static_cast<Derived const*>(LinkedListElement::next()); }
+        Derived      * prev()       { return static_cast<Derived*>(LinkedListElement::prev()); }
+        Derived const* prev() const { return static_cast<Derived const*>(LinkedListElement::prev()); }
 
-        Reference<TO, FROM>       * nocheck_next()       { return((Reference<TO, FROM>       *) LinkedListElement::nocheck_next()); }
-        Reference<TO, FROM> const* nocheck_next() const { return((Reference<TO, FROM> const*) LinkedListElement::nocheck_next()); }
-        Reference<TO, FROM>       * nocheck_prev()       { return((Reference<TO, FROM>       *) LinkedListElement::nocheck_prev()); }
-        Reference<TO, FROM> const* nocheck_prev() const { return((Reference<TO, FROM> const*) LinkedListElement::nocheck_prev()); }
+        Derived      * nocheck_next()       { return static_cast<Derived*>(LinkedListElement::nocheck_next()); }
+        Derived const* nocheck_next() const { return static_cast<Derived const*>(LinkedListElement::nocheck_next()); }
+        Derived      * nocheck_prev()       { return static_cast<Derived*>(LinkedListElement::nocheck_prev()); }
+        Derived const* nocheck_prev() const { return static_cast<Derived const*>(LinkedListElement::nocheck_prev()); }
 
         TO* operator->() const { return iRefTo; }
         TO* getTarget() const { return iRefTo; }