hash_algorithm_name.h

 
#pragma once
 
#include <system/string.h>
#include <system/boxable_traits.h>
 
namespace System { namespace Security { namespace Cryptography {
 
struct HashAlgorithmName
{
    static HashAlgorithmName get_MD5()
    {
        return HashAlgorithmName(u"MD5");
    }
 
    static HashAlgorithmName get_SHA1()
    {
        return HashAlgorithmName(u"SHA1");
    }
 
    static HashAlgorithmName get_SHA256()
    {
        return HashAlgorithmName(u"SHA256");
    }
 
    static HashAlgorithmName get_SHA384()
    {
        return HashAlgorithmName(u"SHA384");
    }
 
    static HashAlgorithmName get_SHA512()
    {
        return HashAlgorithmName(u"SHA512");
    }
 
    static ASPOSECPP_SHARED_API bool TryFromOid(const String& oid_value, HashAlgorithmName& value);
 
    static ASPOSECPP_SHARED_API HashAlgorithmName FromOid(const String& oid_value);
 
    HashAlgorithmName() = default;
 
    HashAlgorithmName(const String& name)
        : m_name(name)
    {}
 
    HashAlgorithmName& operator=(const HashAlgorithmName&) = default;
 
    String get_Name() const
    {
        return m_name;
    }
 
    String ToString() const
    {
        return m_name == nullptr ? String::Empty : m_name;
    }
 
    bool Equals(const HashAlgorithmName& other) const
    {
        return m_name == other.m_name;
    }
 
    int GetHashCode() const
    {
        return m_name == nullptr ? 0 : m_name.GetHashCode();
    }
 
    bool operator==(const HashAlgorithmName& other) const
    {
        return Equals(other);
    }
 
    bool operator!=(const HashAlgorithmName& other) const
    {
        return !Equals(other);
    }
 
    static const TypeInfo& Type()
    {
        return *static_holder<ThisTypeInfo>();
    }
 
    bool IsNull() const { return false; }
    bool operator==(std::nullptr_t) const { return false; }
    bool operator!=(std::nullptr_t) const { return true; }
    bool operator<(std::nullptr_t) const { return false; }
    bool operator<=(std::nullptr_t) const { return false; }
    bool operator>(std::nullptr_t) const { return false; }
    bool operator>=(std::nullptr_t) const { return false; }
 
private:
    String m_name;
 
    struct ThisTypeInfo : TypeInfoPtr
    {
        ThisTypeInfo()
            : TypeInfoPtr(u"System::Security::Cryptography::HashAlgorithmName")
        {}
    };
};
 
constexpr bool operator==(std::nullptr_t, const HashAlgorithmName&) { return false; }
constexpr bool operator!=(std::nullptr_t, const HashAlgorithmName&) { return true; }
constexpr bool operator<(std::nullptr_t, const HashAlgorithmName&) { return false; }
constexpr bool operator<=(std::nullptr_t, const HashAlgorithmName&) { return false; }
constexpr bool operator>(std::nullptr_t, const HashAlgorithmName&) { return false; }
constexpr bool operator>=(std::nullptr_t, const HashAlgorithmName&) { return false; }
 
inline std::ostream& operator<<(std::ostream& stream, const HashAlgorithmName& name)
{
    stream << name.ToString();
    return stream;
}
 
inline std::wostream& operator<<(std::wostream& stream, const HashAlgorithmName& name)
{
    stream << name.ToString();
    return stream;
}
 
}}} // namespace System::Security::Cryptography
 
namespace System {
 
template<> struct IsBoxable<System::Security::Cryptography::HashAlgorithmName> : std::true_type {};
 
} // namespace System