result.c

Go to the documentation of this file.

 
#include <derive-c/prelude.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
enum error_kind {
    ERROR_KIND_NOT_FOUND,
    ERROR_KIND_INVALID,
    ERROR_KIND_PERMISSION_DENIED,
};
 
static char const* error_kind_to_str(enum error_kind self) {
    switch (self) {
    case ERROR_KIND_NOT_FOUND:
        return "NOT_FOUND";
    case ERROR_KIND_INVALID:
        return "INVALID";
    case ERROR_KIND_PERMISSION_DENIED:
        return "PERMISSION_DENIED";
    }
    return "UNKNOWN";
}
 
static void error_kind_debug(enum error_kind const* self, dc_debug_fmt /* fmt */, FILE* stream) {
    fprintf(stream, "error_kind::%s", error_kind_to_str(*self));
}
 
struct example_data {
    int value;
    char* description;
};
 
static void example_data_delete(struct example_data* self) { free(self->description); }
 
static void example_data_debug(struct example_data const* self, dc_debug_fmt fmt, FILE* stream) {
    fprintf(stream, "example_data@%p {\n", (void*)self);
    fmt = dc_debug_fmt_scope_begin(fmt);
    dc_debug_fmt_print(fmt, stream, "value: %d,\n", self->value);
    dc_debug_fmt_print(fmt, stream, "description: %s,\n", self->description);
    fmt = dc_debug_fmt_scope_end(fmt);
    dc_debug_fmt_print(fmt, stream, "}");
}
 
#define OK struct example_data
#define OK_DELETE example_data_delete
#define OK_DEBUG example_data_debug
#define ERROR enum error_kind
#define ERROR_DEBUG error_kind_debug
#define NAME example_result
#include <derive-c/utils/result/template.h>
 
static void example_result_example(DC_LOGGER* parent) {
    DC_SCOPED(DC_LOGGER) log = DC_LOGGER_NEW(parent, "%s", __func__);
 
    DC_LOG(log, DC_INFO, "creating success result");
    DC_SCOPED(example_result)
    success_result = example_result_from_ok((struct example_data){
        .value = 42,
        .description = strdup("A successful result"),
    });
 
    DC_LOG(log, DC_INFO, "creating error results");
    DC_SCOPED(example_result) error_result = example_result_from_error(ERROR_KIND_NOT_FOUND);
    DC_SCOPED(example_result) invalid_result = example_result_from_error(ERROR_KIND_INVALID);
    DC_SCOPED(example_result)
    permission_result = example_result_from_error(ERROR_KIND_PERMISSION_DENIED);
 
    DC_LOG(log, DC_INFO, "success: %s", DC_DEBUG(example_result_debug, &success_result));
    DC_LOG(log, DC_INFO, "error: %s", DC_DEBUG(example_result_debug, &error_result));
    DC_LOG(log, DC_INFO, "invalid: %s", DC_DEBUG(example_result_debug, &invalid_result));
    DC_LOG(log, DC_INFO, "permission: %s", DC_DEBUG(example_result_debug, &permission_result));
 
    DC_ASSERT(!example_result_is_error(&success_result));
    DC_ASSERT(example_result_is_error(&error_result));
    DC_ASSERT(example_result_is_error(&invalid_result));
    DC_ASSERT(example_result_is_error(&permission_result));
 
    struct example_data const* ok_data = example_result_get_okay(&success_result);
    DC_ASSERT(ok_data != NULL);
    DC_ASSERT(ok_data->value == 42);
    DC_ASSERT(strcmp(ok_data->description, "A successful result") == 0);
 
    enum error_kind const* error_data = example_result_get_error(&error_result);
    DC_ASSERT(error_data != NULL);
    DC_ASSERT(*error_data == ERROR_KIND_NOT_FOUND);
 
    enum error_kind const* invalid_data = example_result_get_error(&invalid_result);
    DC_ASSERT(invalid_data != NULL);
    DC_ASSERT(*invalid_data == ERROR_KIND_INVALID);
 
    enum error_kind const* permission_data = example_result_get_error(&permission_result);
    DC_ASSERT(permission_data != NULL);
    DC_ASSERT(*permission_data == ERROR_KIND_PERMISSION_DENIED);
 
    DC_ASSERT(example_result_get_okay(&error_result) == NULL);
    DC_ASSERT(example_result_get_error(&success_result) == NULL);
 
    DC_LOG(log, DC_INFO, "all assertions passed");
}
 
int main() {
    DC_SCOPED(DC_LOGGER)
    root = NS(DC_LOGGER,
              new_global)((NS(DC_LOGGER, global_config)){.stream = stdout, .ansi_colours = true},
                          (dc_log_id){"result"});
 
    example_result_example(&root);
    return 0;
}