base1.c

Go to the documentation of this file.

#include "base1_friend.h"

#define BASE1_STR_SIZE 128

typedef struct base1_private_st_ {
    const base1_vtable_st *vtable;
} base1_private_st;

const char *
base1_get_val1_description (void)
{
    return ("Value 1");
}

my_rc_e
base1_get_public_data (base1_handle base1_h, base1_public_data_st *public_data)
{

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

    memcpy(public_data, &(base1_h->public_data), sizeof(*public_data));

    return (MY_RC_E_SUCCESS);
}

my_rc_e
base1_set_public_data (base1_handle base1_h, base1_public_data_st *public_data)
{

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

    memcpy(&(base1_h->public_data), public_data, sizeof(base1_h->public_data));

    return (MY_RC_E_SUCCESS);
}

my_rc_e
base1_string_size (base1_handle base1_h, size_t *buffer_size)
{
    my_rc_e rc = MY_RC_E_SUCCESS;

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

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

static my_rc_e
base1_string_size_internal (base1_handle base1_h, size_t *buffer_size)
{
    if ((NULL == base1_h) || (NULL == buffer_size)) {
        LOG_ERR("Invalid input, base1_h(%p) buffer_size(%p)",
                base1_h, buffer_size);
        return (MY_RC_E_EINVAL);
    }

    *buffer_size = BASE1_STR_SIZE;

    return (MY_RC_E_SUCCESS);
}

static const char *
base1_type_string_internal (base1_handle base1_h)
{
    return ("base1");
}

const char *
base1_type_string (base1_handle base1_h)
{
    my_rc_e rc = MY_RC_E_SUCCESS;

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

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

my_rc_e
base1_string (base1_handle base1_h, char *buffer, size_t buffer_size)
{
    my_rc_e rc = MY_RC_E_SUCCESS;

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

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

static my_rc_e
base1_string_internal (base1_handle base1_h, char *buffer, size_t buffer_size)
{
    size_t min_size;
    my_rc_e rc = MY_RC_E_SUCCESS;

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

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

    rc = base1_h->private_h->vtable->string_size_fn(base1_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) val2(%u) val3(%u)",
             base1_h->public_data.val1, base1_h->public_data.val2,
             base1_h->val3);

    return (MY_RC_E_SUCCESS);
}

static void
base1_delete_internal (base1_handle base1_h, bool free_base1_h)
{
    if (NULL == base1_h) {
        return;
    }

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

    if (free_base1_h) {
        free(base1_h);
    }
}

void
base1_friend_delete (base1_handle base1_h)
{
    base1_delete_internal(base1_h, false);
}

static void
base1_private_delete (base1_handle base1_h)
{
    base1_delete_internal(base1_h, true);
}

void
base1_delete (base1_handle base1_h)
{
    my_rc_e rc = MY_RC_E_SUCCESS;

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

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

static my_rc_e
base1_increase_val3_internal (base1_handle base1_h)
{
    if (NULL == base1_h) {
        LOG_ERR("Invalid input, base1_h(%p)", base1_h);
        return (MY_RC_E_EINVAL);
    }

    base1_h->val3 *= 2;

    return (MY_RC_E_SUCCESS);
}

my_rc_e
base1_increase_val3 (base1_handle base1_h)
{
    my_rc_e rc = MY_RC_E_SUCCESS;

    VALIDATE_VTABLE_FN(base1_h, private_h, vtable, increase_val3_fn, rc);
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }

    return (base1_h->private_h->vtable->increase_val3_fn(base1_h));
}

static const base1_vtable_st base1_vtable = {
    base1_private_delete,
    base1_type_string_internal,
    base1_string_internal,
    base1_string_size_internal,
    base1_increase_val3_internal
};

my_rc_e
base1_inherit_vtable (const base1_vtable_st *parent_vtable,
                      base1_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(base1_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_val3_fn,
                      do_null_check, rc);

    return (MY_RC_E_SUCCESS);

err_exit:

    return (rc);
}

my_rc_e
base1_set_vtable (base1_handle base1_h, base1_vtable_st *vtable)
{
    my_rc_e rc;

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

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

    rc = base1_inherit_vtable(&base1_vtable, vtable, true);
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }

    base1_h->private_h->vtable = vtable;

    return (MY_RC_E_SUCCESS);
}

my_rc_e
base1_init (base1_handle base1_h)
{
    my_rc_e rc = MY_RC_E_SUCCESS;

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

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

    base1_h->private_h->vtable = &base1_vtable;
    base1_h->public_data.val1 = 1;
    base1_h->public_data.val2 = 2;
    base1_h->val3 = 42;

    return (MY_RC_E_SUCCESS);

err_exit:

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

    return (rc);
}

base1_handle
base1_new1 (void)
{
    base1_st *base1 = NULL;
    my_rc_e rc;

    base1 = calloc(1, sizeof(*base1));
    if (NULL != base1) {
        rc = base1_init(base1);
        if (my_rc_e_is_notok(rc)) {
            LOG_ERR("Init failed, rc(%s)", my_rc_e_get_string(rc));
            goto err_exit;
        }
    }

    return (base1);

err_exit:

    base1_private_delete(base1);

    return (NULL);
}

base1_handle
base1_new2 (base1_public_data_st *public_data)
{
    base1_st *base1 = NULL;

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

    base1 = base1_new1();
    if (NULL != base1) {
        memcpy(&(base1->public_data), public_data, sizeof(base1->public_data));
     }

    return (base1);
}

base1_handle
base1_new3 (uint8_t val1, uint32_t val3)
{
    base1_st *base1 = NULL;

    base1 = base1_new1();
    if (NULL != base1) {
        base1->public_data.val1 = val1;
        base1->val3 = val3;
     }

    return (base1);
}