derived1.c

Go to the documentation of this file.

#include "derived1_friend.h"

#define DERIVED1_STR_SIZE 256

typedef struct derived1_private_st_ {
    const derived1_vtable_st *vtable;
} derived1_private_st;

/*
 * This is C, we need explicit casts to each of an object's parent classes.
 */

static derived1_handle
base1_cast_to_derived1 (base1_handle base1_h)
{
    derived1_handle derived1_h = NULL;

    if (NULL != base1_h) {
        derived1_h = (derived1_handle) ((uint8_t *) base1_h -
                                        offsetof(derived1_st, base1));
    }

    return (derived1_h);
}

static derived1_handle
base2_cast_to_derived1 (base2_handle base2_h)
{
    derived1_handle derived1_h = NULL;

    if (NULL != base2_h) {
        derived1_h = (derived1_handle) ((uint8_t *) base2_h -
                                        offsetof(derived1_st, base2));
    }

    return (derived1_h);
}

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

    base2_h->val1 += 5;

    return (MY_RC_E_SUCCESS);
}

static my_rc_e
derived1_string_size_internal (derived1_handle derived1_h, size_t *buffer_size)
{
    if ((NULL == derived1_h) || (NULL == buffer_size)) {
        LOG_ERR("Invalid input, derived1_h(%p) buffer_size(%p)",
                derived1_h, buffer_size);
        return (MY_RC_E_EINVAL);
    }
    *buffer_size = DERIVED1_STR_SIZE;

    return (MY_RC_E_SUCCESS);
}

static my_rc_e
derived1_base1_string_size (base1_handle base1_h, size_t *buffer_size)
{
    return (derived1_string_size_internal(base1_cast_to_derived1(base1_h), 
                                          buffer_size));
}

static my_rc_e
derived1_base2_string_size (base2_handle base2_h, size_t *buffer_size)
{
    return (derived1_string_size_internal(base2_cast_to_derived1(base2_h), 
                                          buffer_size));
}

static const char *
derived1_type_string_internal (derived1_handle derived1_h)
{
    return ("derived1");
}

static const char *
derived1_base1_type_string (base1_handle base1_h)
{
    return (derived1_type_string_internal(base1_cast_to_derived1(base1_h)));
}

static const char *
derived1_base2_type_string (base2_handle base2_h)
{
    return (derived1_type_string_internal(base2_cast_to_derived1(base2_h)));
}

static my_rc_e
derived1_string_internal (derived1_handle derived1_h, 
                          char *buffer, size_t buffer_size)
{
    size_t min_size;
    my_rc_e rc = MY_RC_E_SUCCESS;

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

    rc = derived1_string_size_internal(derived1_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, "b1_val1(%u) b1_val2(%u) b1_val3(%u) "
             "b2_val1(%u) d1_val4(%u)", derived1_h->base1.public_data.val1,
             derived1_h->base1.public_data.val2, derived1_h->base1.val3,
             derived1_h->base2.val1, derived1_h->val4);

    return (MY_RC_E_SUCCESS);
}

static my_rc_e
derived1_base1_string (base1_handle base1_h, char *buffer, size_t buffer_size)
{
    return (derived1_string_internal(base1_cast_to_derived1(base1_h), buffer,
                                     buffer_size));
}

static my_rc_e
derived1_base2_string (base2_handle base2_h, char *buffer, size_t buffer_size)
{
    return (derived1_string_internal(base2_cast_to_derived1(base2_h), buffer,
                                     buffer_size));
}

static my_rc_e
derived1_increase_val4_internal (derived1_handle derived1_h)
{
    if (NULL == derived1_h) {
        LOG_ERR("Invalid input, derived1_h(%p)", derived1_h);
        return (MY_RC_E_EINVAL);
    }

    derived1_h->val4 *= 3;

    return (MY_RC_E_SUCCESS);
}

my_rc_e
derived1_increase_val4 (derived1_handle derived1_h)
{
    my_rc_e rc = MY_RC_E_SUCCESS;

    VALIDATE_VTABLE_FN(derived1_h, private_h, vtable, increase_val4_fn, rc);
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }

    return (derived1_h->private_h->vtable->increase_val4_fn(derived1_h));
}

static void
derived1_delete_internal (derived1_handle derived1_h, bool free_derived1_h)
{
    if (NULL == derived1_h) {
        return;
    }

    base1_friend_delete(&(derived1_h->base1));
    base2_friend_delete(&(derived1_h->base2));

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

    if (free_derived1_h) {
        free(derived1_h);
    }
}

void
derived1_friend_delete (derived1_handle derived1_h)
{
    derived1_delete_internal(derived1_h, false);
}

static void
derived1_private_delete (derived1_handle derived1_h)
{
    derived1_delete_internal(derived1_h, true);
}

void
derived1_delete (derived1_handle derived1_h)
{
    my_rc_e rc = MY_RC_E_SUCCESS;

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

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

static void
derived1_base1_delete (base1_handle base1_h)
{
    return (derived1_delete(base1_cast_to_derived1(base1_h)));
}

static void
derived1_base2_delete (base2_handle base2_h)
{
    return (derived1_delete(base2_cast_to_derived1(base2_h)));
}

static base1_vtable_st base1_vtable = {
    derived1_base1_delete,
    derived1_base1_type_string,
    derived1_base1_string,
    derived1_base1_string_size,
    NULL
};

static base2_vtable_st base2_vtable = {
    derived1_base2_delete,
    derived1_base2_type_string,
    derived1_base2_string,
    derived1_base2_string_size,
    derived1_base2_increase_val1
};

static derived1_vtable_st derived1_vtable = {
    &base1_vtable,
    &base2_vtable,
    derived1_private_delete,
    derived1_increase_val4_internal
};

base1_handle
derived1_cast_to_base1 (derived1_handle derived1_h)
{
    base1_handle base1_h = NULL;

    if (NULL != derived1_h) {
        base1_h = &(derived1_h->base1);
    }

    return (base1_h);
}

base2_handle
derived1_cast_to_base2 (derived1_handle derived1_h)
{
    base2_handle base2_h = NULL;

    if (NULL != derived1_h) {
        base2_h = &(derived1_h->base2);
    }

    return (base2_h);
}

my_rc_e
derived1_inherit_vtable (const derived1_vtable_st *parent_vtable,
                         derived1_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(4 == (sizeof(derived1_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);
    }

    rc = base1_inherit_vtable(&base1_vtable, child_vtable->base1_vtable, false);
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }

    rc = base2_inherit_vtable(&base2_vtable, child_vtable->base2_vtable, false);
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }

    INHERIT_VTABLE_FN(parent_vtable, child_vtable, delete_fn, do_null_check,
                      rc);
    INHERIT_VTABLE_FN(parent_vtable, child_vtable, increase_val4_fn, 
                      do_null_check, rc);

    return (MY_RC_E_SUCCESS);

err_exit:

    return (rc);
}

my_rc_e
derived1_set_vtable (derived1_handle derived1_h, derived1_vtable_st *vtable)
{
    my_rc_e rc;

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

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

    rc = derived1_inherit_vtable(&derived1_vtable, vtable, true);
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }

    rc = base1_set_vtable(&(derived1_h->base1), vtable->base1_vtable);
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }

    rc = base2_set_vtable(&(derived1_h->base2), vtable->base2_vtable);
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }

    derived1_h->private_h->vtable = vtable;

    return (MY_RC_E_SUCCESS);
}

my_rc_e
derived1_init (derived1_handle derived1_h)
{
    bool did_base1_init = false;
    bool did_base2_init = false;
    my_rc_e rc = MY_RC_E_SUCCESS;

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

    rc = base1_init(&(derived1_h->base1));
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }
    did_base1_init = true;

    rc = base1_set_vtable(&(derived1_h->base1), &base1_vtable);
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }

    rc = base2_init(&(derived1_h->base2));
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }
    did_base2_init = true;

    rc = base2_set_vtable(&(derived1_h->base2), &base2_vtable);
    if (my_rc_e_is_notok(rc)) {
        return (rc);
    }

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

    derived1_h->private_h->vtable = &derived1_vtable;
    derived1_h->val4 = 500;

    return (MY_RC_E_SUCCESS);

err_exit:

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

    if (did_base2_init) {
        base2_friend_delete(&(derived1_h->base2));
    }

    if (did_base1_init) {
        base1_friend_delete(&(derived1_h->base1));
    }

    return (rc);
}

derived1_handle
derived1_new1 (void)
{
    derived1_st *derived1 = NULL;
    my_rc_e rc;

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

    return (derived1);

err_exit:

    derived1_delete(derived1);

    return (NULL);
}