How C++ represents state flags related to the order of operations?

Question

I am now working on a motion control system. I want to make the motion control interface more flexible, so I want to provide an api that can specifiy the controlled axis.

It just like.

void moveTo(/*data*/, Axis which);

Axis parameter is used to define how the motion data should be treated as and the internal implement will check the data according the requested axis.

So i want to define a operation rules on Axis parameters.

I tried the bit flags, defined as follow.

enum class Axis : std::uint_fast16_t {
    X = 1l << 0,
    Y = 1l << 1,
    Z = 1l << 2
}; 
// operator | and & and so on are also defined.

It can be used as follow.

const auto which = Axis::X | Axis::Y;

But what i want is that, Axis::X | Axis::Y and Axis::Y | Axis::X should be different, but now they have same value. There is no way to distinguish them inside the function.

How should I define such a bit mask that appears to be related to "order of operations"?

It seems to do this by listing all allowed combined states in a single enumeration. But I still want to ask if there is a more elegant and clear solution.

Or any suggestion for a better implementation of such functionality?

I hope the final usage is still as simple as the bit mask, I don't mind if I do some really complicated work behind the scenes, I don't mind using any 3rd party library.

Answer 1

Given that you just have 3 axes and a limited amount of combinations, I'd suggest just defining them all.

enum class Axis : std::uint_fast16_t {
    X   = 0,
    Y   = 1,
    Z   = 2,
    XX  = 3,
    YX  = 4,
    ZX  = 5,
    XY  = 6,
    YY  = 7,
    ZY  = 8,
    XZ  = 9,
    YZ  = 10,
    ZZ  = 11,
    XXX = 12,
    YXX = 13,
    ZXX = 14,
    XYX = 15,
    YYX = 16,
    ZYX = 17,
    XZX = 18,
    YZX = 19,
    ZZX = 20,
    XXY = 21,
    YXY = 22,
    ZXY = 23,
    XYY = 24,
    YYY = 25,
    ZYY = 26,
    XZY = 27,
    YZY = 28,
    ZZY = 29,
    XXZ = 30,
    YXZ = 31,
    ZXZ = 32,
    XYZ = 33,
    YYZ = 34,
    ZYZ = 35,
    XZZ = 36,
    YZZ = 37,
    ZZZ = 38,
};

---

If you want to do it programmatically, what you can do is to make the flag by shifting the value by 2 every time you add a new flag, as each value is represented by 2 bits.

#include <type_traits>
#include <array>
#include <iostream>
#include <bitset>


enum class Axis : std::uint_fast16_t {
    X = 0b01,
    Y = 0b10,
    Z = 0b11,
};


Axis append_flag(Axis current, Axis to_append) {
    std::uint_fast16_t flag = static_cast<std::uint_fast16_t>(current);
    flag = (flag << 2) | static_cast<std::uint_fast16_t>(to_append);
    return static_cast<Axis>(flag);
}


template <class ... T>
Axis make_flag(T ... axes) {
    std::array values = { axes... };
    auto flag = values[0];
    for (std::size_t i = 1; i < values.size(); ++i) {
        flag = append_flag(flag, values[i]);
    }

    return flag;
}


int main(int argc, const char* argv[]) {
    auto result = make_flag(Axis::X, Axis::Y, Axis::Z);
    auto value  = static_cast<std::size_t>(result);
    std::cout << value << " (" << std::bitset<16>(value) << ")" << std::endl;
    return 0;
}