amxc_variant_dump.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <syslog.h>
#include <amxc/amxc_string.h>
#include <amxc/amxc_variant_type.h>
#include <amxc/amxc_rbuffer.h>
#include <amxc/amxc_string_split.h>
#include <amxc_variant_priv.h>
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Data Structures
struct	_amxc_log_var

Typedefs
typedef struct _amxc_log_var	amxc_log_var_t
typedef int(*	amxc_var_dump_fn_t) (const amxc_var_t *const var, int indent, amxc_log_var_t *log)

Functions
static void	amxc_var_log_init (amxc_log_var_t *log, int fd, FILE *stream, size_t msg_length)
static int	amxc_var_write (amxc_log_var_t *log, const char *line, size_t length)
static int	amxc_var_dump_internal (const amxc_var_t *const var, int indent, amxc_log_var_t *log)
static void	write_indentation (int indent, amxc_log_var_t *log)
static int	variant_dump_type (const amxc_var_t *const var, int indent, amxc_log_var_t *log)
static int	variant_dump_null (UNUSED const amxc_var_t *const var, int indent, amxc_log_var_t *log)
static int	variant_dump_char (const amxc_var_t *const var, int indent, amxc_log_var_t *log)
static int	variant_dump_default (const amxc_var_t *const var, int indent, amxc_log_var_t *log)
static int	variant_dump_list (const amxc_var_t *const var, int indent, amxc_log_var_t *log)
static int	variant_dump_htable (const amxc_var_t *const var, int indent, amxc_log_var_t *log)
static int	variant_dump_fd (const amxc_var_t *const var, int indent, amxc_log_var_t *log)
static int	variant_dump_ts (const amxc_var_t *const var, int indent, amxc_log_var_t *log)
static int	amxc_var_dump_impl (const amxc_var_t *const var, int fd, FILE *stream)
int	amxc_var_dump (const amxc_var_t *const var, int fd)
	Dumps the content of the variant in a human readable manner. More...
int	amxc_var_dump_stream (const amxc_var_t *const var, FILE *stream)
	Dumps the content of the variant in a human readable manner. More...
int	amxc_var_log (const amxc_var_t *const var)
	Logs the content of the variant in a human readable manner to syslog. More...

Typedef Documentation

amxc_log_var_t

typedef struct _amxc_log_var amxc_log_var_t

amxc_var_dump_fn_t

typedef int(* amxc_var_dump_fn_t) (const amxc_var_t *const var, int indent, amxc_log_var_t *log)

Definition at line 74 of file amxc_variant_dump.c.

Function Documentation

amxc_var_dump_impl()

static int amxc_var_dump_impl ( const amxc_var_t *const  var, int  fd, FILE *  stream  )

static

Definition at line 321 of file amxc_variant_dump.c.

                                                                                 {
    int retval = 0;
    amxc_log_var_t log;
 
    amxc_var_log_init(&log, fd, stream, 0);
 
    if(var == NULL) {
        amxc_var_write(&log, "NULL\n", 5);
        goto exit;
    }
 
    retval = amxc_var_dump_internal(var, 0, &log);
    when_true(amxc_var_write(&log, "\n", 1) == -1, exit);
 
exit:
    amxc_string_clean(&log.message);
    return retval;
}

amxc_var_dump_internal()

static int amxc_var_dump_internal ( const amxc_var_t *const  var, int  indent, amxc_log_var_t *  log  )

static

Definition at line 283 of file amxc_variant_dump.c.

                                                       {
    int retval = -1;
    amxc_var_dump_fn_t dumpfn[AMXC_VAR_ID_CUSTOM_BASE] = {
        variant_dump_null,
        variant_dump_char,
        variant_dump_default,
        variant_dump_default,
        variant_dump_default,
        variant_dump_default,
        variant_dump_default,
        variant_dump_default,
        variant_dump_default,
        variant_dump_default,
        variant_dump_default,
        variant_dump_default,
        variant_dump_default,
        variant_dump_list,
        variant_dump_htable,
        variant_dump_fd,
        variant_dump_ts,
        variant_dump_char,
        variant_dump_char,
        NULL,
    };
 
    if(var->type_id >= AMXC_VAR_ID_CUSTOM_BASE) {
        retval = variant_dump_default(var, indent, log);
    } else {
        if(dumpfn[var->type_id] != NULL) {
            retval = dumpfn[var->type_id](var, indent, log);
        }
    }
 
    return retval;
}

amxc_var_log_init()

static void amxc_var_log_init ( amxc_log_var_t *  log, int  fd, FILE *  stream, size_t  msg_length  )

static

Definition at line 78 of file amxc_variant_dump.c.

                                                                                            {
    log->fd = fd;
    log->stream = stream;
    amxc_string_init(&log->message, msg_length);
}

amxc_var_write()

static int amxc_var_write ( amxc_log_var_t *  log, const char *  line, size_t  length  )

static

Definition at line 84 of file amxc_variant_dump.c.

                                         {
    int retval = 0;
    if(log->fd != -1) {
        retval = write(log->fd, line, length);
    } else if(log->stream != NULL) {
        retval = fwrite(line, 1, length, log->stream); // size is 1 to return the number of bytes like write()
    } else {
        retval = amxc_string_append(&log->message, line, length);
        if(amxc_string_search(&log->message, "\n", 0) >= 0) {
            syslog(LOG_DAEMON | LOG_DEBUG,
                   "%s", amxc_string_get(&log->message, 0));
            amxc_string_reset(&log->message);
        }
    }
    return retval;
}

variant_dump_char()

static int variant_dump_char ( const amxc_var_t *const  var, int  indent, amxc_log_var_t *  log  )

static

Definition at line 156 of file amxc_variant_dump.c.

                                                  {
    const char* txt = amxc_var_constcast(cstring_t, var);
    write_indentation(indent, log);
    when_true(amxc_var_write(log, "\"", 1) == -1, exit);
    if(txt != NULL) {
        when_true(amxc_var_write(log, txt, strlen(txt)) == -1, exit);
    }
    when_true(amxc_var_write(log, "\"", 1) == -1, exit);
 
exit:
    return 0;
}

variant_dump_default()

static int variant_dump_default ( const amxc_var_t *const  var, int  indent, amxc_log_var_t *  log  )

static

Definition at line 171 of file amxc_variant_dump.c.

                                                     {
    int retval = -1;
    char* text = amxc_var_dyncast(cstring_t, var);
 
    write_indentation(indent, log);
 
    if(text != NULL) {
        when_true(amxc_var_write(log, text, strlen(text)) == -1, exit);
        retval = 0;
    } else {
        retval = variant_dump_type(var, indent, log);
    }
 
exit:
    free(text);
    return retval;
}

variant_dump_fd()

static int variant_dump_fd ( const amxc_var_t *const  var, int  indent, amxc_log_var_t *  log  )

static

Definition at line 269 of file amxc_variant_dump.c.

                                                {
    variant_dump_type(var, indent, log);
    return variant_dump_default(var, indent, log);
}

variant_dump_htable()

static int variant_dump_htable ( const amxc_var_t *const  var, int  indent, amxc_log_var_t *  log  )

static

Definition at line 220 of file amxc_variant_dump.c.

                                                    {
    const amxc_htable_t* htable = amxc_var_constcast(amxc_htable_t, var);
    amxc_array_t* keys = amxc_htable_get_sorted_keys(htable);
    const char* prev_key = NULL;
    amxc_htable_it_t* it = NULL;
 
    when_true(amxc_var_write(log, "{\n", 2) == -1, exit);
    indent += 4;
    for(uint32_t i = 0; i < amxc_array_capacity(keys); i++) {
        amxc_var_t* hvar = NULL;
        const char* key
            = (const char*) amxc_array_it_get_data(amxc_array_get_at(keys, i));
        if((prev_key != NULL) && (key != NULL) && (strcmp(key, prev_key) == 0)) {
            it = amxc_htable_it_get_next_key(it);
        } else {
            it = amxc_htable_get(htable, key);
        }
        prev_key = key;
        hvar = amxc_var_from_htable_it(it);
        write_indentation(indent, log);
        if(key != NULL) {
            when_true(amxc_var_write(log, key, strlen(key)) == -1, exit);
        } else {
            when_true(amxc_var_write(log, "UNKNOWN", 7) == -1, exit);
        }
        when_true(amxc_var_write(log, " = ", 3) == -1, exit);
        if((amxc_var_type_of(hvar) == AMXC_VAR_ID_HTABLE) ||
           ( amxc_var_type_of(hvar) == AMXC_VAR_ID_LIST)) {
            amxc_var_dump_internal(hvar, indent, log);
        } else {
            amxc_var_dump_internal(hvar, 0, log);
        }
        if(i + 1 < amxc_array_capacity(keys)) {
            when_true(amxc_var_write(log, ",\n", 2) == -1, exit);
        } else {
            when_true(amxc_var_write(log, "\n", 1) == -1, exit);
        }
    }
    indent -= 4;
    write_indentation(indent, log);
    when_true(amxc_var_write(log, "}", 1) == -1, exit);
 
exit:
    amxc_array_delete(&keys, NULL);
    return 0;
}

variant_dump_list()

static int variant_dump_list ( const amxc_var_t *const  var, int  indent, amxc_log_var_t *  log  )

static

Definition at line 191 of file amxc_variant_dump.c.

                                                  {
 
    const amxc_llist_t* list = amxc_var_constcast(amxc_llist_t, var);
 
    when_true(amxc_var_write(log, "[\n", 2) == -1, exit);
    indent += 4;
    amxc_llist_for_each(it, list) {
        amxc_var_t* lvar = amxc_var_from_llist_it(it);
        if((amxc_var_type_of(lvar) == AMXC_VAR_ID_HTABLE) ||
           ( amxc_var_type_of(lvar) == AMXC_VAR_ID_LIST)) {
            write_indentation(indent, log);
        }
        amxc_var_dump_internal(lvar, indent, log);
        if(amxc_llist_it_get_next(it) != NULL) {
            when_true(amxc_var_write(log, ",\n", 2) == -1, exit);
        } else {
            when_true(amxc_var_write(log, "\n", 1) == -1, exit);
        }
    }
    indent -= 4;
    write_indentation(indent, log);
    when_true(amxc_var_write(log, "]", 1) == -1, exit);
 
exit:
    return 0;
}

variant_dump_null()

static int variant_dump_null ( UNUSED const amxc_var_t *const  var, int  indent, amxc_log_var_t *  log  )

static

Definition at line 146 of file amxc_variant_dump.c.

                                                  {
    write_indentation(indent, log);
    when_true(amxc_var_write(log, "<NULL>", 6) == -1, exit);
 
exit:
    return 0;
}

variant_dump_ts()

static int variant_dump_ts ( const amxc_var_t *const  var, int  indent, amxc_log_var_t *  log  )

static

Definition at line 276 of file amxc_variant_dump.c.

                                                {
    variant_dump_type(var, indent, log);
    return variant_dump_default(var, indent, log);
}

variant_dump_type()

static int variant_dump_type ( const amxc_var_t *const  var, int  indent, amxc_log_var_t *  log  )

static

Definition at line 116 of file amxc_variant_dump.c.

                                                  {
    amxc_string_t txt;
    char addr[64] = "";
    const char* type_name = amxc_var_type_name_of(var);
 
    write_indentation(indent, log);
    amxc_string_init(&txt, 64);
    amxc_string_append(&txt, "<", 1);
    if(type_name != NULL) {
        amxc_string_append(&txt, type_name, strlen(type_name));
    } else {
        amxc_string_append(&txt, "UNKNOWN", 7);
    }
    amxc_string_append(&txt, ">:", 2);
    if(amxc_var_type_of(var) > AMXC_VAR_ID_ANY) {
        snprintf(addr, 63, "%p:", var->data.data);
        amxc_string_append(&txt, addr, strlen(addr));
    }
    when_true(amxc_var_write(log,
                             amxc_string_get(&txt, 0),
                             amxc_string_text_length(&txt)) == -1,
              exit);
 
exit:
    amxc_string_clean(&txt);
    return 0;
}

write_indentation()

static void write_indentation ( int  indent, amxc_log_var_t *  log  )

static

Definition at line 107 of file amxc_variant_dump.c.

                                                               {
    for(int i = 0; i < indent; i++) {
        when_true(amxc_var_write(log, " ", 1) == -1, exit);
    }
 
exit:
    return;
}