GStreamer GError to boost::system::error_code？

Question

Looking for a clever way to transform a gstreamer/glib GError:

 struct GError { GQuark domain; gint code; gchar* message; };

to a boost::system::error_code. Typically, you could create a category and register an enum to boost. GStreamer uses enum but the code is returned as an int. GQuark is a category.

This is mainly to standardize error handling across an application.

Answer 1

GQuark is a category.

I think you mean that figuratively.

Quarks are associations between strings and integer identifiers. Given either the string or the Quark identifier it is possible to retrieve the other.

That's like interned strings, aka atoms. So GQuark actually represents a string, then, that you want to treat as a category. Well then.

Categories are static

Well. Usually. At the very least categories are singleton with global object identity. So, assuming that you know statically what domains to expect, you could create categories for those.

Map them to the text representation of the domain makes for the most stable mappings.

A single category

To get started, here's a single category:

using boost::system::error_code;
using boost::system::error_condition;

enum class MyCoreError {
    failed,          // a general error which doesn't fit in any other category.  Make sure you add a custom message to the error call.
    too_lazy,        // do not use this except as a placeholder for deciding where to go while developing code.
    not_implemented, // use this when you do not want to implement this functionality yet.
    state_change,    // used for state change errors.
    pad,             // used for pad-related errors.
    thread,          // used for thread-related errors.
    negotiation,     // used for negotiation-related errors.
    event,           // used for event-related errors.
    seek,            // used for seek-related errors.
    caps,            // used for caps-related errors.
    tag,             // used for negotiation-related errors.
    missing_plugin,  // used if a plugin is missing.
    clock,           // used for clock related errors.
    disabled,        // used if functionality has been disabled at compile time.
    num_errors,      // the number of core error types.
};

namespace boost::system { template<> struct is_error_code_enum<MyCoreError> : std::true_type {}; }

namespace detail {
    class my_core_category : public boost::system::error_category {
      public:
        const char* name() const noexcept override { 
            return g_quark_to_string(GST_CORE_ERROR);
        }
        std::string message(int ev) const override {
          switch (static_cast<MyCoreError>(ev)) {
            case MyCoreError::failed: return "a general error which doesn't fit in any other category.  Make sure you add a custom message to the error call.";
            case MyCoreError::too_lazy: return "do not use this except as a placeholder for deciding where to go while developing code.";
            case MyCoreError::not_implemented: return "use this when you do not want to implement this functionality yet.";
            case MyCoreError::state_change: return "used for state change errors.";
            case MyCoreError::pad: return "used for pad-related errors.";
            case MyCoreError::thread: return "used for thread-related errors.";
            case MyCoreError::negotiation: return "used for negotiation-related errors.";
            case MyCoreError::event: return "used for event-related errors.";
            case MyCoreError::seek: return "used for seek-related errors.";
            case MyCoreError::caps: return "used for caps-related errors.";
            case MyCoreError::tag: return "used for negotiation-related errors.";
            case MyCoreError::missing_plugin: return "used if a plugin is missing.";
            case MyCoreError::clock: return "used for clock related errors.";
            case MyCoreError::disabled: return "used if functionality has been disabled at compile time.";
            case MyCoreError::num_errors: return "the number of core error types.";
            default: return "unknown core error";
          }
        }
        error_condition default_error_condition(int ev) const noexcept override {
            return error_condition{ ev, *this };
        }
        bool equivalent(int ev, error_condition const& condition) const noexcept override {
            return condition.value() == ev && &condition.category() == this;
        }
        bool equivalent(error_code const& error, int ev) const noexcept override {
            return error.value() == ev && &error.category() == this;
        }
    };
}
error_code make_error_code(MyCoreError se)
{
    static detail::my_core_category const cat{};
    return error_code{static_cast<std::underlying_type<MyCoreError>::type>(se), cat};
}

Now you can just

auto code = MyCoreError::missing_plugin;
throw boost::system::system_error(make_error_code(code));

and it will magically do the right thing.

General Error Translation:

For the general case translating from API error:

boost::system::error_code make_error_code(GError const& err) {
    if (err.domain == GST_CORE_ERROR) {
        return make_error_code(MyCoreError(err.code));
    }
    if (err.domain == GST_LIBRARY_ERROR) {
        return make_error_code(MyLibraryError(err.code));
    }
    if (err.domain == GST_RESOURCE_ERROR) {
        return make_error_code(MyResourceError(err.code));
    }
    if (err.domain == GST_STREAM_ERROR) {
        return make_error_code(MyStreamError(err.code));
    }
    // decide on how to represent unknown errors? Just throw, or translate into
    // MyCoreError::failed?
}