flagsbase.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_FLAGSBASE_H
#define EGT_FLAGSBASE_H
 
#include <egt/detail/meta.h>
#include <initializer_list>
#include <limits>
#include <set>
 
namespace egt
{
inline namespace v1
{
 
template <class T>
class FlagsBase
{
public:
 
    using Underlying = typename std::underlying_type<T>::type;
 
    constexpr FlagsBase() noexcept = default;
 
    // cppcheck-suppress noExplicitConstructor
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    constexpr FlagsBase(const T flag) noexcept
        : m_flags(static_cast<Underlying>(flag))
    {}
 
    // cppcheck-suppress noExplicitConstructor
    constexpr FlagsBase(std::initializer_list<T> flags) noexcept
    {
        for (auto& flag : flags)
            m_flags |= static_cast<Underlying>(flag);
    }
 
    EGT_NODISCARD constexpr bool is_set(const T flag) const noexcept
    {
        return m_flags & static_cast<Underlying>(flag);
    }
 
    EGT_NODISCARD constexpr bool is_set(std::initializer_list<T> flags) const noexcept
    {
        for (auto& flag : flags)
            if (!is_set(flag))
                return false;
        return true;
    }
 
    constexpr bool set(const T flag) noexcept
    {
        auto state = is_set(flag);
        if (!state)
            m_flags |= static_cast<Underlying>(flag);
        return !state;
    }
 
    constexpr bool set(std::initializer_list<T> flags) noexcept
    {
        bool inserted = false;
        for (auto& flag : flags)
        {
            if (!is_set(flag))
            {
                m_flags |= static_cast<Underlying>(flag);
                inserted = true;
            }
        }
 
        return inserted;
    }
 
    constexpr bool clear(const T flag) noexcept
    {
        bool changed = false;
        if (is_set(flag))
        {
            m_flags &= ~(static_cast<Underlying>(flag));
            changed = true;
        }
 
        return changed;
    }
 
    EGT_NODISCARD constexpr bool empty() const noexcept
    {
        return m_flags == 0;
    }
 
    constexpr bool clear() noexcept
    {
        const bool diff = m_flags != 0;
        m_flags = 0;
        return diff;
    }
 
    EGT_NODISCARD std::set<T> get() const
    {
        std::set<T> result;
        const auto bits = std::numeric_limits<Underlying>::digits;
        for (auto b = 0; b < bits; b++)
        {
            if ((m_flags & (1u << b)))
                result.insert(static_cast<T>(1u << b));
        }
 
        return result;
    }
 
    EGT_NODISCARD constexpr const Underlying& raw() const
    {
        return m_flags;
    }
 
    constexpr Underlying& raw()
    {
        return m_flags;
    }
 
protected:
 
    // cppcheck-suppress noExplicitConstructor
    // NOLINTNEXTLINE(hicpp-explicit-conversions)
    constexpr FlagsBase(const Underlying flags) noexcept
        : m_flags(flags)
    {}
 
    Underlying m_flags{};
};
 
}
}
 
#endif