3 files changed, 175 insertions, 0 deletions
diff --git a/src/common/Utilities/FuzzyFind.h b/src/common/Utilities/FuzzyFind.h
new file mode 100644
index 00000000000..e1c583af3b0
--- /dev/null
+++ b/src/common/Utilities/FuzzyFind.h
@@ -0,0 +1,53 @@
+/*
+ * 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_FUZZYFIND_H
+#define TRINITY_FUZZYFIND_H
+
+namespace Trinity
+{
+    namespace Containers
+    {
+        template <typename Container, typename NeedleContainer, typename ContainsOperator = bool(std::string const&, std::string const&), typename T = void>
+        auto FuzzyFindIn(Container const& container, NeedleContainer const& needles, ContainsOperator const& contains = StringContainsStringI, int(*bonus)(decltype((*std::begin(std::declval<Container>())))) = nullptr)
+        {
+            using IteratorResult = decltype((*std::begin(container)));
+            using MappedType = std::conditional_t<advstd::is_reference_v<IteratorResult>, std::reference_wrapper<std::remove_reference_t<IteratorResult>>, IteratorResult>;
+            std::multimap<size_t, MappedType, std::greater<size_t>> results;
+
+            for (auto outerIt = std::begin(container), outerEnd = std::end(container); outerIt != outerEnd; ++outerIt)
+            {
+                size_t count = 0;
+                for (auto innerIt = std::begin(needles), innerEnd = std::end(needles); innerIt != innerEnd; ++innerIt)
+                    if (contains(*outerIt, *innerIt))
+                        ++count;
+
+                if (!count)
+                    continue;
+
+                if (bonus)
+                    count += bonus(*outerIt);
+
+                results.emplace(count, *outerIt);
+            }
+
+            return results;
+        }
+    }
+}
+
+#endif
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
diff --git a/src/common/Utilities/Util.h b/src/common/Utilities/Util.h
index 27dee721d16..a858a44b556 100644
--- a/src/common/Utilities/Util.h
+++ b/src/common/Utilities/Util.h
@@ -22,6 +22,7 @@
 #include "Errors.h"
 #include <array>
 #include <string>
+#include <utility>
 #include <vector>
 #include "advstd.h"
 
@@ -351,6 +352,11 @@ TC_COMMON_API bool StringToBool(std::string const& str);
 TC_COMMON_API float DegToRad(float degrees);
 
 TC_COMMON_API bool StringContainsStringI(std::string const& haystack, std::string const& needle);
+template <typename T>
+inline bool ValueContainsStringI(std::pair<T, std::string> const& haystack, std::string const& needle)
+{
+    return StringContainsStringI(haystack.second, needle);
+}
 
 // simple class for not-modifyable list
 template <typename T>