AVR Freaks

>Yeah, I would suggest "Restorestate" is the one used 99% of the time

I would even skip the ability to do anything else. The saving of 1 instruction if you know irq's are on is not worth the addition of more options. You get one little class that does one simple job, and everyone can see what it does and how it does it.

~5 lines of code handles most needs. 

struct InterruptLock {
    InterruptLock   () : sreg_(SREG) { asm("cli"); }
    ~InterruptLock  () { SREG = sreg_; }
    private:
    u8 sreg_;
};

volatile time_t systemSeconds;

static auto  time        ()             { InterruptLock lock; return systemSeconds; }

static auto  time        (time_t t)     { InterruptLock lock; systemSeconds = t; }
static auto  localtime   (tm& tmptr)    { time_t t = time(); localtime_r( &t, &tmptr ); }

int main(){

    tm now;
    localtime( now );

Another good reason to keep it simple is you can create this class on the fly if needed, from memory as its so simple, or stick it in some common header, etc. You can then use it anywhere, such as posting examples here or on compiler explorer, and will not be tied down to a 3-4 header file version which contains variations for whatever std is in use. When simple, it also means you can use it as an example for other uses-

struct ScopeBackup { //backup a register, restore when exit scope
    ScopeBackup   (volatile u8& reg) : reg_(reg), backup_(reg) {}
    ~ScopeBackup  () { reg_ = backup_; }
    private:
    volatile u8& reg_;
    u8 backup_;
};

or template so you do not need to create versions for every type that can be used-

template<typename T>
struct ScopeBackup {
    ScopeBackup   (T& reg) : reg_(reg), backup_(reg) {}
    ~ScopeBackup  () { reg_ = backup_; }
    private:
    T& reg_;
    u8 backup_;
};

ISR(TCA0_CMP0_vect){

    //main code may be doing something that uses TEMP, so backup/restore

    ScopeBackup tempBak{ TCA0.SINGLE.TEMP };

    //do a read/write on a register that affects temp

    //TEMP is restored, and main code does not need to protect a 16bit write to a tca0 register

}

Well, you then end up with a truckload of parts and you only use a handful.

Or rather, your attic collects all these things that you think you will use someday, but never do.

Keep the common parts on hand, when you need the unusual part not in stock just order it.

Storage of extra bits is free on a pc, but you still have to stumble over all the extra bits when looking for the needed bits.

</metaphors>

You also get to maintain all that extra code. New std, new version. More features, new version. Plus in this case you allow the potential to introduce a problem if used wrong- sei gets used when its not supposed to if you thought irq's were on but they were not (and were off for a good reason that may not be apparent in the function). If you only allow one simple version, it cannot be used wrong.