FlagsMI.h

#pragma once


#include <libutl/Object.h>


UTL_NS_BEGIN;

// FlagsMI /////////////////////////////////////////////////////////////////////////////////////////


class FlagsMI
{
public:
    FlagsMI()
    {
        _flags = 0;
    }

    virtual ~FlagsMI()
    {
    }

    void
    copyFlags(const FlagsMI& rhs)
    {
        _flags = rhs._flags;
    }

    void
    copyFlags(const FlagsMI& rhs, uint_t lsb, uint_t msb)
    {
        copyFlags(rhs._flags, lsb, msb);
    }

    void
    copyFlags(uint64_t flags, uint_t lsb, uint_t msb)
    {
        ASSERTD(lsb <= msb);
        ASSERTD(msb <= 63);
        uint64_t mask;
        if (msb == 63)
            mask = uint64_t_max;
        else
            mask = ((uint64_t)1 << (msb + 1)) - 1;
        if (lsb > 0) mask &= ~(((uint64_t)1 << lsb) - 1);
        _flags = (_flags & ~mask) | (flags & mask);
    }

    void
    serializeFlags(Stream& stream, uint_t io, uint_t mode)
    {
        utl::serialize(_flags, stream, io, mode);
    }

    bool
    getFlag(uint_t flagNum) const
    {
        ASSERTD(flagNum < 64);
        uint64_t mask = ((uint64_t)1 << flagNum);
        return ((_flags & mask) != 0);
    }

    void
    setFlag(uint_t flagNum, bool val)
    {
        ASSERTD(flagNum < 64);
        uint64_t mask = ((uint64_t)1 << flagNum);
        if (val)
            _flags |= mask;
        else
            _flags &= ~mask;
    }

    uint64_t
    getFlagsNumber(uint64_t mask, uint64_t shift = 0)
    {
        return (_flags & mask) >> shift;
    }

    void
    setFlagsNumber(uint64_t mask, uint64_t shift, uint64_t num)
    {
        _flags &= ~mask;
        _flags |= (num << shift);
    }

    uint64_t
    getFlags() const
    {
        return _flags;
    }

    void
    setFlags(uint64_t flags)
    {
        _flags = flags;
    }

protected:
    uint64_t _flags;
};

// FlagGuard ///////////////////////////////////////////////////////////////////////////////////////


class FlagGuard
{
public:
    FlagGuard(FlagsMI* object, uint_t flagNum, bool val)
    {
        // save the original value and toggle the flag
        _object = object;
        _flagNum = flagNum;
        _value = object->getFlag(flagNum);
        object->setFlag(flagNum, val);
    }

    ~FlagGuard()
    {
        ASSERTD(_object != nullptr);
        _object->setFlag(_flagNum, _value);
    }

private:
    FlagsMI* _object;
    uint_t _flagNum;
    bool _value;
};


UTL_NS_END;