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

(cherry picked from commit 3b6fd226bedb689847dadaeeba36a588ee9bc928)

# Conflicts:
#	src/server/game/Combat/ThreatManager.cpp
#	src/server/game/Loot/LootMgr.h

2 files changed, 18 insertions, 19 deletions

diff --git a/src/server/shared/Dynamic/LinkedReference/RefManager.h b/src/server/shared/Dynamic/LinkedReference/RefManager.h
index 72e3abcdc9f..ad6bf1d79ad 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 1543b9bdfd2..c0c4ec21a80 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;
 };
 
 //=====================================================