Rose/BitFlags.h

#ifndef ROSE_BitFlags_H
#define ROSE_BitFlags_H
#include <RoseFirst.h>
 
#include <rosePublicConfig.h>
#include <boost/format.hpp>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#endif
 
#include <Sawyer/Assert.h>
#include <Sawyer/BitFlags.h>
#include <vector>
 
namespace Rose {
 
template<typename E, typename V = int64_t>
class BitFlags: public Sawyer::BitFlags<E, V> {
public:
    typedef E Enum;
    typedef V Vector;
 
    BitFlags()
        : Sawyer::BitFlags<E, V>(0) {}
    BitFlags() {…}
 
    BitFlags(Vector v) /*implicit*/
        : Sawyer::BitFlags<E, V>(v) {}
    BitFlags(Vector v) /*implicit*/ {…}
 
    BitFlags(Sawyer::BitFlags<E, V> bf) /*implicit*/
        : Sawyer::BitFlags<E, V>(bf) {}
    
    std::string toString(std::vector<int64_t> constants, const char*(*stringifier)(int64_t)) const {
        std::string retval;
        if (this->vector() != Vector(0)) {
            Vector leftovers(0);
            std::vector<Enum> members = this->split(constants, leftovers /*out*/);
            for (Enum member: members) {
                const char *name = stringifier(member);
                ASSERT_not_null(name);
                retval += std::string(retval.empty()?"":"|") + name;
            }
            if (leftovers != Vector(0))
                retval += retval.empty()?"":"|" + (boost::format("%lx") % (unsigned long)leftovers).str();
        } else {
            if (const char* name = stringifier(0)) {
                retval = name;
            } else {
                retval = "0";
            }
        }
        return retval;
    }
    std::string toString(std::vector<int64_t> constants, const char*(*stringifier)(int64_t)) const  {…}
};
class BitFlags: public Sawyer::BitFlags<E, V> {…};
 
// Temporary construction helper useful before C++17
template<class E>
inline BitFlags<E>
makeBitFlags(E enumMember) {
    return BitFlags<E>(enumMember);
}
 
} // namespace
 
#endif