Core/Misc: fix interaction of spells like Shadowmeld with Threat reducing effects

- SPELL_AURA_MOD_TOTAL_THREAT should be temporary and not added/subtracted from total, only computed
- Cleanup of reference related code
- Kill getLast() and reverse iterator obsevers, LinkedList iterator can't be used as a standard reverse_iterator (ie with operator++). They weren't used anyways

3 files changed, 51 insertions, 42 deletions

diff --git a/src/server/shared/Dynamic/LinkedList.h b/src/server/shared/Dynamic/LinkedList.h
index 94f67cac909..1c99144db0e 100644
--- a/src/server/shared/Dynamic/LinkedList.h
+++ b/src/server/shared/Dynamic/LinkedList.h
@@ -32,18 +32,18 @@ class LinkedListElement
 
         LinkedListElement* iNext;
         LinkedListElement* iPrev;
+
     public:
-        LinkedListElement() : iNext(NULL), iPrev(NULL) { }
-        virtual ~LinkedListElement() { delink(); }
+        LinkedListElement() : iNext(nullptr), iPrev(nullptr) { }
 
-        bool hasNext() const { return(iNext && iNext->iNext != NULL); }
-        bool hasPrev() const { return(iPrev && iPrev->iPrev != NULL); }
-        bool isInList() const { return(iNext != NULL && iPrev != NULL); }
+        bool hasNext() const  { return (iNext && iNext->iNext != nullptr); }
+        bool hasPrev() const  { return (iPrev && iPrev->iPrev != nullptr); }
+        bool isInList() const { return (iNext != nullptr && iPrev != nullptr); }
 
-        LinkedListElement      * next()       { return hasNext() ? iNext : NULL; }
-        LinkedListElement const* next() const { return hasNext() ? iNext : NULL; }
-        LinkedListElement      * prev()       { return hasPrev() ? iPrev : NULL; }
-        LinkedListElement const* prev() const { return hasPrev() ? iPrev : NULL; }
+        LinkedListElement      * next()       { return hasNext() ? iNext : nullptr; }
+        LinkedListElement const* next() const { return hasNext() ? iNext : nullptr; }
+        LinkedListElement      * prev()       { return hasPrev() ? iPrev : nullptr; }
+        LinkedListElement const* prev() const { return hasPrev() ? iPrev : nullptr; }
 
         LinkedListElement      * nocheck_next()       { return iNext; }
         LinkedListElement const* nocheck_next() const { return iNext; }
@@ -52,10 +52,13 @@ class LinkedListElement
 
         void delink()
         {
-            if (isInList())
-            {
-                iNext->iPrev = iPrev; iPrev->iNext = iNext; iNext = NULL; iPrev = NULL;
-            }
+            if (!isInList())
+                return;
+
+            iNext->iPrev = iPrev;
+            iPrev->iNext = iNext;
+            iNext = nullptr;
+            iPrev = nullptr;
         }
 
         void insertBefore(LinkedListElement* pElem)
@@ -75,8 +78,14 @@ class LinkedListElement
         }
 
     private:
-        LinkedListElement(LinkedListElement const&);
-        LinkedListElement& operator=(LinkedListElement const&);
+        LinkedListElement(LinkedListElement const&) = delete;
+        LinkedListElement& operator=(LinkedListElement const&) = delete;
+
+    protected:
+        ~LinkedListElement()
+        {
+            delink();
+        }
 };
 
 //============================================
@@ -97,15 +106,13 @@ class LinkedListHead
             iLast.iPrev = &iFirst;
         }
 
-        virtual ~LinkedListHead() { }
-
         bool isEmpty() const { return(!iFirst.iNext->isInList()); }
 
-        LinkedListElement      * getFirst()       { return(isEmpty() ? NULL : iFirst.iNext); }
-        LinkedListElement const* getFirst() const { return(isEmpty() ? NULL : iFirst.iNext); }
+        LinkedListElement      * getFirst()       { return (isEmpty() ? nullptr : iFirst.iNext); }
+        LinkedListElement const* getFirst() const { return (isEmpty() ? nullptr : iFirst.iNext); }
 
-        LinkedListElement      * getLast() { return(isEmpty() ? NULL : iLast.iPrev); }
-        LinkedListElement const* getLast() const  { return(isEmpty() ? NULL : iLast.iPrev); }
+        LinkedListElement      * getLast()       { return(isEmpty() ? nullptr : iLast.iPrev); }
+        LinkedListElement const* getLast() const { return(isEmpty() ? nullptr : iLast.iPrev); }
 
         void insertFirst(LinkedListElement* pElem)
         {
@@ -248,8 +255,11 @@ class LinkedListHead
         typedef Iterator<LinkedListElement> iterator;
 
     private:
-        LinkedListHead(LinkedListHead const&);
-        LinkedListHead& operator=(LinkedListHead const&);
+        LinkedListHead(LinkedListHead const&) = delete;
+        LinkedListHead& operator=(LinkedListHead const&) = delete;
+
+    protected:
+        ~LinkedListHead() { }
 };
 
 //============================================
diff --git a/src/server/shared/Dynamic/LinkedReference/RefManager.h b/src/server/shared/Dynamic/LinkedReference/RefManager.h
index 9dbab4f338e..3c716e3c6b7 100644
--- a/src/server/shared/Dynamic/LinkedReference/RefManager.h
+++ b/src/server/shared/Dynamic/LinkedReference/RefManager.h
@@ -23,31 +23,29 @@
 #include "Dynamic/LinkedList.h"
 #include "Dynamic/LinkedReference/Reference.h"
 
-template <class TO, class FROM> class RefManager : public LinkedListHead
+template <class TO, class FROM>
+class RefManager : public LinkedListHead
 {
     public:
-        typedef LinkedListHead::Iterator< Reference<TO, FROM> > iterator;
+        typedef LinkedListHead::Iterator<Reference<TO, FROM>> iterator;
         RefManager() { }
-        virtual ~RefManager() { clearReferences(); }
 
-        Reference<TO, FROM>* getFirst() { return ((Reference<TO, FROM>*) LinkedListHead::getFirst()); }
-        Reference<TO, FROM> const* getFirst() const { return ((Reference<TO, FROM> const*) LinkedListHead::getFirst()); }
-        Reference<TO, FROM>* getLast() { return ((Reference<TO, FROM>*) LinkedListHead::getLast()); }
-        Reference<TO, FROM> const* getLast() const { return ((Reference<TO, FROM> const*) LinkedListHead::getLast()); }
+        Reference<TO, FROM>* getFirst()             { return static_cast<Reference<TO, FROM>*>(LinkedListHead::getFirst()); }
+
+        Reference<TO, FROM> const* getFirst() const { return static_cast<Reference<TO, FROM> const*>(LinkedListHead::getFirst()); }
 
         iterator begin() { return iterator(getFirst()); }
-        iterator end() { return iterator(NULL); }
-        iterator rbegin() { return iterator(getLast()); }
-        iterator rend() { return iterator(NULL); }
+        iterator end()   { return iterator(nullptr); }
+
+        virtual ~RefManager()
+        {
+            clearReferences();
+        }
 
         void clearReferences()
         {
-            LinkedListElement* ref;
-            while ((ref = getFirst()) != NULL)
-            {
-                ((Reference<TO, FROM>*) ref)->invalidate();
-                ref->delink();                              // the delink might be already done by invalidate(), but doing it here again does not hurt and insures an empty list
-            }
+            while (Reference<TO, FROM>* ref = getFirst())
+                ref->invalidate();
         }
 };
 
diff --git a/src/server/shared/Dynamic/LinkedReference/Reference.h b/src/server/shared/Dynamic/LinkedReference/Reference.h
index 4a473b0f2ac..0dcf91fb052 100644
--- a/src/server/shared/Dynamic/LinkedReference/Reference.h
+++ b/src/server/shared/Dynamic/LinkedReference/Reference.h
@@ -29,6 +29,7 @@ template <class TO, class FROM> class Reference : public LinkedListElement
     private:
         TO* iRefTo;
         FROM* iRefFrom;
+
     protected:
         // Tell our refTo (target) object that we have a link
         virtual void targetObjectBuildLink() = 0;
@@ -90,14 +91,14 @@ template <class TO, class FROM> class Reference : public LinkedListElement
         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()); }
 
-        TO* operator ->() const { return iRefTo; }
+        TO* operator->() const { return iRefTo; }
         TO* getTarget() const { return iRefTo; }
 
         FROM* GetSource() const { return iRefFrom; }
 
     private:
-        Reference(Reference const&);
-        Reference& operator=(Reference const&);
+        Reference(Reference const&) = delete;
+        Reference& operator=(Reference const&) = delete;
 };
 
 //=====================================================