/**
 * @brief Template class implementation for `EnumFlags<T>`.
 */
#ifndef STA_CORE_ENUM_FLAGS_TPP
#define STA_CORE_ENUM_FLAGS_TPP

#ifndef STA_CORE_ENUM_FLAGS_HPP
#  error "Direct use of internal header. Use <sta/enum_flags.hpp> instead"
#endif // !STA_CORE_ENUM_FLAGS_HPP


namespace sta
{
    template <typename F>
    EnumFlags<F>::EnumFlags()
        : flags_{0}
    {}

    template <typename F>
    EnumFlags<F>::EnumFlags(const EnumFlags & other)
        : flags_{other.flags_}
    {}

    template <typename F>
    EnumFlags<F>::EnumFlags(flag_type flag)
        : flags_{1U << static_cast<uint8_t>(flag)}
    {}

    template <typename F>
    EnumFlags<F>::EnumFlags(uint32_t flags)
        : flags_{flags}
    {}


    template <typename F>
    void EnumFlags<F>::set(const EnumFlags & flags)
    {
        flags_ |= flags.flags_;
    }

    template <typename F>
    void EnumFlags<F>::clear(const EnumFlags & flags)
    {
        flags_ &= ~(flags.flags_);
    }

    template <typename F>
    void EnumFlags<F>::clear()
    {
        flags_ = 0;
    }


    template <typename F>
    bool EnumFlags<F>::isSet(const EnumFlags & flags) const
    {
        return (flags_ & flags.flags_) == flags.flags_;
    }

    template <typename F>
    bool EnumFlags<F>::isAnySet(const EnumFlags & flags) const
    {
        return (flags_ & flags.flags_) != 0;
    }


    template <typename F>
    bool EnumFlags<F>::operator ==(const EnumFlags<F> & rhs) const
    {
        return (flags_ == rhs.flags_);
    }

    template <typename F>
    bool EnumFlags<F>::operator !=(const EnumFlags<F> & rhs) const
    {
        return (flags_ != rhs.flags_);
    }


    template <typename F>
    EnumFlags<F> EnumFlags<F>::operator &(const EnumFlags<F> & rhs) const
    {
        return EnumFlags(flags_ & rhs.flags_);
    }

    template <typename F>
    EnumFlags<F> EnumFlags<F>::operator |(const EnumFlags<F> & rhs) const
    {
        return EnumFlags(flags_ | rhs.flags_);
    }


    template <typename F>
    EnumFlags<F> & EnumFlags<F>::operator &=(const EnumFlags<F> & rhs)
    {
        flags_ &= rhs.flags_;
        return *this;
    }

    template <typename F>
    EnumFlags<F> & EnumFlags<F>::operator |=(const EnumFlags<F> & rhs)
    {
        flags_ |= rhs.flags_;
        return *this;
    }


    template <typename F>
    EnumFlags<F>::operator uint32_t()
    {
        return flags_;
    }
} // namespace sta


#endif // STA_CORE_ENUM_FLAGS_TPP