Extensible Enum #100

#include <string>

char AsciiToUpper(const char c) noexcept {
    class AsciiToUpperTable {
        char m_map[256];
    public:
        constexpr AsciiToUpperTable() noexcept : m_map() {
            for (int idx = 0; idx < 256; ++idx) {
                m_map[idx] = static_cast<char>(static_cast<unsigned char>(idx));
            }
 
            for (int idx = 'a'; idx < 'z'; ++idx) {
                m_map[idx] = idx + ('a' - 'A');
            }
        } 
        char operator[](const char c) const noexcept { return m_map[static_cast<unsigned char>(c)]; }
    };
 
    static constexpr AsciiToUpperTable toUpperTable;
    return toUpperTable[c];
}
 
inline bool CaseInSensStringCompareCpp11(const std::string& str1, const std::string &str2) noexcept {
    return std::equal(str1.begin(), str1.end(), str2.begin(), str2.end(),
        [](const char lhs, const char rhs) noexcept { return AsciiToUpper(lhs) == AsciiToUpper(rhs); });
}


// This goes in a .cpp file:
    
/// <summary>
/// <see cref="JsonWebKey"/> key types.
/// </summary>
class KeyType {
    std::string mValue;

public:
    /// <summary>
    /// Initializes a new instance of the <see cref="KeyType"/> structure.
    /// </summary>
    /// <param name="value"></param>
    KeyType(const std::string& value) : mValue(value) { }

    KeyType(const char* value) : mValue(value) { }

    /// <summary>
    /// Determines if two <see cref="KeyType"/> values are the same.
    /// </summary>
    /// <param name="a">The first <see cref="KeyType"/> to compare.</param>
    /// <param name="b">The second <see cref="KeyType"/> to compare.</param>
    /// <returns>True if <paramref name="a"/> and <paramref name="b"/> are the same; otherwise, false.</returns>
    bool operator==(const KeyType& other) const noexcept { return CaseInSensStringCompareCpp11(mValue, other.mValue); }

    /// <summary>
    /// Determines if two <see cref="KeyType"/> values are different.
    /// </summary>
    /// <param name="a">The first <see cref="KeyType"/> to compare.</param>
    /// <param name="b">The second <see cref="KeyType"/> to compare.</param>
    /// <returns>True if <paramref name="a"/> and <paramref name="b"/> are different; otherwise, false.</returns>
    bool operator!=(const KeyType& other) const noexcept { return !(*this == other); }

    const std::string& Get() const noexcept { return mValue; }

    /// <summary>
    /// Elliptic curve cryptographic algorithm.
    /// </summary>
    const static KeyType Ec;

    /// <summary>
    /// Elliptic curve cryptographic algorithm backed by HSM.
    /// </summary>
    const static KeyType EcHsm;

    /// <summary>
    /// RSA cryptographic algorithm.
    /// </summary>
    const static KeyType Rsa;

    /// <summary>
    /// RSA cryptographic algorithm backed by HSM.
    /// </summary>
    const static KeyType RsaHsm;

    /// <summary>
    /// AES cryptographic algorithm.
    /// </summary>
    const static KeyType Oct;    
};

// These go in a .cpp file:
const KeyType KeyType::Ec = "EC";
const KeyType KeyType::EcHsm = "EC-HSM";
const KeyType KeyType::Rsa = "RSA";
const KeyType KeyType::RsaHsm = "RSA-HSM";
const KeyType KeyType::Oct = "oct";