Printing consecutive enums

Question

I am looking to only print out the "grouped" enums but having trouble getting the expected behaviour. So basically printing out all the enums from the specified base Values until there isn't any subsequent consecutive enum value. Each "group" of enum can be determined by ANDing with a mask 0xFFFF0000

The trick is I could iterate over _map enum but then there won't be an easy way to check whether the corresponding key exists. find method takes a key so that won't help.

P.S: _map already exists for 'other' purposes so I can't change that

enum class Values : uint32_t
{
  one    =  0x00000000,
  oneOne =  0x00000001,
  oneTwo =  0x00000002,

  two =     0x00010000,
  twoOne =  0x00010001,
  twoTwo =  0x00010002,

  three    =  0x00020000,
  threeOne =  0x00020001,
  threeTwo =  0x00020002,
  //...


  MAX
};

std::unordered_map<std::string, Values> _map =
{
    {"one",     Values::one},
    {"oneOne",  Values::oneOne},
    {"oneTwo",  Values::oneTwo},
    {"two",     Values::two},
    {"twoOne",  Values::twoOne},
    {"twoTwo",  Values::twoTwo}
};

What I came up with is the following but there isn't a way to "break" where the enum value doesn't exist.

void foo(Values base)
{
    uint32_t mask = static_cast<uint32_t>(base) & 0xffff0000;

    for (Values i = base; i < Values::MAX; i = static_cast<Values>(static_cast<uint32_t>(i) + 1)) 
    {
        uint32_t curMask = static_cast<uint32_t>(i) & 0xffff0000;

        if (curMask != mask) 
        {
            break;  // stop if we've reached a different upper 16 bits value
        }
        
        std::cout << std::hex << static_cast<uint32_t>(i) << "\n";
    }
}

// expected calls with expected output
foo(Values::one);      // should print: one, oneOne, oneTwo
foo(Values::oneOne);   // should print: oneOne, oneTwo
foo(Values::twoTwo);   // should print: twoTwo

Answer 1

If you have

const std::unordered_map<std::string, Values> _map = {
    {"one", Values::one},       
    {"oneOne", Values::oneOne},
    {"oneTwo", Values::oneTwo}, 
    {"two", Values::two},
    {"twoOne", Values::twoOne}, 
    {"twoTwo", Values::twoTwo}};

I suggest adding a reverse lookup std::map

const auto _rmap = []{
    std::map<Values, decltype(_map.cbegin())> rv;
    for(auto it = _map.cbegin(); it != _map.cend(); ++it)
        rv.emplace(it->second, it);
    return rv;
}();

... to be able to use std::map::upper_bound to get an iterator to the first element after the subgroup you are interested in:

void foo(Values base) {
    if (auto it = _rmap.find(base); it != _rmap.end()) {
        // mask contains the highest possible value in the subgroup:
        auto mask = static_cast<Values>(static_cast<uint32_t>(base) | 0xffff);

        // end is an iterator to the first element after `mask`
        auto end = _rmap.upper_bound(mask);

        for (; it != end; ++it) {
            // dereference the iterator into the original map:
            const auto& [str, val] = *it->second;

            std::cout << str << '\t' << static_cast<uint32_t>(val) << '\n';
        }
    }
}

Demo

---

---

If you prefer to store std::strings in the reverse lookup std::map instead of iterators, that works fine too:

#include <algorithm> // std::transform

const auto _rmap = [] {
    std::map<Values, std::string> rv;
    std::transform(_map.begin(), _map.end(), std::inserter(rv, rv.end()),
                   [](auto&& p) { return std::pair{p.second, p.first}; });
    return rv;
}();

void foo(Values base) {
    if (auto it = _rmap.find(base); it != _rmap.end()) {
        auto mask = static_cast<Values>(static_cast<uint32_t>(base) | 0xffff);
        auto end = _rmap.upper_bound(mask);
        for (; it != end; ++it) {
            const auto& [val, str] = *it;

            std::cout << str << '\t' << static_cast<uint32_t>(val) << '\n';
        }
    }
}

Demo

Answer 2

Just reverse _map into another map and use that to help identify which "Values" are valid.

I modified your code slightly and declared reverseMap in your foo function. But you could move the initialization of reverseMap to be a global or member variable somewhere else.

struct ReverseMapContainer
{
    std::unordered_map<uint32_t, std::string> reverseMap;
    ReverseMapContainer()
    {
        for (const auto& v : _map)
        {
            reverseMap.insert({ (uint32_t)(v.second), v.first });
        }
    }
};

void foo(Values base)
{
    static ReverseMapContainer rmc;
    const auto& reverseMap = rmc.reverseMap;

    uint32_t mask = static_cast<uint32_t>(base) & 0xffff0000;
    uint32_t stop = mask + 0x00010000;

    for (uint32_t i = (uint32_t)base; i < stop; i++)
    {
        auto itor = reverseMap.find(i);
        if (itor != reverseMap.end())
        {
            std::cout << itor->second << " ";
        }
        else
        {
            break;
        }
    }
    std::cout << "\n";
}

And then to test it with the same criteria you had:

int main()
{
    // expected calls with expected output
    foo(Values::one);      // should print: one, oneOne, oneTwo
    foo(Values::oneOne);   // should print: oneOne, oneTwo
    foo(Values::twoTwo);   // should print: twoTwo
}

Result: