How can I have a static function inside a template class? - c++

Question

I'm not very good with C++ but I'm trying to create a generic base class that can be extended to create a kind of dynamic enum. There may be way better ways to do this and I'm open to suggestions but my main question here is why am I getting the error C2338 The C++ Standard doesn't provide a hash for this type.
Base Enums Template Class
template <typename T>
class Enums
{
public:
BOOL HasValue(T enumValue) const
{
auto it = this->m_EnumPairs.find(enumValue);
return (it != this->m_EnumPairs.end());
}
const DWORD Count() const
{
return this->m_EnumPairs.size();
}
const DWORD &operator[](T enumValue) const
{
auto it = this->m_EnumPairs.find(enumValue);
if (it == this->m_EnumPairs.end())
return 0;
return it->second;
}
const DWORD GetVersionCode() const
{
return this->m_VersionCode;
}
static const DWORD Count(DWORD versionCode)
{
T derived(versionCode);
return derived.Count();
}
protected:
DWORD m_VersionCode;
Enums(DWORD versionCode) : m_VersionCode(versionCode), m_NextValue(0) { }
virtual ~Enums() { }
void Add(T enumValue)
{
for (auto it = this->m_EnumPairs.cbegin(); it != this->m_EnumPairs.cend(); it++)
{
if (it->first == enumValue)
throw std::exception("Enum key already defined");
if (it->second == this->m_NextValue)
throw std::exception("Enum value already exists");
}
this->m_EnumPairs[enumValue] = this->m_NextValue++;
}
void Add(T enumValue, DWORD value)
{
this->m_NextValue = value;
this->Add(valueName);
}
private:
std::unordered_map<T, DWORD> m_EnumPairs;
DWORD m_NextValue;
};
Derived Enums .h
namespace Test
{
typedef enum _Enum
{
EnumValue1,
EnumValue2,
EnumValue3,
EnumValue4,
EnumValue5,
EnumValue6,
EnumValue7,
EnumValue8
} Enum;
}
class DerivedEnum : public Enums<Test::Enum>
{
public:
DerivedEnum(DWORD versionCode);
~DerivedEnum();
};
Derived Enums .cpp
DerivedEnum::DerivedEnum(DWORD versionCode) : Enums(versionCode)
{
this->Add(Test::EnumValue1);
this->Add(Test::EnumValue2);
this->Add(Test::EnumValue3);
this->Add(Test::EnumValue4);
this->Add(Test::EnumValue5);
this->Add(Test::EnumValue6);
if (versionCode > 200)
this->Add(Blocks::EnumValue7);
this->Add(Blocks::EnumValue8);
}
DerivedEnum::~DerivedEnum()
{
}
Usage
Enums<DerivedEnum>::Count(250)
I'm know I'm doing something wrong, I just want to know what I'm doing wrong and how I can do something like Enums<DerivedEnum>::Count(250). The error centers around the static Count function and the error goes completely away when I remove the static function and the call to it.
EDIT
To answer a question asked in the comments: The usage of this would be to get the size or number of entries in the "enum". For example, if I needed to read a structure from a file and in that structure is an array of items:
struct DataFromFile
{
int flags;
int array[SIZE_OF_ENUM];
}
If I have different versions of this file that contain a different number of items in the array, I can use the "enum" class to determine how many bytes to read based on Enums<DerivedEnum>::Count(250). If that doesn't make sense, I'll try to clarify even further.
UPDATE
As ZDF said in the comments, changing unordered_map to map fixed the issue. unordered_map requires a hash function and the default does not know how to hash my custom class, map does not require a hash and therefore works perfect in this situation.