flags.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_FLAGS_H
#define EGT_FLAGS_H
 
#include <egt/detail/enum.h>
#include <egt/detail/meta.h>
#include <egt/detail/string.h>
#include <egt/flagsbase.h>
#include <egt/signal.h>
#include <iosfwd>
#include <sstream>
#include <string>
#include <vector>
 
namespace egt
{
inline namespace v1
{
 
template<class T>
class Flags : public FlagsBase<T>
{
public:
    using FlagsBase<T>::FlagsBase;
 
    constexpr Flags() noexcept = default;
 
    Signal<> on_change;
    explicit Flags(const std::string& str)
    {
        this->from_string(str);
    }
 
    explicit Flags(const char* str)
    {
        this->from_string(str);
    }
 
    // cppcheck-suppress noExplicitConstructor
    // NOLINTNEXTLINE(hicpp-explicit-conversions)
    constexpr Flags(T flag) noexcept
        : FlagsBase<T>(flag)
    {
    }
 
    constexpr Flags(const Flags& rhs) noexcept
        : FlagsBase<T>(rhs)
    {
        // signals are not copied!
    }
 
    // NOLINTNEXTLINE(cert-oop54-cpp)
    Flags& operator=(const Flags& rhs)
    {
        if (&rhs != this)
        {
            const auto res = (*this != rhs);
 
            // signals are not copied!
            FlagsBase<T>::operator=(rhs);
 
            if (res)
                on_change.invoke();
        }
        return *this;
    }
 
    Flags(Flags&&) noexcept = default;
    Flags& operator=(Flags&&) noexcept = default;
    ~Flags() noexcept = default;
 
    bool set(T flag) noexcept
    {
        const auto res = FlagsBase<T>::set(flag);
        if (res)
            on_change.invoke();
        return res;
    }
 
    bool set(std::initializer_list<T> flags) noexcept
    {
        const auto res = FlagsBase<T>::set(flags);
        if (res)
            on_change.invoke();
        return res;
    }
 
    bool clear(T flag) noexcept
    {
        const auto res = FlagsBase<T>::clear(flag);
        if (res)
            on_change.invoke();
        return res;
    }
 
    bool clear() noexcept
    {
        const auto res = FlagsBase<T>::clear();
        if (res)
            on_change.invoke();
        return res;
    }
 
    constexpr Flags<T> operator|(const T& flag) const noexcept
    {
        return {this->m_flags | static_cast<typename FlagsBase<T>::Underlying>(flag)};
    }
 
    constexpr Flags<T> operator&(const T& flag) const noexcept
    {
        return {this->m_flags& static_cast<typename FlagsBase<T>::Underlying>(flag)};
    }
 
    constexpr static const char FLAGS_DELIMITER = '|';
 
    EGT_NODISCARD std::string to_string() const
    {
        std::ostringstream ss;
        if (!this->empty())
        {
            bool first = true;
            const auto container = this->get();
            for (const auto& item : container)
            {
                if (first)
                    first = false;
                else
                    ss << FLAGS_DELIMITER;
                ss << detail::enum_to_string(item);
            }
        }
        return ss.str();
    }
 
    void from_string(const std::string& str)
    {
        this->clear();
        std::vector<std::string> tokens;
        detail::tokenize(str, FLAGS_DELIMITER, tokens);
        for (auto& flag : tokens)
            this->set(detail::enum_from_string<T>(detail::trim(flag)));
    }
};
 
enum class RuleE {};
static_assert(detail::rule_of_5<Flags<RuleE>>(), "must fulfill rule of 5");
 
template<class T>
constexpr bool operator==(const Flags<T>& lhs, const Flags<T>& rhs)
{
    return lhs.raw() == rhs.raw();
}
 
template<class T>
constexpr bool operator!=(const Flags<T>& lhs, const Flags<T>& rhs)
{
    return !(lhs == rhs);
}
 
template<class T>
std::ostream& operator<<(std::ostream& os, const Flags<T>& flags)
{
    return os << flags.tostring();
}
 
}
}
 
#endif