flags.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/utils/flags.hpp
/// @brief Types that provide flags interface to enums
 
#include <atomic>
#include <initializer_list>
#include <type_traits>
 
USERVER_NAMESPACE_BEGIN
 
namespace utils {
 
template <typename Enum>
class AtomicFlags;
 
/// @ingroup userver_universal userver_containers
///
/// @brief Wrapper to extend enum with flags interface
template <typename Enum>
class Flags final {
public:
    using ValueType = std::underlying_type_t<Enum>;
 
    constexpr Flags() noexcept : Flags(Enum::kNone) {}
    /*implicit*/ constexpr Flags(Enum) noexcept;
    constexpr Flags(std::initializer_list<Enum>) noexcept;
 
    constexpr explicit operator bool() const;
 
    constexpr Flags& operator|=(Flags);
    constexpr Flags& operator&=(Flags);
    constexpr Flags& Clear(Flags);
 
    constexpr Flags operator|(Flags) const;
    constexpr Flags operator&(Flags) const;
 
    constexpr bool operator==(Flags) const;
    constexpr bool operator!=(Flags) const;
 
    constexpr ValueType GetValue() const;
    constexpr void SetValue(ValueType value);
 
private:
    friend class AtomicFlags<Enum>;
 
    ValueType value_;
};
 
template <typename Enum>
constexpr Flags<Enum> operator|(Enum, Flags<Enum>);
 
template <typename Enum>
constexpr Flags<Enum> operator&(Enum, Flags<Enum>);
 
template <typename Enum>
constexpr bool operator==(Enum, Flags<Enum>);
 
template <typename Enum>
constexpr bool operator!=(Enum, Flags<Enum>);
 
/// @ingroup userver_universal userver_containers
///
/// @brief Wrapper to extend enum with atomic flags interface
template <typename Enum>
class AtomicFlags final {
public:
    using ValueType = std::underlying_type_t<Enum>;
 
    constexpr AtomicFlags() : AtomicFlags(Enum::kNone) {}
    constexpr explicit AtomicFlags(Enum);
    constexpr AtomicFlags(std::initializer_list<Enum>);
 
    explicit operator bool() const;
    /*implicit*/ operator Flags<Enum>() const;
    Flags<Enum> Load(std::memory_order = std::memory_order_seq_cst) const;
 
    AtomicFlags& operator=(Flags<Enum>);
    AtomicFlags& Store(Flags<Enum>, std::memory_order = std::memory_order_seq_cst);
    Flags<Enum> Exchange(Flags<Enum>);
 
    AtomicFlags& operator|=(Flags<Enum>);
    AtomicFlags& operator&=(Flags<Enum>);
    AtomicFlags& Clear(Flags<Enum>);
    Flags<Enum> FetchOr(Flags<Enum>, std::memory_order = std::memory_order_seq_cst);
    Flags<Enum> FetchAnd(Flags<Enum>, std::memory_order = std::memory_order_seq_cst);
    Flags<Enum> FetchClear(Flags<Enum>, std::memory_order = std::memory_order_seq_cst);
    bool CompareExchangeWeak(
        Flags<Enum>& expected,
        Flags<Enum> desired,
        std::memory_order order = std::memory_order_seq_cst
    );
    bool CompareExchangeStrong(
        Flags<Enum>& expected,
        Flags<Enum> desired,
        std::memory_order order = std::memory_order_seq_cst
    );
    bool CompareExchangeWeak(
        Flags<Enum>& expected,
        Flags<Enum> desired,
        std::memory_order success,
        std::memory_order failure
    );
    bool CompareExchangeStrong(
        Flags<Enum>& expected,
        Flags<Enum> desired,
        std::memory_order success,
        std::memory_order failure
    );
 
    Flags<Enum> operator|(Flags<Enum>) const;
    Flags<Enum> operator&(Flags<Enum>) const;
 
    bool operator==(Flags<Enum>) const;
    bool operator!=(Flags<Enum>) const;
 
    ValueType GetValue();
 
private:
    std::atomic<ValueType> value_;
};
 
template <typename Enum>
Flags<Enum> operator|(Enum, const AtomicFlags<Enum>&);
 
template <typename Enum>
Flags<Enum> operator&(Enum, const AtomicFlags<Enum>&);
 
template <typename Enum>
bool operator==(Enum, const AtomicFlags<Enum>&);
 
template <typename Enum>
bool operator!=(Enum, const AtomicFlags<Enum>&);
 
template <typename Enum>
constexpr Flags<Enum>::Flags(Enum value) noexcept : value_(static_cast<ValueType>(value)) {}
 
template <typename Enum>
constexpr Flags<Enum>::Flags(std::initializer_list<Enum> values) noexcept : Flags() {
    for (Enum value : values) {
        *this |= value;
    }
}
 
template <typename Enum>
constexpr Flags<Enum>::operator bool() const {
    return !!value_;
}
 
template <typename Enum>
constexpr Flags<Enum>& Flags<Enum>::operator|=(Flags rhs) {
    value_ |= rhs.value_;
    return *this;
}
 
template <typename Enum>
constexpr Flags<Enum>& Flags<Enum>::operator&=(Flags rhs) {
    value_ &= rhs.value_;
    return *this;
}
 
template <typename Enum>
constexpr Flags<Enum>& Flags<Enum>::Clear(Flags flags) {
    value_ &= ~flags.value_;
    return *this;
}
 
template <typename Enum>
constexpr Flags<Enum> Flags<Enum>::operator|(Flags rhs) const {
    return Flags(*this) |= rhs;
}
 
template <typename Enum>
constexpr Flags<Enum> Flags<Enum>::operator&(Flags rhs) const {
    return Flags(*this) &= rhs;
}
 
template <typename Enum>
constexpr bool Flags<Enum>::operator==(Flags rhs) const {
    return value_ == rhs.value_;
}
 
template <typename Enum>
constexpr bool Flags<Enum>::operator!=(Flags rhs) const {
    return !(*this == rhs);
}
 
template <typename Enum>
constexpr typename Flags<Enum>::ValueType Flags<Enum>::GetValue() const {
    return this->value_;
}
 
template <typename Enum>
constexpr void Flags<Enum>::SetValue(typename Flags<Enum>::ValueType value) {
    this->value_ = value;
}
 
template <typename Enum>
constexpr Flags<Enum> operator|(Enum lhs, Flags<Enum> rhs) {
    return rhs |= lhs;
}
 
template <typename Enum>
constexpr Flags<Enum> operator&(Enum lhs, Flags<Enum> rhs) {
    return rhs &= lhs;
}
 
template <typename Enum>
constexpr bool operator==(Enum lhs, Flags<Enum> rhs) {
    return rhs == Flags<Enum>{lhs};
}
 
template <typename Enum>
constexpr bool operator!=(Enum lhs, Flags<Enum> rhs) {
    return rhs != Flags<Enum>{lhs};
}
 
template <typename Enum>
constexpr AtomicFlags<Enum>::AtomicFlags(Enum value) : value_(static_cast<ValueType>(value)) {}
 
template <typename Enum>
constexpr AtomicFlags<Enum>::AtomicFlags(std::initializer_list<Enum> values) : AtomicFlags(Enum(values)) {}
 
template <typename Enum>
AtomicFlags<Enum>::operator bool() const {
    return !!value_;
}
 
template <typename Enum>
AtomicFlags<Enum>::operator Flags<Enum>() const {
    return Load();
}
 
template <typename Enum>
Flags<Enum> AtomicFlags<Enum>::Load(std::memory_order order) const {
    return static_cast<Enum>(value_.load(order));
}
 
template <typename Enum>
AtomicFlags<Enum>& AtomicFlags<Enum>::operator=(Flags<Enum> rhs) {
    Store(rhs);
    return *this;
}
 
template <typename Enum>
AtomicFlags<Enum>& AtomicFlags<Enum>::Store(Flags<Enum> rhs, std::memory_order order) {
    value_.store(rhs.value_, order);
    return *this;
}
 
template <typename Enum>
Flags<Enum> AtomicFlags<Enum>::Exchange(Flags<Enum> flags) {
    return static_cast<Enum>(value_.exchange(flags.value_));
}
 
template <typename Enum>
AtomicFlags<Enum>& AtomicFlags<Enum>::operator|=(Flags<Enum> rhs) {
    FetchOr(rhs);
    return *this;
}
 
template <typename Enum>
AtomicFlags<Enum>& AtomicFlags<Enum>::operator&=(Flags<Enum> rhs) {
    FetchAnd(rhs);
    return *this;
}
 
template <typename Enum>
AtomicFlags<Enum>& AtomicFlags<Enum>::Clear(Flags<Enum> flags) {
    FetchClear(flags);
    return *this;
}
 
template <typename Enum>
Flags<Enum> AtomicFlags<Enum>::FetchOr(Flags<Enum> rhs, std::memory_order memory_order) {
    return static_cast<Enum>(value_.fetch_or(rhs.value_, memory_order));
}
 
template <typename Enum>
Flags<Enum> AtomicFlags<Enum>::FetchAnd(Flags<Enum> rhs, std::memory_order memory_order) {
    return static_cast<Enum>(value_.fetch_and(rhs.value_, memory_order));
}
 
template <typename Enum>
Flags<Enum> AtomicFlags<Enum>::FetchClear(Flags<Enum> flags, std::memory_order memory_order) {
    return static_cast<Enum>(value_.fetch_and(~flags.value_, memory_order));
}
 
template <typename Enum>
bool AtomicFlags<Enum>::CompareExchangeWeak(Flags<Enum>& expected, Flags<Enum> desired, std::memory_order order) {
    auto expected_int = expected.GetValue();
    const bool result = value_.compare_exchange_weak(expected_int, desired.GetValue(), order);
    expected = Enum{expected_int};
    return result;
}
 
template <typename Enum>
bool AtomicFlags<Enum>::CompareExchangeStrong(Flags<Enum>& expected, Flags<Enum> desired, std::memory_order order) {
    auto expected_int = expected.GetValue();
    const bool result = value_.compare_exchange_strong(expected_int, desired.GetValue(), order);
    expected = Enum{expected_int};
    return result;
}
 
template <typename Enum>
bool AtomicFlags<Enum>::CompareExchangeWeak(
    Flags<Enum>& expected,
    Flags<Enum> desired,
    std::memory_order success,
    std::memory_order failure
) {
    auto expected_int = expected.GetValue();
    const bool result = value_.compare_exchange_weak(expected_int, desired.GetValue(), success, failure);
    expected = Enum{expected_int};
    return result;
}
 
template <typename Enum>
bool AtomicFlags<Enum>::CompareExchangeStrong(
    Flags<Enum>& expected,
    Flags<Enum> desired,
    std::memory_order success,
    std::memory_order failure
) {
    auto expected_int = expected.GetValue();
    const bool result = value_.compare_exchange_strong(expected_int, desired.GetValue(), success, failure);
    expected = Enum{expected_int};
    return result;
}
 
template <typename Enum>
Flags<Enum> AtomicFlags<Enum>::operator|(Flags<Enum> rhs) const {
    return Flags<Enum>{*this} |= rhs;
}
 
template <typename Enum>
Flags<Enum> AtomicFlags<Enum>::operator&(Flags<Enum> rhs) const {
    return Flags<Enum>{*this} &= rhs;
}
 
template <typename Enum>
bool AtomicFlags<Enum>::operator==(Flags<Enum> rhs) const {
    return value_ == rhs.value_;
}
 
template <typename Enum>
bool AtomicFlags<Enum>::operator!=(Flags<Enum> rhs) const {
    return !(*this == rhs);
}
 
template <typename Enum>
typename AtomicFlags<Enum>::ValueType AtomicFlags<Enum>::GetValue() {
    return this->value_.load();
}
 
template <typename Enum>
Flags<Enum> operator|(Enum lhs, const AtomicFlags<Enum>& rhs) {
    return rhs | lhs;
}
 
template <typename Enum>
Flags<Enum> operator&(Enum lhs, const AtomicFlags<Enum>& rhs) {
    return rhs & lhs;
}
 
template <typename Enum>
bool operator==(Enum lhs, const AtomicFlags<Enum>& rhs) {
    return rhs == Flags<Enum>{lhs};
}
 
template <typename Enum>
bool operator!=(Enum lhs, const AtomicFlags<Enum>& rhs) {
    return rhs != Flags<Enum>{lhs};
}
 
}  // namespace utils
 
USERVER_NAMESPACE_END