init

Telegram/lib_base/base/flags.h

@@ -0,0 +1,423 @@
+// This file is part of Desktop App Toolkit,
+// a set of libraries for developing nice desktop applications.
+//
+// For license and copyright information please follow this link:
+// https://github.com/desktop-app/legal/blob/master/LEGAL
+//
+#pragma once
+
+#include <type_traits>
+
+namespace base {
+
+template <typename EnumType>
+class flags;
+
+template <typename ExtendedEnum>
+struct extended_flags;
+
+template <typename ExtendedEnum>
+using extended_flags_t = typename extended_flags<ExtendedEnum>::type;
+
+namespace details {
+
+struct flags_zero_helper_struct {
+};
+
+using flags_zero_helper = void(base::details::flags_zero_helper_struct::*)();
+
+template <typename ExtendedEnum,
+	typename Enum = typename base::extended_flags<ExtendedEnum>::type>
+inline constexpr auto extended_flag_convert(ExtendedEnum value) {
+	return static_cast<Enum>(value);
+}
+
+template <typename ExtendedEnum,
+	typename Enum = typename base::extended_flags<ExtendedEnum>::type>
+inline constexpr auto extended_flags_convert(ExtendedEnum value) {
+	return flags<Enum>(extended_flag_convert(value));
+}
+
+} // namespace details
+
+template <typename EnumType>
+class flags {
+public:
+	using Enum = EnumType;
+	using Type = std::underlying_type_t<Enum>;
+
+	constexpr flags() = default;
+	constexpr flags(details::flags_zero_helper) noexcept {
+	}
+	constexpr flags(Enum value) noexcept
+	: _value(static_cast<Type>(value)) {
+	}
+	static constexpr flags from_raw(Type value) noexcept {
+		return flags(static_cast<Enum>(value));
+	}
+
+	constexpr auto value() const noexcept {
+		return _value;
+	}
+	constexpr operator Type() const noexcept {
+		return value();
+	}
+
+	constexpr auto &operator|=(flags b) noexcept {
+		_value |= b.value();
+		return *this;
+	}
+	constexpr auto &operator&=(flags b) noexcept {
+		_value &= b.value();
+		return *this;
+	}
+	constexpr auto &operator^=(flags b) noexcept {
+		_value ^= b.value();
+		return *this;
+	}
+
+	constexpr auto operator~() const noexcept {
+		return from_raw(~value());
+	}
+
+	constexpr auto operator|(flags b) const noexcept {
+		return (flags(*this) |= b);
+	}
+	constexpr auto operator&(flags b) const noexcept {
+		return (flags(*this) &= b);
+	}
+	constexpr auto operator^(flags b) const noexcept {
+		return (flags(*this) ^= b);
+	}
+
+	constexpr auto operator|(Enum b) const noexcept {
+		return (flags(*this) |= b);
+	}
+	constexpr auto operator&(Enum b) const noexcept {
+		return (flags(*this) &= b);
+	}
+	constexpr auto operator^(Enum b) const noexcept {
+		return (flags(*this) ^= b);
+	}
+
+	constexpr auto operator==(Enum b) const noexcept {
+		return (value() == static_cast<Type>(b));
+	}
+	constexpr auto operator!=(Enum b) const noexcept {
+		return !(*this == b);
+	}
+	constexpr auto operator<(Enum b) const noexcept {
+		return value() < static_cast<Type>(b);
+	}
+	constexpr auto operator>(Enum b) const noexcept {
+		return (b < *this);
+	}
+	constexpr auto operator<=(Enum b) const noexcept {
+		return !(b < *this);
+	}
+	constexpr auto operator>=(Enum b) const noexcept {
+		return !(*this < b);
+	}
+
+private:
+	Type _value = 0;
+
+};
+
+template <typename Enum>
+constexpr auto make_flags(Enum value) noexcept {
+	return flags<Enum>(value);
+}
+
+template <typename Enum,
+	typename = std::enable_if_t<std::is_enum<Enum>::value>,
+	typename = std::enable_if_t<is_flag_type(Enum{})>>
+inline constexpr auto operator|(Enum a, flags<Enum> b) noexcept {
+	return b | a;
+}
+
+template <typename Enum,
+	typename = std::enable_if_t<std::is_enum<Enum>::value>,
+	typename = std::enable_if_t<is_flag_type(Enum{})>>
+inline constexpr auto operator&(Enum a, flags<Enum> b) noexcept {
+	return b & a;
+}
+
+template <typename Enum,
+	typename = std::enable_if_t<std::is_enum<Enum>::value>,
+	typename = std::enable_if_t<is_flag_type(Enum{})>>
+inline constexpr auto operator^(Enum a, flags<Enum> b) noexcept {
+	return b ^ a;
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator|(flags<extended_flags_t<ExtendedEnum>> a, ExtendedEnum b) {
+	return a | details::extended_flags_convert(b);
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator|(ExtendedEnum a, flags<extended_flags_t<ExtendedEnum>> b) {
+	return b | a;
+}
+
+template <typename ExtendedEnum,
+	typename = extended_flags_t<ExtendedEnum>>
+inline constexpr auto operator&(flags<extended_flags_t<ExtendedEnum>> a, ExtendedEnum b) {
+	return a & details::extended_flags_convert(b);
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator&(ExtendedEnum a, flags<extended_flags_t<ExtendedEnum>> b) {
+	return b & a;
+}
+
+template <typename ExtendedEnum,
+	typename = extended_flags_t<ExtendedEnum>>
+inline constexpr auto operator^(flags<extended_flags_t<ExtendedEnum>> a, ExtendedEnum b) {
+	return a ^ details::extended_flags_convert(b);
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator^(ExtendedEnum a, flags<extended_flags_t<ExtendedEnum>> b) {
+	return b ^ a;
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto &operator&=(flags<extended_flags_t<ExtendedEnum>> &a, ExtendedEnum b) {
+	return (a &= details::extended_flags_convert(b));
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto &operator|=(flags<extended_flags_t<ExtendedEnum>> &a, ExtendedEnum b) {
+	return (a |= details::extended_flags_convert(b));
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto &operator^=(flags<extended_flags_t<ExtendedEnum>> &a, ExtendedEnum b) {
+	return (a ^= details::extended_flags_convert(b));
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator==(flags<extended_flags_t<ExtendedEnum>> a, ExtendedEnum b) {
+	return a == details::extended_flags_convert(b);
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator==(ExtendedEnum a, flags<extended_flags_t<ExtendedEnum>> b) {
+	return (b == a);
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator!=(flags<extended_flags_t<ExtendedEnum>> a, ExtendedEnum b) {
+	return !(a == b);
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator!=(ExtendedEnum a, flags<extended_flags_t<ExtendedEnum>> b) {
+	return !(a == b);
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator<(flags<extended_flags_t<ExtendedEnum>> a, ExtendedEnum b) {
+	return a < details::extended_flags_convert(b);
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator<(ExtendedEnum a, flags<extended_flags_t<ExtendedEnum>> b) {
+	return details::extended_flags_convert(a) < b;
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator>(flags<extended_flags_t<ExtendedEnum>> a, ExtendedEnum b) {
+	return (b < a);
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator>(ExtendedEnum a, flags<extended_flags_t<ExtendedEnum>> b) {
+	return (b < a);
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator<=(flags<extended_flags_t<ExtendedEnum>> a, ExtendedEnum b) {
+	return !(b < a);
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator<=(ExtendedEnum a, flags<extended_flags_t<ExtendedEnum>> b) {
+	return !(b < a);
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator>=(flags<extended_flags_t<ExtendedEnum>> a, ExtendedEnum b) {
+	return !(a < b);
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator>=(ExtendedEnum a, flags<extended_flags_t<ExtendedEnum>> b) {
+	return !(a < b);
+}
+
+// For bare-enum operators to work inside namespace base we duplicate them here.
+
+template <typename Enum,
+	typename = std::enable_if_t<std::is_enum<Enum>::value>,
+	typename = std::enable_if_t<is_flag_type(Enum{})>>
+inline constexpr auto operator!(Enum a) noexcept {
+	return !make_flags(a);
+}
+
+template <typename Enum,
+	typename = std::enable_if_t<std::is_enum<Enum>::value>,
+	typename = std::enable_if_t<is_flag_type(Enum{})>>
+inline constexpr auto operator~(Enum a) noexcept {
+	return ~make_flags(a);
+}
+
+template <typename Enum,
+	typename = std::enable_if_t<std::is_enum<Enum>::value>,
+	typename = std::enable_if_t<is_flag_type(Enum{})>>
+inline constexpr auto operator|(Enum a, Enum b) noexcept {
+	return make_flags(a) | b;
+}
+
+template <typename Enum,
+	typename = std::enable_if_t<std::is_enum<Enum>::value>,
+	typename = std::enable_if_t<is_flag_type(Enum{})>>
+inline constexpr auto operator|(Enum a, details::flags_zero_helper) noexcept {
+	return make_flags(a);
+}
+
+template <typename Enum,
+	typename = std::enable_if_t<std::is_enum<Enum>::value>,
+	typename = std::enable_if_t<is_flag_type(Enum{})>>
+inline constexpr auto operator|(details::flags_zero_helper, Enum b) noexcept {
+	return make_flags(b);
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator|(ExtendedEnum a, ExtendedEnum b) {
+	return details::extended_flags_convert(a) | b;
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator|(ExtendedEnum a, typename extended_flags<ExtendedEnum>::type b) {
+	return details::extended_flags_convert(a) | b;
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator|(typename extended_flags<ExtendedEnum>::type a, ExtendedEnum b) {
+	return b | a;
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator|(details::flags_zero_helper, ExtendedEnum b) {
+	return 0 | details::extended_flag_convert(b);
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator|(ExtendedEnum a, details::flags_zero_helper) {
+	return details::extended_flag_convert(a) | 0;
+}
+
+template <typename ExtendedEnum,
+	typename = typename extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator~(ExtendedEnum b) {
+	return ~details::extended_flags_convert(b);
+}
+
+} // namespace base
+
+template <typename Enum,
+	typename = std::enable_if_t<std::is_enum<Enum>::value>,
+	typename = std::enable_if_t<is_flag_type(Enum{})>>
+inline constexpr auto operator!(Enum a) noexcept {
+	return !base::make_flags(a);
+}
+
+template <typename Enum,
+	typename = std::enable_if_t<std::is_enum<Enum>::value>,
+	typename = std::enable_if_t<is_flag_type(Enum{})>>
+inline constexpr auto operator~(Enum a) noexcept {
+	return ~base::make_flags(a);
+}
+
+template <typename Enum,
+	typename = std::enable_if_t<std::is_enum<Enum>::value>,
+	typename = std::enable_if_t<is_flag_type(Enum{})>>
+inline constexpr auto operator|(Enum a, Enum b) noexcept {
+	return base::make_flags(a) | b;
+}
+
+template <typename Enum,
+	typename = std::enable_if_t<std::is_enum<Enum>::value>,
+	typename = std::enable_if_t<is_flag_type(Enum{})>>
+inline constexpr auto operator|(Enum a, base::details::flags_zero_helper) noexcept {
+	return base::make_flags(a);
+}
+
+template <typename Enum,
+	typename = std::enable_if_t<std::is_enum<Enum>::value>,
+	typename = std::enable_if_t<is_flag_type(Enum{})>>
+inline constexpr auto operator|(base::details::flags_zero_helper, Enum b) noexcept {
+	return base::make_flags(b);
+}
+
+template <typename ExtendedEnum,
+	typename = typename base::extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator|(ExtendedEnum a, ExtendedEnum b) {
+	return base::details::extended_flags_convert(a) | b;
+}
+
+template <typename ExtendedEnum,
+	typename = typename base::extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator|(ExtendedEnum a, typename base::extended_flags<ExtendedEnum>::type b) {
+	return base::details::extended_flags_convert(a) | b;
+}
+
+template <typename ExtendedEnum,
+	typename = typename base::extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator|(typename base::extended_flags<ExtendedEnum>::type a, ExtendedEnum b) {
+	return b | a;
+}
+
+template <typename ExtendedEnum,
+	typename = typename base::extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator|(base::details::flags_zero_helper, ExtendedEnum b) {
+	return 0 | base::details::extended_flag_convert(b);
+}
+
+template <typename ExtendedEnum,
+	typename = typename base::extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator|(ExtendedEnum a, base::details::flags_zero_helper) {
+	return base::details::extended_flag_convert(a) | 0;
+}
+
+template <typename ExtendedEnum,
+	typename = typename base::extended_flags<ExtendedEnum>::type>
+inline constexpr auto operator~(ExtendedEnum b) {
+	return ~base::details::extended_flags_convert(b);
+}