Run clang-format

src/strategy/Value.h

@@ -1,388 +1,418 @@
 /*
- * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
+ * and/or modify it under version 2 of the License, or (at your option), any later version.
  */
 
 #ifndef _PLAYERBOT_VALUE_H
 #define _PLAYERBOT_VALUE_H
 
+#include <time.h>
+
 #include "AiObject.h"
 #include "ObjectGuid.h"
 #include "PerformanceMonitor.h"
 #include "Timer.h"
 #include "Unit.h"
 
-#include <time.h>
-
 class PlayerbotAI;
 class Unit;
 
 class FleeInfo
 {
-    public:
-        Position fromPos;
-        float radius;
-        float angle;
-        uint32 timestamp;
-        int GetAngleRangeIndex() { return (angle + 2 * M_PI) / (M_PI / 2); } // [0, 7)
+public:
+    Position fromPos;
+    float radius;
+    float angle;
+    uint32 timestamp;
+    int GetAngleRangeIndex() { return (angle + 2 * M_PI) / (M_PI / 2); }  // [0, 7)
 };
 
 struct CreatureData;
 
 class UntypedValue : public AiNamedObject
 {
-    public:
-        UntypedValue(PlayerbotAI* botAI, std::string const name) : AiNamedObject(botAI, name) { }
-        virtual ~UntypedValue() { }
-        virtual void Update() { }
-        virtual void Reset() { }
-        virtual std::string const Format() { return "?"; }
-        virtual std::string const Save() { return "?"; }
-        virtual bool Load([[maybe_unused]] std::string const value) { return false; }
+public:
+    UntypedValue(PlayerbotAI* botAI, std::string const name) : AiNamedObject(botAI, name) {}
+    virtual ~UntypedValue() {}
+    virtual void Update() {}
+    virtual void Reset() {}
+    virtual std::string const Format() { return "?"; }
+    virtual std::string const Save() { return "?"; }
+    virtual bool Load([[maybe_unused]] std::string const value) { return false; }
 };
 
-template<class T>
+template <class T>
 class Value
 {
-    public:
-        virtual ~Value() { }
-        virtual T Get() = 0;
-        virtual T LazyGet() = 0;
-        virtual T& RefGet() = 0;
-        virtual void Reset() { }
-        virtual void Set(T value) = 0;
-        operator T() { return Get(); }
+public:
+    virtual ~Value() {}
+    virtual T Get() = 0;
+    virtual T LazyGet() = 0;
+    virtual T& RefGet() = 0;
+    virtual void Reset() {}
+    virtual void Set(T value) = 0;
+    operator T() { return Get(); }
 };
 
-template<class T>
+template <class T>
 class CalculatedValue : public UntypedValue, public Value<T>
 {
-	public:
-        CalculatedValue(PlayerbotAI* botAI, std::string const name = "value", uint32 checkInterval = 1) : UntypedValue(botAI, name),
-            checkInterval(checkInterval == 1 ? 1 : (checkInterval < 100 ? checkInterval * 1000 : checkInterval)) /*turn s -> ms?*/, lastCheckTime(0) { } 
+public:
+    CalculatedValue(PlayerbotAI* botAI, std::string const name = "value", uint32 checkInterval = 1)
+        : UntypedValue(botAI, name),
+          checkInterval(
+              checkInterval == 1 ? 1 : (checkInterval < 100 ? checkInterval * 1000 : checkInterval)) /*turn s -> ms?*/,
+          lastCheckTime(0)
+    {
+    }
 
-        virtual ~CalculatedValue() { }
+    virtual ~CalculatedValue() {}
 
-        T Get() override
+    T Get() override
+    {
+        if (checkInterval < 2)
         {
-            if (checkInterval < 2) {
-                // PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr);
+            // PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(),
+            // this->context ? &this->context->performanceStack : nullptr);
+            value = Calculate();
+            // if (pmo)
+            //     pmo->finish();
+        }
+        else
+        {
+            time_t now = getMSTime();
+            if (!lastCheckTime || now - lastCheckTime >= checkInterval)
+            {
+                lastCheckTime = now;
+                // PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(),
+                // this->context ? &this->context->performanceStack : nullptr);
                 value = Calculate();
                 // if (pmo)
                 //     pmo->finish();
-            } else {
-                time_t now = getMSTime();
-                if (!lastCheckTime || now - lastCheckTime >= checkInterval)
-                {
-                    lastCheckTime = now;
-                    // PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr);
-                    value = Calculate();
-                    // if (pmo)
-                    //     pmo->finish();
-                }
             }
-            return value;
         }
+        return value;
+    }
 
-        T LazyGet() override
+    T LazyGet() override
+    {
+        if (!lastCheckTime)
+            return Get();
+
+        return value;
+    }
+    T& RefGet() override
+    {
+        if (checkInterval < 2)
         {
-            if (!lastCheckTime)
-                return Get();
-
-            return value;
+            // PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(),
+            // this->context ? &this->context->performanceStack : nullptr);
+            value = Calculate();
+            // if (pmo)
+            //     pmo->finish();
         }
-        T& RefGet() override
+        else
         {
-            if (checkInterval < 2) {
-                // PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr);
+            time_t now = getMSTime();
+            if (!lastCheckTime || now - lastCheckTime >= checkInterval)
+            {
+                lastCheckTime = now;
+                // PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(),
+                // this->context ? &this->context->performanceStack : nullptr);
                 value = Calculate();
                 // if (pmo)
                 //     pmo->finish();
-            } else {
-                time_t now = getMSTime();
-                if (!lastCheckTime || now - lastCheckTime >= checkInterval)
-                {
-                    lastCheckTime = now;
-                    // PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr);
-                    value = Calculate();
-                    // if (pmo)
-                    //     pmo->finish();
-                }
             }
-            return value;
         }
-        void Set(T val) override { value = val; }
-        void Update() override {}
-        void Reset() override { lastCheckTime = 0; }
+        return value;
+    }
+    void Set(T val) override { value = val; }
+    void Update() override {}
+    void Reset() override { lastCheckTime = 0; }
 
-    protected:
-        virtual T Calculate() = 0;
+protected:
+    virtual T Calculate() = 0;
 
-		uint32 checkInterval;
-		uint32 lastCheckTime;
-        T value;
+    uint32 checkInterval;
+    uint32 lastCheckTime;
+    T value;
 };
 
 template <class T>
 class SingleCalculatedValue : public CalculatedValue<T>
 {
-    public:
-        SingleCalculatedValue(PlayerbotAI* botAI, std::string const name = "value") : CalculatedValue<T>(botAI, name)
+public:
+    SingleCalculatedValue(PlayerbotAI* botAI, std::string const name = "value") : CalculatedValue<T>(botAI, name)
+    {
+        this->Reset();
+    }
+
+    T Get() override
+    {
+        time_t now = time(0);
+        if (!this->lastCheckTime)
         {
-            this->Reset();
+            this->lastCheckTime = now;
+
+            PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(
+                PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr);
+            this->value = this->Calculate();
+            if (pmo)
+                pmo->finish();
         }
 
-        T Get() override
-        {
-            time_t now = time(0);
-            if (!this->lastCheckTime)
-            {
-                this->lastCheckTime = now;
-
-                PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr);
-                this->value = this->Calculate();
-                if (pmo)
-                    pmo->finish();
-            }
-
-            return this->value;
-        }
+        return this->value;
+    }
 };
 
-template<class T>
+template <class T>
 class MemoryCalculatedValue : public CalculatedValue<T>
 {
-    public:
-        MemoryCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1) : CalculatedValue<T>(botAI, name, checkInterval)
-        {
-            lastChangeTime = time(0);
-        }
+public:
+    MemoryCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1)
+        : CalculatedValue<T>(botAI, name, checkInterval)
+    {
+        lastChangeTime = time(0);
+    }
 
-        virtual bool EqualToLast(T value) = 0;
-        virtual bool CanCheckChange()
-        {
-            return time(0) - lastChangeTime < minChangeInterval || EqualToLast(this->value);
-        }
+    virtual bool EqualToLast(T value) = 0;
+    virtual bool CanCheckChange() { return time(0) - lastChangeTime < minChangeInterval || EqualToLast(this->value); }
 
-        virtual bool UpdateChange()
-        {
-            if (CanCheckChange())
-                return false;
+    virtual bool UpdateChange()
+    {
+        if (CanCheckChange())
+            return false;
 
-            lastChangeTime = time(0);
-            lastValue = this->value;
-            return true;
-        }
+        lastChangeTime = time(0);
+        lastValue = this->value;
+        return true;
+    }
 
-        void Set([[maybe_unused]] T value) override
-        {
-            CalculatedValue<T>::Set(this->value);
-            UpdateChange();
-        }
+    void Set([[maybe_unused]] T value) override
+    {
+        CalculatedValue<T>::Set(this->value);
+        UpdateChange();
+    }
 
-        T Get() override
-        {
-            this->value = CalculatedValue<T>::Get();
-            UpdateChange();
-            return this->value;
-        }
+    T Get() override
+    {
+        this->value = CalculatedValue<T>::Get();
+        UpdateChange();
+        return this->value;
+    }
 
-        T LazyGet() override
-        {
-            return this->value;
-        }
+    T LazyGet() override { return this->value; }
 
-        time_t LastChangeOn()
-        {
-            Get();
-            UpdateChange();
-            return lastChangeTime;
-        }
+    time_t LastChangeOn()
+    {
+        Get();
+        UpdateChange();
+        return lastChangeTime;
+    }
 
-        uint32 LastChangeDelay() { return time(0) - LastChangeOn(); }
+    uint32 LastChangeDelay() { return time(0) - LastChangeOn(); }
 
-        void Reset() override
-        {
-            CalculatedValue<T>::Reset();
-            lastChangeTime = time(0);
-        }
+    void Reset() override
+    {
+        CalculatedValue<T>::Reset();
+        lastChangeTime = time(0);
+    }
 
-    protected:
-        T lastValue;
-        uint32 minChangeInterval = 0;
-        time_t lastChangeTime;
+protected:
+    T lastValue;
+    uint32 minChangeInterval = 0;
+    time_t lastChangeTime;
 };
 
-template<class T>
+template <class T>
 class LogCalculatedValue : public MemoryCalculatedValue<T>
 {
-    public:
-        LogCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1) : MemoryCalculatedValue<T>(botAI, name, checkInterval) { }
+public:
+    LogCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1)
+        : MemoryCalculatedValue<T>(botAI, name, checkInterval)
+    {
+    }
 
-        bool UpdateChange() override
-        {
-            if (MemoryCalculatedValue<T>::UpdateChange())
-                return false;
+    bool UpdateChange() override
+    {
+        if (MemoryCalculatedValue<T>::UpdateChange())
+            return false;
 
-            valueLog.push_back(std::make_pair(this->value, time(0)));
+        valueLog.push_back(std::make_pair(this->value, time(0)));
 
-            if (valueLog.size() > logLength)
-                valueLog.pop_front();
-            return true;
-        }
+        if (valueLog.size() > logLength)
+            valueLog.pop_front();
+        return true;
+    }
 
-        std::list<std::pair<T, time_t>> ValueLog() { return valueLog; }
+    std::list<std::pair<T, time_t>> ValueLog() { return valueLog; }
 
-        void Reset() override
-        {
-            MemoryCalculatedValue<T>::Reset();
-            valueLog.clear();
-        }
+    void Reset() override
+    {
+        MemoryCalculatedValue<T>::Reset();
+        valueLog.clear();
+    }
 
-    protected:
-        std::list<std::pair<T, time_t>> valueLog;
-        uint8 logLength = 10;
-    };
+protected:
+    std::list<std::pair<T, time_t>> valueLog;
+    uint8 logLength = 10;
+};
 
 class Uint8CalculatedValue : public CalculatedValue<uint8>
 {
-    public:
-        Uint8CalculatedValue(PlayerbotAI* botAI, std::string const name = "value", uint32 checkInterval = 1) :
-            CalculatedValue<uint8>(botAI, name, checkInterval) { }
+public:
+    Uint8CalculatedValue(PlayerbotAI* botAI, std::string const name = "value", uint32 checkInterval = 1)
+        : CalculatedValue<uint8>(botAI, name, checkInterval)
+    {
+    }
 
-        std::string const Format() override;
+    std::string const Format() override;
 };
 
 class Uint32CalculatedValue : public CalculatedValue<uint32>
 {
-    public:
-        Uint32CalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int checkInterval = 1) :
-            CalculatedValue<uint32>(botAI, name, checkInterval) { }
+public:
+    Uint32CalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int checkInterval = 1)
+        : CalculatedValue<uint32>(botAI, name, checkInterval)
+    {
+    }
 
-        std::string const Format() override;
+    std::string const Format() override;
 };
 
 class FloatCalculatedValue : public CalculatedValue<float>
 {
-    public:
-        FloatCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int checkInterval = 1) :
-            CalculatedValue<float>(botAI, name, checkInterval) { }
+public:
+    FloatCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int checkInterval = 1)
+        : CalculatedValue<float>(botAI, name, checkInterval)
+    {
+    }
 
-        std::string const Format() override;
+    std::string const Format() override;
 };
 
 class BoolCalculatedValue : public CalculatedValue<bool>
 {
-    public:
-        BoolCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int checkInterval = 1) :
-            CalculatedValue<bool>(botAI, name, checkInterval) { }
+public:
+    BoolCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int checkInterval = 1)
+        : CalculatedValue<bool>(botAI, name, checkInterval)
+    {
+    }
 
-        std::string const Format() override
-        {
-            return Calculate() ? "true" : "false";
-        }
+    std::string const Format() override { return Calculate() ? "true" : "false"; }
 };
 
 class UnitCalculatedValue : public CalculatedValue<Unit*>
 {
-    public:
-        UnitCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
+public:
+    UnitCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
 
-        std::string const Format() override;
-        Unit* Get() override;
+    std::string const Format() override;
+    Unit* Get() override;
 };
 
 class CDPairCalculatedValue : public CalculatedValue<CreatureData const*>
 {
-    public:
-        CDPairCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
+public:
+    CDPairCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
 
-        std::string const Format() override;
+    std::string const Format() override;
 };
 
 class CDPairListCalculatedValue : public CalculatedValue<std::vector<CreatureData const*>>
 {
-    public:
-        CDPairListCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
+public:
+    CDPairListCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
 
-        std::string const Format() override;
+    std::string const Format() override;
 };
 
 class ObjectGuidCalculatedValue : public CalculatedValue<ObjectGuid>
 {
-    public:
-        ObjectGuidCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
+public:
+    ObjectGuidCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
 
-        std::string const Format() override;
+    std::string const Format() override;
 };
 
 class ObjectGuidListCalculatedValue : public CalculatedValue<GuidVector>
 {
-    public:
-        ObjectGuidListCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
+public:
+    ObjectGuidListCalculatedValue(PlayerbotAI* botAI, std::string const name = "value", int32 checkInterval = 1);
 
-        std::string const Format() override;
+    std::string const Format() override;
 };
 
-template<class T>
+template <class T>
 class ManualSetValue : public UntypedValue, public Value<T>
 {
-    public:
-        ManualSetValue(PlayerbotAI* botAI, T defaultValue, std::string const name = "value") :
-            UntypedValue(botAI, name), value(defaultValue), defaultValue(defaultValue) { }
+public:
+    ManualSetValue(PlayerbotAI* botAI, T defaultValue, std::string const name = "value")
+        : UntypedValue(botAI, name), value(defaultValue), defaultValue(defaultValue)
+    {
+    }
 
-        virtual ~ManualSetValue() { }
+    virtual ~ManualSetValue() {}
 
-        T Get() override { return value; }
-        T LazyGet() override { return value; }
-        T& RefGet() override { return value; }
-        void Set(T val) override { value = val; }
-        void Update() override {}
-        void Reset() override
-        {
-            value = defaultValue;
-        }
+    T Get() override { return value; }
+    T LazyGet() override { return value; }
+    T& RefGet() override { return value; }
+    void Set(T val) override { value = val; }
+    void Update() override {}
+    void Reset() override { value = defaultValue; }
 
-    protected:
-        T value;
-        T defaultValue;
+protected:
+    T value;
+    T defaultValue;
 };
 
 class UnitManualSetValue : public ManualSetValue<Unit*>
 {
-    public:
-        UnitManualSetValue(PlayerbotAI* botAI, Unit* defaultValue, std::string const name = "value") :
-            ManualSetValue<Unit*>(botAI, defaultValue, name) { }
+public:
+    UnitManualSetValue(PlayerbotAI* botAI, Unit* defaultValue, std::string const name = "value")
+        : ManualSetValue<Unit*>(botAI, defaultValue, name)
+    {
+    }
 
-        std::string const Format() override;
-        Unit* Get() override;
+    std::string const Format() override;
+    Unit* Get() override;
 };
 
 class DisperseDistanceValue : public ManualSetValue<float>
 {
-    public:
-        DisperseDistanceValue(PlayerbotAI* botAI, float defaultValue = -1.0f, std::string const name = "disperse distance") :
-            ManualSetValue<float>(botAI, defaultValue, name) { }
+public:
+    DisperseDistanceValue(PlayerbotAI* botAI, float defaultValue = -1.0f, std::string const name = "disperse distance")
+        : ManualSetValue<float>(botAI, defaultValue, name)
+    {
+    }
 };
 
 class LastFleeAngleValue : public ManualSetValue<float>
 {
-    public:
-        LastFleeAngleValue(PlayerbotAI* botAI, float defaultValue = 0.0f, std::string const name = "last flee angle") :
-            ManualSetValue<float>(botAI, defaultValue, name) { }
+public:
+    LastFleeAngleValue(PlayerbotAI* botAI, float defaultValue = 0.0f, std::string const name = "last flee angle")
+        : ManualSetValue<float>(botAI, defaultValue, name)
+    {
+    }
 };
 
 class LastFleeTimestampValue : public ManualSetValue<uint32>
 {
-    public:
-        LastFleeTimestampValue(PlayerbotAI* botAI, uint32 defaultValue = 0, std::string const name = "last flee timestamp") :
-            ManualSetValue<uint32>(botAI, defaultValue, name) { }
+public:
+    LastFleeTimestampValue(PlayerbotAI* botAI, uint32 defaultValue = 0, std::string const name = "last flee timestamp")
+        : ManualSetValue<uint32>(botAI, defaultValue, name)
+    {
+    }
 };
 
 class RecentlyFleeInfo : public ManualSetValue<std::list<FleeInfo>>
 {
-    public:
-        RecentlyFleeInfo(PlayerbotAI* botAI, std::list<FleeInfo> defaultValue = {}, std::string const name = "recently flee info") :
-            ManualSetValue<std::list<FleeInfo>>(botAI, defaultValue, name) { }
+public:
+    RecentlyFleeInfo(PlayerbotAI* botAI, std::list<FleeInfo> defaultValue = {},
+                     std::string const name = "recently flee info")
+        : ManualSetValue<std::list<FleeInfo>>(botAI, defaultValue, name)
+    {
+    }
 };
 
 #endif