Core/Misc: Partial merge of 3.3.5-dbedit:

- Added SmartEnum.h for enum iteration, stringification, and more, courtesy of krabicezpapundeklu/smart_enum
- Moved a bunch of enums in SharedDefines.h to the new system
- Miscellaneous utility methods ported

Core/Util: Redesign SmartEnum to properly work for large
 enums (>64 entries) and play nice with IDEs (PR #22768)

(cherry picked from commit 338e8ba0fea8b4b15120c96fff15a6c4b1a52593)
(cherry picked from commit f7ca0877a3736000a6e3b4ed09ac5f08b4d8e3f0)
(cherry picked from commit 207093475a177e9fd29696e80fdd06a11324782d)
(cherry picked from commit ee68cf33921944fd3f8c188044906998cf10ff2a)
(cherry picked from commit c16d461e16f0704bb11040faff30953d33ba2188)
(cherry picked from commit f6b0d99e2c0bc22b44d6f3cfdae50cbba7d51de8)
(cherry picked from commit bc1f456125c1b6c90617a514152d69c40ce64886)

1 files changed, 116 insertions, 0 deletions

diff --git a/src/common/Utilities/SmartEnum.h b/src/common/Utilities/SmartEnum.h
new file mode 100644
index 00000000000..0966469f454
--- /dev/null
+++ b/src/common/Utilities/SmartEnum.h
@@ -0,0 +1,116 @@
+/*
+ * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TRINITY_SMARTENUM_H
+#define TRINITY_SMARTENUM_H
+
+#include "IteratorPair.h"
+#include <iterator>
+
+struct EnumText
+{
+    EnumText(char const* c, char const* t, char const* d) : Constant(c), Title(t), Description(d) {}
+    // Enum constant of the value
+    char const* const Constant;
+    // Human-readable title of the value
+    char const* const Title;
+    // Human-readable description of the value
+    char const* const Description;
+};
+
+namespace Trinity
+{
+    namespace Impl
+    {
+        template <typename Enum>
+        struct EnumUtils
+        {
+            static size_t Count();
+            static EnumText ToString(Enum value);
+            static Enum FromIndex(size_t index);
+        };
+    }
+}
+
+class EnumUtils
+{
+    public:
+        template <typename Enum>
+        static size_t Count() { return Trinity::Impl::EnumUtils<Enum>::Count(); }
+        template <typename Enum>
+        static EnumText ToString(Enum value) { return Trinity::Impl::EnumUtils<Enum>::ToString(value); }
+        template <typename Enum>
+        static Enum FromIndex(size_t index) { return Trinity::Impl::EnumUtils<Enum>::FromIndex(index); }
+
+        template <typename Enum>
+        class Iterator
+        {
+            public:
+                using iterator_category = std::random_access_iterator_tag;
+                using value_type = Enum;
+                using pointer = Enum*;
+                using reference = Enum&;
+                using difference_type = std::ptrdiff_t;
+
+                Iterator() : _index(EnumUtils::Count<Enum>()) {}
+                explicit Iterator(size_t index) : _index(index) { }
+
+                bool operator==(const Iterator& other) const { return other._index == _index; }
+                bool operator!=(const Iterator& other) const { return !operator==(other); }
+                difference_type operator-(Iterator const& other) const { return _index - other._index; }
+                bool operator<(const Iterator& other) const { return _index < other._index; }
+                bool operator<=(const Iterator& other) const { return _index <= other._index; }
+                bool operator>(const Iterator& other) const { return _index > other._index; }
+                bool operator>=(const Iterator& other) const { return _index >= other._index; }
+
+                value_type operator[](difference_type d) const { return FromIndex<Enum>(_index + d); }
+                value_type operator*() const { return operator[](0); }
+
+                Iterator& operator+=(difference_type d) { _index += d; return *this; }
+                Iterator& operator++() { return operator+=(1); }
+                Iterator operator++(int) { Iterator i = *this; operator++(); return i; }
+                Iterator operator+(difference_type d) const { Iterator i = *this; i += d; return i; }
+
+                Iterator& operator-=(difference_type d) { _index -= d; return *this; }
+                Iterator& operator--() { return operator-=(1); }
+                Iterator operator--(int) { Iterator i = *this; operator--(); return i; }
+                Iterator operator-(difference_type d) const { Iterator i = *this; i -= d; return i; }
+
+            private:
+                difference_type _index;
+        };
+
+        template <typename Enum>
+        static Iterator<Enum> Begin() { return Iterator<Enum>(0); }
+
+        template <typename Enum>
+        static Iterator<Enum> End() { return Iterator<Enum>(); }
+
+        template <typename Enum>
+        static Trinity::IteratorPair<Iterator<Enum>> Iterate() { return { Begin<Enum>(), End<Enum>() }; }
+
+        template <typename Enum>
+        static char const* ToConstant(Enum value) { return ToString(value).Constant; }
+
+        template <typename Enum>
+        static char const* ToTitle(Enum value) { return ToString(value).Title; }
+
+        template <typename Enum>
+        static char const* ToDescription(Enum value) { return ToString(value).Description; }
+};
+
+#endif