Efficiently handling a large set of bit-mask flags - c++

Question

My function takes a filesystem path and a bit-mask describing the desired check to be performed on the FS object.
Does it Exist ?
Is it : File, Folder, SymLink ? Empty, Hidden ? Readable (R), Writable ?
Symlink : to a File, to a Folder ?
These 11 flags afford for a large number of combinations so I provide convenience flags like SymLinkToAReadableFile and such. This is not only convenient, it also spares some potential confusion : SymLinkToFile | R could mean a readable symlink (not very useful), the name "SymLinkToAReadableFile" leaves no doubt.
And to cut back on the required processing, I would define RWHiddenFolder = Folder | R | W | Hidden, and same for all things Folder related : Folder | .. , and likewise for File & SymLink.
This makes checking that user in not mixing File and Folder (which does not make sense) easy : (flag & Folder) && (flag & File) -> error.
But this makes RWHiddenFolder | RWEmptyFile same as RWHiddenFile | RWEmptyFolder same as File | Folder | R | W | Empty | Hidden :
can't tell what the user actually passed !
and thus can't build a precise error message
if I make my function tolerant and ignore SymLink in presence of Folder, can't tell if user wants Empty or Hidden (or both) Folder !
The naive "solution" of affecting a bit to each possible combination obviously solves all of these issues, but builds a dense forest of if/else branches already for just making sure the provided flag combination makes sense, let alone doing the actual checks after that..
Is there a good trade-off between complex processing and convenient/clear interface (for the user) ?

Answer 1

I came up with a reasonable solution (I had to !).
Sharing here for anyone with the same issue.
For those who prefer action to lectures (like me) : sample (ignore the numerous constants definitions)
Obviously an enum can't do this, nor simple bitfields/sets : composing with OR loses the identity of the flag (ReadableFile == Readable | File).
But binary operations make for very effiecent (read "compact") manipulations (check, extract flag, ..)
So the idea is to carry mask and separate id :
constexpr static auto nFlags = 96u; // total amount of flags
struct argFlag {
string n; // reflection
bitset<nFlags> id;
bitset<16> mask; // plain bitmask
// id == position of true bit
argFlag(const string& s, const int i, const uint32_t m = 0 )
: n(s), mask(m) { id.set(i); }
// Cumulate id & mask bits, preserve reflection
argFlag operator| (const argFlag& b)
{ argFlag r{ (n.empty()? ""s : n+" | ") + b.n, 0 };
r.id = id | b.id; r.mask = mask | b.mask; return /* move */r; }
// operator<< (has atom Id ? Meaning flag = .. | Atom | .. )
bool operator<< (const argFlag& b)
{ .. }
}
Now you can make the list of base flags provided to the user, these are "atomic" flags : each one has 1 single true bit in id.
Now when user passes flag Symlink2Folder | HiddenFile :
you can decompose it to its building atoms (2 here) using id
you can't confuse this with Symlink2HiddenFolder | File (same mask, but different id bits) : exact error messages are achievable.
the mask member has all the right bits set (Symlink | Folder | Hidden | File). For cheap logical checks.
Reach for whatever member you need to achieve an operation on a flag (check id, check logical composition).
Using a couple of lambdas & macros, validateFlags() (example) can be very readably written in under 100 lines of code to handle gazillion unfathomable combinations (4 atoms make for 96x95x94x93 ~ 80 millions combinations).
You can try to get past validateFlags() in main() using whatever unlikely combination you can come up with ! Good luck ;-)