base2.c

Go to the documentation of this file.

#include "base2_friend.h"

#define BASE2_STR_SIZE 64

typedef struct base2_private_st_ {
    const base2_vtable_st *vtable;
} base2_private_st;

my_rc_e
base2_string_size (base2_handle base2_h, size_t *buffer_size)
{
    my_rc_e rc = MY_RC_E_SUCCESS;

    VALIDATE_VTABLE_FN(base2_h, private_h, vtable, string_size_fn, rc);
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }

    return (base2_h->private_h->vtable->string_size_fn(base2_h, buffer_size));
}

static my_rc_e
base2_string_size_internal (base2_handle base2_h, size_t *buffer_size)
{
    if ((NULL == base2_h) || (NULL == buffer_size)) {
        LOG_ERR("Invalid input, base2_h(%p) buffer_size(%p)",
                base2_h, buffer_size);
        return (MY_RC_E_EINVAL);
    }

    *buffer_size = BASE2_STR_SIZE;

    return (MY_RC_E_SUCCESS);
}

static const char *
base2_type_string_internal (base2_handle base2_h)
{
    return ("base2");
}

const char *
base2_type_string (base2_handle base2_h)
{
    my_rc_e rc = MY_RC_E_SUCCESS;

    VALIDATE_VTABLE_FN(base2_h, private_h, vtable, type_string_fn, rc);
    if (my_rc_e_is_notok(rc)) {
        return ("");
    }

    return (base2_h->private_h->vtable->type_string_fn(base2_h));
}

my_rc_e
base2_string (base2_handle base2_h, char *buffer, size_t buffer_size)
{
    my_rc_e rc = MY_RC_E_SUCCESS;

    VALIDATE_VTABLE_FN(base2_h, private_h, vtable, string_fn, rc);
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }

    return (base2_h->private_h->vtable->string_fn(base2_h, buffer,
                                                  buffer_size));
}

static my_rc_e
base2_string_internal (base2_handle base2_h, char *buffer, size_t buffer_size)
{
    size_t min_size;
    my_rc_e rc = MY_RC_E_SUCCESS;

    if ((NULL == base2_h) || (NULL == buffer)) {
        LOG_ERR("Invalid input, base2_h(%p) buffer(%p) buffer_size(%zu)",
                base2_h, buffer, buffer_size);
        return (MY_RC_E_EINVAL);
    }

    VALIDATE_VTABLE_FN(base2_h, private_h, vtable, string_size_fn, rc);
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }

    rc = base2_h->private_h->vtable->string_size_fn(base2_h, &min_size);
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }

    if (buffer_size < min_size) {
        LOG_ERR("Invalid input, buffer_size(%zu)", buffer_size);
        return (MY_RC_E_EINVAL);
    }

    snprintf(buffer, buffer_size, "val1(%u)", base2_h->val1);

    return (MY_RC_E_SUCCESS);
}

static void
base2_delete_internal (base2_handle base2_h, bool free_base2_h)
{
    if (NULL == base2_h) {
        return;
    }

    if (NULL != base2_h->private_h) {
        free(base2_h->private_h);
        base2_h->private_h = NULL;
    }

    if (free_base2_h) {
        free(base2_h);
    }
}

void
base2_friend_delete (base2_handle base2_h)
{
    base2_delete_internal(base2_h, false);
}

static void
base2_private_delete (base2_handle base2_h)
{
    base2_delete_internal(base2_h, true);
}

void
base2_delete (base2_handle base2_h)
{
    my_rc_e rc = MY_RC_E_SUCCESS;

    VALIDATE_VTABLE_FN(base2_h, private_h, vtable, delete_fn, rc);
    if (my_rc_e_is_notok(rc)) {
        return;
    }

    return (base2_h->private_h->vtable->delete_fn(base2_h));
}

my_rc_e
base2_increase_val1 (base2_handle base2_h)
{
    my_rc_e rc = MY_RC_E_SUCCESS;

    VALIDATE_VTABLE_FN(base2_h, private_h, vtable, increase_val1_fn, rc);
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }

    return (base2_h->private_h->vtable->increase_val1_fn(base2_h));
}

my_rc_e
base2_get_val1 (base2_handle base2_h, uint32_t *val1)
{
    if ((NULL == base2_h) || (NULL == val1)) {
        LOG_ERR("Invalid input, base2_h(%p) val1(%p)", base2_h, val1);
        return (MY_RC_E_EINVAL);
    }

    *val1 = base2_h->val1;

    return (MY_RC_E_SUCCESS);
}

static const base2_vtable_st base2_vtable = {
    base2_private_delete,
    base2_type_string_internal,
    base2_string_internal,
    base2_string_size_internal,
    NULL
};

my_rc_e
base2_inherit_vtable (const base2_vtable_st *parent_vtable,
                      base2_vtable_st *child_vtable,
                      bool do_null_check)
{
    my_rc_e rc = MY_RC_E_SUCCESS;

    /* Always add a new check here if functions are added. */
    CT_ASSERT(5 == (sizeof(base2_vtable_st)/sizeof(void*)));

    if ((NULL == parent_vtable) || (NULL == child_vtable)) {
        LOG_ERR("Invalid input, parent_vtable(%p) "
                "child_vtable(%p)", parent_vtable, child_vtable);
        return (MY_RC_E_EINVAL);
    }

    INHERIT_VTABLE_FN(parent_vtable, child_vtable, delete_fn, do_null_check,
                      rc);
    INHERIT_VTABLE_FN(parent_vtable, child_vtable, type_string_fn,
                      do_null_check, rc);
    INHERIT_VTABLE_FN(parent_vtable, child_vtable, string_fn, do_null_check,
                      rc);
    INHERIT_VTABLE_FN(parent_vtable, child_vtable, string_size_fn,
                      do_null_check, rc);
    INHERIT_VTABLE_FN(parent_vtable, child_vtable, increase_val1_fn,
                      do_null_check, rc);

    return (MY_RC_E_SUCCESS);

err_exit:

    return (rc);
}

my_rc_e
base2_set_vtable (base2_handle base2_h, base2_vtable_st *vtable)
{
    my_rc_e rc;

    if ((NULL == base2_h) || (NULL == vtable)) {
        LOG_ERR("Invalid input, base2_h(%p) vtable(%p)", base2_h, vtable);
        return (MY_RC_E_EINVAL);
    }

    if (NULL == base2_h->private_h) {
        LOG_ERR("Invalid input, base2_h(%p)->private_h(%p)", base2_h,
                base2_h->private_h);
        return (MY_RC_E_EINVAL);
    }

    rc = base2_inherit_vtable(&base2_vtable, vtable, true);
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }

    base2_h->private_h->vtable = vtable;

    return (MY_RC_E_SUCCESS);
}

my_rc_e
base2_init (base2_handle base2_h)
{
    my_rc_e rc = MY_RC_E_SUCCESS;

    if (NULL == base2_h) {
        LOG_ERR("Invalid input, base2_h(%p)", base2_h);
        return (MY_RC_E_EINVAL);
    }

    base2_h->private_h = calloc(1, sizeof(*base2_h->private_h));
    if (NULL == base2_h->private_h) {
        rc = MY_RC_E_ENOMEM;
        goto err_exit;
    }

    base2_h->private_h->vtable = &base2_vtable;
    base2_h->val1 = 7;

    return (MY_RC_E_SUCCESS);

err_exit:

    if (NULL != base2_h->private_h) {
        free(base2_h->private_h);
        base2_h->private_h = NULL;
    }

    return (rc);
}