Convert Vulkan MemoryPropertyFlags to MemoryPropertyFlagBits

In the Vulkan c++ API, physical_device.getMemoryProperties().memoryTypes returns an instance of MemoryPropertyFlags, aka Flags<MemoryPropertyFlagBits>.
I'd like to simply recover the bit mask to easily match it with MemoryPropertyFlagBits for buffer creation requests.

I realize it is a simple question but for some reason I am unable to find any information on Flags and navigating though the headers leads me nowhere. All I know from clang completion is that Flags has a few binary operators.

In vulkan.hpp the Flags class is defined as

template <typename BitType>
class Flags
{
public:
    using MaskType = typename std::underlying_type<BitType>::type;

    // constructors
    constexpr Flags() noexcept : m_mask( 0 ) {}

    constexpr Flags( BitType bit ) noexcept : m_mask( static_cast<MaskType>( bit ) ) {}

    constexpr Flags( Flags<BitType> const & rhs ) noexcept = default;

    constexpr explicit Flags( MaskType flags ) noexcept : m_mask( flags ) {}

    // relational operators
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( Flags<BitType> const & ) const = default;
#else
    constexpr bool operator<( Flags<BitType> const & rhs ) const noexcept
    {
        return m_mask < rhs.m_mask;
    }

    constexpr bool operator<=( Flags<BitType> const & rhs ) const noexcept
    {
        return m_mask <= rhs.m_mask;
    }

    constexpr bool operator>( Flags<BitType> const & rhs ) const noexcept
    {
        return m_mask > rhs.m_mask;
    }

    constexpr bool operator>=( Flags<BitType> const & rhs ) const noexcept
    {
        return m_mask >= rhs.m_mask;
    }

    constexpr bool operator==( Flags<BitType> const & rhs ) const noexcept
    {
        return m_mask == rhs.m_mask;
    }

    constexpr bool operator!=( Flags<BitType> const & rhs ) const noexcept
    {
        return m_mask != rhs.m_mask;
    }
#endif

    // logical operator
    constexpr bool operator!() const noexcept
    {
        return !m_mask;
    }

    // bitwise operators
    constexpr Flags<BitType> operator&( Flags<BitType> const & rhs ) const noexcept
    {
        return Flags<BitType>( m_mask & rhs.m_mask );
    }

    constexpr Flags<BitType> operator|( Flags<BitType> const & rhs ) const noexcept
    {
        return Flags<BitType>( m_mask | rhs.m_mask );
    }

    constexpr Flags<BitType> operator^( Flags<BitType> const & rhs ) const noexcept
    {
        return Flags<BitType>( m_mask ^ rhs.m_mask );
    }

    constexpr Flags<BitType> operator~() const noexcept
    {
        return Flags<BitType>( m_mask ^ FlagTraits<BitType>::allFlags.m_mask );
    }

    // assignment operators
    constexpr Flags<BitType> & operator=( Flags<BitType> const & rhs ) noexcept = default;

    constexpr Flags<BitType> & operator|=( Flags<BitType> const & rhs ) noexcept
    {
        m_mask |= rhs.m_mask;
        return *this;
    }

    constexpr Flags<BitType> & operator&=( Flags<BitType> const & rhs ) noexcept
    {
        m_mask &= rhs.m_mask;
        return *this;
    }

    constexpr Flags<BitType> & operator^=( Flags<BitType> const & rhs ) noexcept
    {
        m_mask ^= rhs.m_mask;
        return *this;
    }

    // cast operators
    explicit constexpr operator bool() const noexcept
    {
        return !!m_mask;
    }

    explicit constexpr operator MaskType() const noexcept
    {
        return m_mask;
    }

#if defined( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC )
public:
#else
private:
#endif
    MaskType m_mask;
};

The Flags class can be constructed by passing in the bit type, or the underlying type (VkMemoryPropertyFlagBits is an enum, and the underlying type is probably going to be something like an int). There is an explicit operator to get out the underlying value, which can be accessed by static casting the Flags class to the underlying type. You can also declare VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC in your compile flags and access the mask directly. There are of course also all necessary operators defined to interact with the Flags class as if it were a raw integer.

Given VkFlags is a uint32_t I'm not sure why they don't offer an implicit or explicit cast to VkFlags.

The safest way would probably be

vk::Flags<VkMemoryPropertyFlagBits> flags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
VkFlags vkFlags = static_cast<decltype(flags)::MaskType>(flags);

This will always cast it to the correct type (using the wrong type will produce a compile error), and the conversion between MaskType and VkFlags should be implicit.