result.c File Reference

#include <derive-c/prelude.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <derive-c/utils/result/template.h>

Go to the source code of this file.

Data Structures
struct	example_data

Macros
#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

Enumerations
enum	error_kind { ERROR_KIND_NOT_FOUND , ERROR_KIND_INVALID , ERROR_KIND_PERMISSION_DENIED }

Functions
static char const *	error_kind_to_str (enum error_kind self)
static void	error_kind_debug (enum error_kind const *self, dc_debug_fmt, FILE *stream)
static void	example_data_delete (struct example_data *self)
static void	example_data_debug (struct example_data const *self, dc_debug_fmt fmt, FILE *stream)
static void	example_result_example (DC_LOGGER *parent)
int	main ()

Macro Definition Documentation

ERROR

#define ERROR   enum error_kind

Definition at line 51 of file result.c.

ERROR_DEBUG

#define ERROR_DEBUG   error_kind_debug

Definition at line 52 of file result.c.

NAME

#define NAME   example_result

Definition at line 53 of file result.c.

OK

#define OK   struct example_data

Definition at line 48 of file result.c.

OK_DEBUG

#define OK_DEBUG   example_data_debug

Definition at line 50 of file result.c.

OK_DELETE

#define OK_DELETE   example_data_delete

Definition at line 49 of file result.c.

Enumeration Type Documentation

error_kind

enum error_kind

Enumerator
ERROR_KIND_NOT_FOUND
ERROR_KIND_INVALID
ERROR_KIND_PERMISSION_DENIED

Examples

utils/result.c.

Definition at line 10 of file result.c.

                {
    ERROR_KIND_NOT_FOUND,
    ERROR_KIND_INVALID,
    ERROR_KIND_PERMISSION_DENIED,
};

Function Documentation

error_kind_debug()

void error_kind_debug ( enum error_kind const * self, dc_debug_fmt , FILE * stream )

static

Examples

utils/result.c.

Definition at line 28 of file result.c.

                                                                                        {
    fprintf(stream, "error_kind::%s", error_kind_to_str(*self));
}

error_kind_to_str()

char const * error_kind_to_str ( enum error_kind self )

static

Examples

utils/result.c.

Definition at line 16 of file result.c.

                                                           {
    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";
}

example_data_debug()

void example_data_debug ( struct example_data const * self, dc_debug_fmt fmt, FILE * stream )

static

Definition at line 39 of file result.c.

                                                                                                {
    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, "}");
}

example_data_delete()

void example_data_delete ( struct example_data * self )

static

Definition at line 37 of file result.c.

{ free(self->description); }

example_result_example()

void example_result_example ( DC_LOGGER * parent )

static

Examples

utils/result.c.

Definition at line 56 of file result.c.

                                                      {
    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");
}

main()

int main

(

)

Definition at line 105 of file result.c.

           {
    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;
}