Class DiffFlags

tools/ktx/command_compare.cpp:272–319

};

struct DiffFlags : DiffBase<uint32_t> {
    DiffFlags(const std::string_view textHeaderIn, const std::string_view jsonPathIn,
        const std::optional<uint32_t>& value1, const std::optional<uint32_t>& value2,
        const char*(*bitToString)(uint32_t, bool))
        : DiffBase<uint32_t>(textHeaderIn, jsonPathIn, value1, value2), toStringFn(bitToString) {}

    DiffFlags(const std::string_view textHeaderIn, const std::string_view jsonPathIn, const uint32_t& value1, const uint32_t& value2,
        const char*(*bitToString)(uint32_t, bool))
        : DiffBase<uint32_t>(textHeaderIn, jsonPathIn, value1, value2), toStringFn(bitToString) {}

    virtual std::string value(std::size_t index, OutputFormat format) const override {
        const auto space = format != OutputFormat::json_mini ?  " " : "";
        const auto quote = format == OutputFormat::text ? "" : "\"";

        std::stringstream formattedValue;
        bool first = true;
        std::string comma = "";
        for (uint32_t bitIndex = 0; bitIndex < 32; ++bitIndex) {
            uint32_t bitMask = 1u << bitIndex;
            bool bitValue = (bitMask & DiffBase<uint32_t>::rawValue(index)) != 0;

            const char* bitStr = toStringFn(bitIndex, bitValue);
            if (bitStr) {
                fmt::print(formattedValue, "{}{}{}{}", comma, quote, bitStr, quote);
            } else if (bitValue) {
                fmt::print(formattedValue, "{}{}", comma, bitMask);
            }

            if (bitValue && first) {
                first = false;
                comma = fmt::format(",{}", space);
            }
        }

        if (format == OutputFormat::text) {
            return fmt::format("0x{:x} ({})", DiffBase<uint32_t>::rawValue(index), formattedValue.str());
        } else {
            if (formattedValue.str().empty()) {
                return "[]";
            } else {
                return fmt::format("[{}{}{}]", space, formattedValue.str(), space);
            }
        }
    }

private:
    const char*(*toStringFn)(uint32_t, bool);
};

template <typename T, std::size_t N>
struct DiffArray : public DiffBase<std::array<T, N>> {