Run clang-format

src/strategy/ItemVisitors.h

@@ -1,5 +1,6 @@
 /*
- * 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_ITEMVISITORS_H
@@ -17,407 +18,401 @@ char* strstri(char const* str1, char const* str2);
 
 enum IterateItemsMask : uint32
 {
-    ITERATE_ITEMS_IN_BAGS   = 1,
-    ITERATE_ITEMS_IN_EQUIP  = 2,
-    ITERATE_ITEMS_IN_BANK   = 4,
-    ITERATE_ALL_ITEMS       = 255
+    ITERATE_ITEMS_IN_BAGS = 1,
+    ITERATE_ITEMS_IN_EQUIP = 2,
+    ITERATE_ITEMS_IN_BANK = 4,
+    ITERATE_ALL_ITEMS = 255
 };
 
 class IterateItemsVisitor
 {
-    public:
-        IterateItemsVisitor() { }
+public:
+    IterateItemsVisitor() {}
 
-        virtual bool Visit(Item* item) = 0;
+    virtual bool Visit(Item* item) = 0;
 };
 
 class FindItemVisitor : public IterateItemsVisitor
 {
-    public:
-        FindItemVisitor() : IterateItemsVisitor(), result() { }
+public:
+    FindItemVisitor() : IterateItemsVisitor(), result() {}
 
-        bool Visit(Item* item) override
-        {
-            if (!Accept(item->GetTemplate()))
-                return true;
-
-            result.push_back(item);
+    bool Visit(Item* item) override
+    {
+        if (!Accept(item->GetTemplate()))
             return true;
-        }
 
-        std::vector<Item*>& GetResult() { return result; }
+        result.push_back(item);
+        return true;
+    }
 
-    protected:
-        virtual bool Accept(ItemTemplate const* proto) = 0;
+    std::vector<Item*>& GetResult() { return result; }
 
-    private:
-        std::vector<Item*> result;
+protected:
+    virtual bool Accept(ItemTemplate const* proto) = 0;
+
+private:
+    std::vector<Item*> result;
 };
 
 class FindUsableItemVisitor : public FindItemVisitor
 {
-    public:
-        FindUsableItemVisitor(Player* bot) : FindItemVisitor(), bot(bot) { }
+public:
+    FindUsableItemVisitor(Player* bot) : FindItemVisitor(), bot(bot) {}
 
-        bool Visit(Item* item) override;
+    bool Visit(Item* item) override;
 
-    private:
-        Player* bot;
+private:
+    Player* bot;
 };
 
 class FindItemsByQualityVisitor : public IterateItemsVisitor
 {
-    public:
-        FindItemsByQualityVisitor(uint32 quality, uint32 count) : IterateItemsVisitor(), quality(quality), count(count) { }
+public:
+    FindItemsByQualityVisitor(uint32 quality, uint32 count) : IterateItemsVisitor(), quality(quality), count(count) {}
 
-        bool Visit(Item* item) override
-        {
-            if (item->GetTemplate()->Quality != quality)
-                return true;
-
-            if (result.size() >= (size_t)count)
-                return false;
-
-            result.push_back(item);
+    bool Visit(Item* item) override
+    {
+        if (item->GetTemplate()->Quality != quality)
             return true;
-        }
 
-        std::vector<Item*>& GetResult()
-        {
-            return result;
-        }
+        if (result.size() >= (size_t)count)
+            return false;
 
-    private:
-        uint32 quality;
-        uint32 count;
-        std::vector<Item*> result;
+        result.push_back(item);
+        return true;
+    }
+
+    std::vector<Item*>& GetResult() { return result; }
+
+private:
+    uint32 quality;
+    uint32 count;
+    std::vector<Item*> result;
 };
 
 class FindItemsToTradeByQualityVisitor : public FindItemsByQualityVisitor
 {
-    public:
-        FindItemsToTradeByQualityVisitor(uint32 quality, uint32 count) : FindItemsByQualityVisitor(quality, count) { }
+public:
+    FindItemsToTradeByQualityVisitor(uint32 quality, uint32 count) : FindItemsByQualityVisitor(quality, count) {}
 
-        bool Visit(Item* item) override
-        {
-            if (item->IsSoulBound())
-                return true;
+    bool Visit(Item* item) override
+    {
+        if (item->IsSoulBound())
+            return true;
 
-            return FindItemsByQualityVisitor::Visit(item);
-        }
+        return FindItemsByQualityVisitor::Visit(item);
+    }
 };
 
 class FindItemsToTradeByClassVisitor : public IterateItemsVisitor
 {
-    public:
-        FindItemsToTradeByClassVisitor(uint32 itemClass, uint32 itemSubClass, uint32 count)
-            : IterateItemsVisitor(), itemClass(itemClass), itemSubClass(itemSubClass), count(count) { } // reorder args - whipowill
+public:
+    FindItemsToTradeByClassVisitor(uint32 itemClass, uint32 itemSubClass, uint32 count)
+        : IterateItemsVisitor(), itemClass(itemClass), itemSubClass(itemSubClass), count(count)
+    {
+    }  // reorder args - whipowill
 
-        bool Visit(Item* item) override
-        {
-            if (item->IsSoulBound())
-                return true;
-
-            if (item->GetTemplate()->Class != itemClass || item->GetTemplate()->SubClass != itemSubClass)
-                return true;
-
-            if (result.size() >= (size_t)count)
-                return false;
-
-            result.push_back(item);
+    bool Visit(Item* item) override
+    {
+        if (item->IsSoulBound())
             return true;
-        }
 
-        std::vector<Item*>& GetResult()
-        {
-            return result;
-        }
+        if (item->GetTemplate()->Class != itemClass || item->GetTemplate()->SubClass != itemSubClass)
+            return true;
 
-    private:
-        uint32 itemClass;
-        uint32 itemSubClass;
-        uint32 count;
-        std::vector<Item*> result;
+        if (result.size() >= (size_t)count)
+            return false;
+
+        result.push_back(item);
+        return true;
+    }
+
+    std::vector<Item*>& GetResult() { return result; }
+
+private:
+    uint32 itemClass;
+    uint32 itemSubClass;
+    uint32 count;
+    std::vector<Item*> result;
 };
 
 class QueryItemCountVisitor : public IterateItemsVisitor
 {
-    public:
-        QueryItemCountVisitor(uint32 itemId) : count(0), itemId(itemId) { }
+public:
+    QueryItemCountVisitor(uint32 itemId) : count(0), itemId(itemId) {}
 
-        bool Visit(Item* item) override
-        {
-            if (item->GetTemplate()->ItemId == itemId)
-                count += item->GetCount();
+    bool Visit(Item* item) override
+    {
+        if (item->GetTemplate()->ItemId == itemId)
+            count += item->GetCount();
 
-            return true;
-        }
+        return true;
+    }
 
-        uint32 GetCount() { return count; }
+    uint32 GetCount() { return count; }
 
-    protected:
-        uint32 count;
-        uint32 itemId;
+protected:
+    uint32 count;
+    uint32 itemId;
 };
 
 class QueryNamedItemCountVisitor : public QueryItemCountVisitor
 {
-    public:
-        QueryNamedItemCountVisitor(std::string const name) : QueryItemCountVisitor(0), name(name) { }
+public:
+    QueryNamedItemCountVisitor(std::string const name) : QueryItemCountVisitor(0), name(name) {}
 
-        bool Visit(Item* item) override
-        {
-            ItemTemplate const* proto = item->GetTemplate();
-            if (proto && proto->Name1.c_str() && strstri(proto->Name1.c_str(), name.c_str()))
-                count += item->GetCount();
+    bool Visit(Item* item) override
+    {
+        ItemTemplate const* proto = item->GetTemplate();
+        if (proto && proto->Name1.c_str() && strstri(proto->Name1.c_str(), name.c_str()))
+            count += item->GetCount();
 
-            return true;
-        }
+        return true;
+    }
 
-    private:
-        std::string const name;
+private:
+    std::string const name;
 };
 
 class FindNamedItemVisitor : public FindItemVisitor
 {
-    public:
-        FindNamedItemVisitor([[maybe_unused]] Player* bot, std::string const name) : FindItemVisitor(), name(name) { }
+public:
+    FindNamedItemVisitor([[maybe_unused]] Player* bot, std::string const name) : FindItemVisitor(), name(name) {}
 
-        bool Accept(ItemTemplate const* proto) override
-        {
-            return proto && proto->Name1.c_str() && strstri(proto->Name1.c_str(), name.c_str());
-        }
+    bool Accept(ItemTemplate const* proto) override
+    {
+        return proto && proto->Name1.c_str() && strstri(proto->Name1.c_str(), name.c_str());
+    }
 
-    private:
-        std::string const name;
+private:
+    std::string const name;
 };
 
 class FindItemByIdVisitor : public FindItemVisitor
 {
-    public:
-        FindItemByIdVisitor(uint32 id) : FindItemVisitor(), id(id) { }
+public:
+    FindItemByIdVisitor(uint32 id) : FindItemVisitor(), id(id) {}
 
-        bool Accept(ItemTemplate const* proto) override
-        {
-            return proto->ItemId == id;
-        }
+    bool Accept(ItemTemplate const* proto) override { return proto->ItemId == id; }
 
-    private:
-        uint32 id;
+private:
+    uint32 id;
 };
 
 class FindItemByIdsVisitor : public FindItemVisitor
 {
-    public:
-        FindItemByIdsVisitor(ItemIds ids) : FindItemVisitor(), ids(ids) { }
+public:
+    FindItemByIdsVisitor(ItemIds ids) : FindItemVisitor(), ids(ids) {}
 
-        bool Accept(ItemTemplate const* proto) override
-        {
-            return ids.find(proto->ItemId) != ids.end();
-        }
+    bool Accept(ItemTemplate const* proto) override { return ids.find(proto->ItemId) != ids.end(); }
 
-    private:
-        ItemIds ids;
+private:
+    ItemIds ids;
 };
 
 class ListItemsVisitor : public IterateItemsVisitor
 {
-    public:
-        ListItemsVisitor() : IterateItemsVisitor() { }
+public:
+    ListItemsVisitor() : IterateItemsVisitor() {}
 
-        std::map<uint32, uint32> items;
-        std::map<uint32, bool> soulbound;
+    std::map<uint32, uint32> items;
+    std::map<uint32, bool> soulbound;
 
-        bool Visit(Item* item) override
-        {
-            uint32 id = item->GetTemplate()->ItemId;
+    bool Visit(Item* item) override
+    {
+        uint32 id = item->GetTemplate()->ItemId;
 
-            if (items.find(id) == items.end())
-                items[id] = 0;
+        if (items.find(id) == items.end())
+            items[id] = 0;
 
-            items[id] += item->GetCount();
-            soulbound[id] = item->IsSoulBound();
-            return true;
-        }
+        items[id] += item->GetCount();
+        soulbound[id] = item->IsSoulBound();
+        return true;
+    }
 };
 
 class ItemCountByQuality : public IterateItemsVisitor
 {
-    public:
-        ItemCountByQuality() : IterateItemsVisitor()
-        {
-            for (uint32 i = 0; i < MAX_ITEM_QUALITY; ++i)
-                count[i] = 0;
-        }
+public:
+    ItemCountByQuality() : IterateItemsVisitor()
+    {
+        for (uint32 i = 0; i < MAX_ITEM_QUALITY; ++i)
+            count[i] = 0;
+    }
 
-        bool Visit(Item* item) override
-        {
-            ++count[item->GetTemplate()->Quality];
-            return true;
-        }
+    bool Visit(Item* item) override
+    {
+        ++count[item->GetTemplate()->Quality];
+        return true;
+    }
 
-    public:
-        std::map<uint32, uint32> count;
+public:
+    std::map<uint32, uint32> count;
 };
 
 class FindPotionVisitor : public FindUsableItemVisitor
 {
-    public:
-        FindPotionVisitor(Player* bot, uint32 effectId) : FindUsableItemVisitor(bot), effectId(effectId) { }
+public:
+    FindPotionVisitor(Player* bot, uint32 effectId) : FindUsableItemVisitor(bot), effectId(effectId) {}
 
-        bool Accept(ItemTemplate const* proto) override;
+    bool Accept(ItemTemplate const* proto) override;
 
-    private:
-        uint32 effectId;
+private:
+    uint32 effectId;
 };
 
 class FindFoodVisitor : public FindUsableItemVisitor
 {
-    public:
-        FindFoodVisitor(Player* bot, uint32 spellCategory, bool conjured = false) : FindUsableItemVisitor(bot),
-            spellCategory(spellCategory), conjured(conjured) { }
+public:
+    FindFoodVisitor(Player* bot, uint32 spellCategory, bool conjured = false)
+        : FindUsableItemVisitor(bot), spellCategory(spellCategory), conjured(conjured)
+    {
+    }
 
-        bool Accept(ItemTemplate const* proto) override
-        {
-            return proto->Class == ITEM_CLASS_CONSUMABLE && (proto->SubClass == ITEM_SUBCLASS_CONSUMABLE || proto->SubClass == ITEM_SUBCLASS_FOOD) &&
-                proto->Spells[0].SpellCategory == spellCategory && (!conjured || proto->IsConjuredConsumable());
-        }
+    bool Accept(ItemTemplate const* proto) override
+    {
+        return proto->Class == ITEM_CLASS_CONSUMABLE &&
+               (proto->SubClass == ITEM_SUBCLASS_CONSUMABLE || proto->SubClass == ITEM_SUBCLASS_FOOD) &&
+               proto->Spells[0].SpellCategory == spellCategory && (!conjured || proto->IsConjuredConsumable());
+    }
 
-    private:
-        uint32 spellCategory;
-        bool conjured;
+private:
+    uint32 spellCategory;
+    bool conjured;
 };
 
 class FindMountVisitor : public FindUsableItemVisitor
 {
-    public:
-        FindMountVisitor(Player* bot) : FindUsableItemVisitor(bot) { }
+public:
+    FindMountVisitor(Player* bot) : FindUsableItemVisitor(bot) {}
 
-        bool Accept(ItemTemplate const* proto) override;
+    bool Accept(ItemTemplate const* proto) override;
 
-    private:
-        uint32 effectId;
+private:
+    uint32 effectId;
 };
 
 class FindPetVisitor : public FindUsableItemVisitor
 {
-    public:
-        FindPetVisitor(Player* bot) : FindUsableItemVisitor(bot) { }
+public:
+    FindPetVisitor(Player* bot) : FindUsableItemVisitor(bot) {}
 
-        bool Accept(ItemTemplate const* proto) override;
+    bool Accept(ItemTemplate const* proto) override;
 };
 
 class FindAmmoVisitor : public FindUsableItemVisitor
 {
-    public:
-        FindAmmoVisitor(Player* bot, uint32 weaponType) : FindUsableItemVisitor(bot), weaponType(weaponType) { }
+public:
+    FindAmmoVisitor(Player* bot, uint32 weaponType) : FindUsableItemVisitor(bot), weaponType(weaponType) {}
 
-        bool Accept(ItemTemplate const* proto)override
+    bool Accept(ItemTemplate const* proto) override
+    {
+        if (proto->Class == ITEM_CLASS_PROJECTILE)
         {
-            if (proto->Class == ITEM_CLASS_PROJECTILE)
+            uint32 subClass = 0;
+            switch (weaponType)
             {
-                uint32 subClass = 0;
-                switch (weaponType)
-                {
-                    case ITEM_SUBCLASS_WEAPON_GUN:
-                        subClass = ITEM_SUBCLASS_BULLET;
-                        break;
-                    case ITEM_SUBCLASS_WEAPON_BOW:
-                    case ITEM_SUBCLASS_WEAPON_CROSSBOW:
-                        subClass = ITEM_SUBCLASS_ARROW;
-                        break;
-                }
-
-                if (!subClass)
-                    return false;
-
-                if (proto->SubClass == subClass)
-                    return true;
+                case ITEM_SUBCLASS_WEAPON_GUN:
+                    subClass = ITEM_SUBCLASS_BULLET;
+                    break;
+                case ITEM_SUBCLASS_WEAPON_BOW:
+                case ITEM_SUBCLASS_WEAPON_CROSSBOW:
+                    subClass = ITEM_SUBCLASS_ARROW;
+                    break;
             }
 
-            return false;
+            if (!subClass)
+                return false;
+
+            if (proto->SubClass == subClass)
+                return true;
         }
 
-    private:
-        uint32 weaponType;
+        return false;
+    }
+
+private:
+    uint32 weaponType;
 };
 
 class FindQuestItemVisitor : public FindUsableItemVisitor
 {
-    public:
-        FindQuestItemVisitor(Player* bot) : FindUsableItemVisitor(bot) { }
+public:
+    FindQuestItemVisitor(Player* bot) : FindUsableItemVisitor(bot) {}
 
-        bool Accept(ItemTemplate const* proto) override
+    bool Accept(ItemTemplate const* proto) override
+    {
+        if (proto->Class == ITEM_CLASS_QUEST)
         {
-            if (proto->Class == ITEM_CLASS_QUEST)
-            {
-                return true;
-            }
-            return false;
+            return true;
         }
+        return false;
+    }
 };
 
 class FindRecipeVisitor : public FindUsableItemVisitor
 {
-    public:
-        FindRecipeVisitor(Player* bot, SkillType skill = SKILL_NONE) : FindUsableItemVisitor(bot), skill(skill) { };
+public:
+    FindRecipeVisitor(Player* bot, SkillType skill = SKILL_NONE) : FindUsableItemVisitor(bot), skill(skill){};
 
-        bool Accept(ItemTemplate const* proto) override
+    bool Accept(ItemTemplate const* proto) override
+    {
+        if (proto->Class == ITEM_CLASS_RECIPE)
         {
-            if (proto->Class == ITEM_CLASS_RECIPE)
+            if (skill == SKILL_NONE)
+                return true;
+
+            switch (proto->SubClass)
             {
-                if (skill == SKILL_NONE)
-                    return true;
-
-                switch (proto->SubClass)
-                {
-                    case ITEM_SUBCLASS_LEATHERWORKING_PATTERN:
-                        return skill == SKILL_LEATHERWORKING;
-                    case ITEM_SUBCLASS_TAILORING_PATTERN:
-                        return skill == SKILL_TAILORING;
-                    case ITEM_SUBCLASS_ENGINEERING_SCHEMATIC:
-                        return skill == SKILL_ENGINEERING;
-                    case ITEM_SUBCLASS_BLACKSMITHING:
-                        return skill == SKILL_BLACKSMITHING;
-                    case ITEM_SUBCLASS_COOKING_RECIPE:
-                        return skill == SKILL_COOKING;
-                    case ITEM_SUBCLASS_ALCHEMY_RECIPE:
-                        return skill == SKILL_ALCHEMY;
-                    case ITEM_SUBCLASS_FIRST_AID_MANUAL:
-                        return skill == SKILL_FIRST_AID;
-                    case ITEM_SUBCLASS_ENCHANTING_FORMULA:
-                        return skill == SKILL_ENCHANTING;
-                    case ITEM_SUBCLASS_FISHING_MANUAL:
-                        return skill == SKILL_FISHING;
-                }
+                case ITEM_SUBCLASS_LEATHERWORKING_PATTERN:
+                    return skill == SKILL_LEATHERWORKING;
+                case ITEM_SUBCLASS_TAILORING_PATTERN:
+                    return skill == SKILL_TAILORING;
+                case ITEM_SUBCLASS_ENGINEERING_SCHEMATIC:
+                    return skill == SKILL_ENGINEERING;
+                case ITEM_SUBCLASS_BLACKSMITHING:
+                    return skill == SKILL_BLACKSMITHING;
+                case ITEM_SUBCLASS_COOKING_RECIPE:
+                    return skill == SKILL_COOKING;
+                case ITEM_SUBCLASS_ALCHEMY_RECIPE:
+                    return skill == SKILL_ALCHEMY;
+                case ITEM_SUBCLASS_FIRST_AID_MANUAL:
+                    return skill == SKILL_FIRST_AID;
+                case ITEM_SUBCLASS_ENCHANTING_FORMULA:
+                    return skill == SKILL_ENCHANTING;
+                case ITEM_SUBCLASS_FISHING_MANUAL:
+                    return skill == SKILL_FISHING;
             }
-
-            return false;
         }
 
-    private:
-        SkillType skill;
+        return false;
+    }
+
+private:
+    SkillType skill;
 };
 
 class FindItemUsageVisitor : public FindUsableItemVisitor
 {
-    public:
-        FindItemUsageVisitor(Player* bot, ItemUsage usage = ITEM_USAGE_NONE);
+public:
+    FindItemUsageVisitor(Player* bot, ItemUsage usage = ITEM_USAGE_NONE);
 
-        bool Accept(ItemTemplate const* proto) override;
+    bool Accept(ItemTemplate const* proto) override;
 
-    private:
-        AiObjectContext* context;
-        ItemUsage usage;
+private:
+    AiObjectContext* context;
+    ItemUsage usage;
 };
 
 class FindUsableNamedItemVisitor : public FindUsableItemVisitor
 {
-    public:
-        FindUsableNamedItemVisitor(Player* bot, std::string name): FindUsableItemVisitor(bot), name(name) {}
+public:
+    FindUsableNamedItemVisitor(Player* bot, std::string name) : FindUsableItemVisitor(bot), name(name) {}
 
-        bool Accept(ItemTemplate const* proto) override;
-    private:
-        std::string name;
+    bool Accept(ItemTemplate const* proto) override;
+
+private:
+    std::string name;
 };
 #endif