Add bitwise SetFlags for AdminId and GroupId

[sirdigbot]

Add a method to AdminId and GroupId that allows you to set multiple admin flags at a time using bitwise ADMFLAG_* values instead of the AdminFlag enum.

AdminId.SetFlag(Admin_Ban, true);
AdminId.SetFlag(Admin_Slay, true);
AdminId.SetFlag(Admin_Chat, true);
AdminId.SetFlag(Admin_Password, true);
// or
AdminId.SetFlags(ADMFLAG_BAN|ADMFLAG_SLAY|ADMFLAG_CHAT|ADMFLAG_PASSWORD, true);

Tested with the following code, not that it was really necessary:

#include <sourcemod>

#pragma semicolon 1
#pragma newdecls required

public Plugin myinfo = {
    name        = "",
    author      = "",
    description = "",
    version     = "0.0.0",
    url         = ""
};

AdminId admNew;
AdminId admOld;
GroupId grpNew;
GroupId grpOld;


void PrintFlags(const char[] msg)
{
    int admNewFlags = admNew.GetFlags(Access_Real);
    int grpNewFlags = grpNew.GetFlags();
    int admOldFlags = admOld.GetFlags(Access_Real);
    int grpOldFlags = grpOld.GetFlags();
    
    PrintToServer("%s\n[SetFlags (New)] AdminId:%i -- GroupId:%i\n[SetFlag  (Old)] AdminId:%i -- GroupId:%i", msg, admNewFlags, grpNewFlags, admOldFlags, grpOldFlags);
    if (admNewFlags == admOldFlags && grpNewFlags == grpOldFlags)
        PrintToServer("Values are equal.\n");
    else
        PrintToServer("***Values are NOT EQUAL.***\n");
}

public void OnPluginStart()
{
    // Reset cache so we can create groups/admins
    DumpAdminCache(AdminCache_Groups, true);
    DumpAdminCache(AdminCache_Admins, true);

    admNew = CreateAdmin("TestAdmin1");
    grpNew = CreateAdmGroup("TestGroup1");
    admOld = CreateAdmin("TestAdmin2");
    grpOld = CreateAdmGroup("TestGroup2");
    
    
    // Initial state
    PrintFlags("Initial state");
    
    
    // Adding single
    admNew.SetFlags(ADMFLAG_GENERIC, true);
    grpNew.SetFlags(ADMFLAG_GENERIC, true);

    admOld.SetFlag(Admin_Generic, true);
    grpOld.SetFlag(Admin_Generic, true);
    PrintFlags("Adding single");
    
    
    // Adding invalid
    admNew.SetFlags((1<<31), true);
    grpNew.SetFlags((1<<31), true);

    admOld.SetFlag(view_as<AdminFlag>(1<<31), true);
    grpOld.SetFlag(view_as<AdminFlag>(1<<31), true);
    PrintFlags("Adding invalid");
    
    
    // Adding multiple
    admNew.SetFlags(ADMFLAG_BAN|ADMFLAG_SLAY|ADMFLAG_CHAT|ADMFLAG_PASSWORD, true);
    grpNew.SetFlags(ADMFLAG_BAN|ADMFLAG_SLAY|ADMFLAG_CHAT|ADMFLAG_PASSWORD, true);

    admOld.SetFlag(Admin_Ban, true);
    admOld.SetFlag(Admin_Slay, true);
    admOld.SetFlag(Admin_Chat, true);
    admOld.SetFlag(Admin_Password, true);
    grpOld.SetFlag(Admin_Ban, true);
    grpOld.SetFlag(Admin_Slay, true);
    grpOld.SetFlag(Admin_Chat, true);
    grpOld.SetFlag(Admin_Password, true);
    PrintFlags("Adding multiple");
    
    
    // Adding redundant
    admNew.SetFlags(ADMFLAG_GENERIC|ADMFLAG_BAN, true);
    grpNew.SetFlags(ADMFLAG_GENERIC|ADMFLAG_BAN, true);

    admOld.SetFlag(Admin_Generic, true);
    admOld.SetFlag(Admin_Ban, true);
    grpOld.SetFlag(Admin_Generic, true);
    grpOld.SetFlag(Admin_Ban, true);
    PrintFlags("Adding redundant");
    
    
    // Removing single
    admNew.SetFlags(ADMFLAG_GENERIC, false);
    grpNew.SetFlags(ADMFLAG_GENERIC, false);

    admOld.SetFlag(Admin_Generic, false);
    grpOld.SetFlag(Admin_Generic, false);
    PrintFlags("Remove single");
    
    
    // Removing invalid
    admNew.SetFlags((1<<31), false);
    grpNew.SetFlags((1<<31), false);

    admOld.SetFlag(view_as<AdminFlag>(1<<31), false);
    grpOld.SetFlag(view_as<AdminFlag>(1<<31), false);
    PrintFlags("Removing invalid");
    
    
    // Remove multiple
    admNew.SetFlags(ADMFLAG_BAN|ADMFLAG_SLAY|ADMFLAG_CHAT, false);
    grpNew.SetFlags(ADMFLAG_BAN|ADMFLAG_SLAY|ADMFLAG_CHAT, false);

    admOld.SetFlag(Admin_Ban, false);
    admOld.SetFlag(Admin_Slay, false);
    admOld.SetFlag(Admin_Chat, false);
    grpOld.SetFlag(Admin_Ban, false);
    grpOld.SetFlag(Admin_Slay, false);
    grpOld.SetFlag(Admin_Chat, false);
    PrintFlags("Remove multiple");
    
    
    // Remove redundant
    admNew.SetFlags(ADMFLAG_PASSWORD|ADMFLAG_SLAY, false);
    grpNew.SetFlags(ADMFLAG_PASSWORD|ADMFLAG_SLAY, false);

    admOld.SetFlag(Admin_Password, false);
    admOld.SetFlag(Admin_Slay, false);
    grpOld.SetFlag(Admin_Password, false);
    grpOld.SetFlag(Admin_Slay, false);
    PrintFlags("Remove redundant");
}

[peace-maker]

I'm not a fan of mixing the AdminFlag enum and bitfield ADMFLAG_ defines in the parameter type of two very similarily named functions. But until we have varargs there isn't a nicer way for this. A SetFlags(AdminFlag[] flags, int size, bool enabled) would defeat this PR's purpose to conveniently add multiple flags at once.

This doesn't have to be implemented in C++ though and could be inlined in the SourcePawn methodmap.

[sirdigbot]

I'm not a fan of mixing the AdminFlag enum and bitfield ADMFLAG_ defines in the parameter type of two very similarily named functions.

So before I rewrite it for the methodmap, would it be better to rename it slightly to avoid confusion?
Maybe SetBitFlags?

This doesn't have to be implemented in C++ though and could be inlined in the SourcePawn methodmap.

The reason I wrote it as a native is because I wasn't sure if repeatedly calling the other natives SetAdminFlag or SetAdmGroupAddFlag was worth having it inlined. I guess it's not a problem though?

[sirdigbot]

If I should add non-methodmap versions let me know

[peace-maker]

Looks good and SetBitFlags is more descriptive as well. Thank you!