ab_gp_train_data_fsm.c

Go to the documentation of this file.

 
#include "ab_gp_train_data_fsm.h"
 
#include "rte/oal/log/rte_log.h"
#include "rte/utils/string/rte_string.h"

static const struct
{
    ab_gp_train_data_state_t from;
    ab_gp_event_t            event;
    ab_gp_train_data_state_t to;
} s_transitions[] = {
    { AB_GP_TRAIN_DATA_NONE,      AB_GP_EVENT_TRAIN_DATA_RECEIVED,          AB_GP_TRAIN_DATA_RECEIVED  },
    { AB_GP_TRAIN_DATA_NONE,      AB_GP_SESSION_EVENT_TRAIN_DATA_VALIDATED, AB_GP_TRAIN_DATA_VALIDATED },
    { AB_GP_TRAIN_DATA_NONE,      AB_GP_EVENT_TRAIN_DATA_REJECTED,          AB_GP_TRAIN_DATA_REJECTED  },
 
    { AB_GP_TRAIN_DATA_RECEIVED,  AB_GP_EVENT_TRAIN_DATA_RECEIVED,          AB_GP_TRAIN_DATA_RECEIVED  },
    { AB_GP_TRAIN_DATA_RECEIVED,  AB_GP_SESSION_EVENT_TRAIN_DATA_VALIDATED, AB_GP_TRAIN_DATA_VALIDATED },
    { AB_GP_TRAIN_DATA_RECEIVED,  AB_GP_EVENT_TRAIN_DATA_REJECTED,          AB_GP_TRAIN_DATA_REJECTED  },
 
    { AB_GP_TRAIN_DATA_VALIDATED, AB_GP_EVENT_TRAIN_DATA_RECEIVED,          AB_GP_TRAIN_DATA_RECEIVED  },
    { AB_GP_TRAIN_DATA_VALIDATED, AB_GP_SESSION_EVENT_TRAIN_DATA_VALIDATED, AB_GP_TRAIN_DATA_VALIDATED },
    /* VALIDATED + TRAIN_DATA_REJECTED: intentionally absent - see doc. */
 
    { AB_GP_TRAIN_DATA_REJECTED,  AB_GP_EVENT_TRAIN_DATA_RECEIVED,          AB_GP_TRAIN_DATA_RECEIVED  },
    { AB_GP_TRAIN_DATA_REJECTED,  AB_GP_SESSION_EVENT_TRAIN_DATA_VALIDATED, AB_GP_TRAIN_DATA_VALIDATED },
    { AB_GP_TRAIN_DATA_REJECTED,  AB_GP_EVENT_TRAIN_DATA_REJECTED,          AB_GP_TRAIN_DATA_REJECTED  }
};
 
#define AB_GP_TRAIN_DATA_FSM_TRANSITION_COUNT \
    (sizeof(s_transitions) / sizeof(s_transitions[0]))
 
bool ab_gp_train_data_fsm_can_handle(ab_gp_train_data_state_t from, ab_gp_event_t event,
                                     ab_gp_train_data_state_t *out_to)
{
    uint32_t i;
 
    for (i = 0U; i < (uint32_t)AB_GP_TRAIN_DATA_FSM_TRANSITION_COUNT; i++)
    {
        if ((s_transitions[i].from == from) && (s_transitions[i].event == event))
        {
            if (out_to != NULL)
            {
                *out_to = s_transitions[i].to;
            }
            return true;
        }
    }
    return false;
}

static const char *state_name(ab_gp_train_data_state_t state)
{
    switch (state)
    {
        case AB_GP_TRAIN_DATA_NONE:      return "NONE";
        case AB_GP_TRAIN_DATA_RECEIVED:  return "RECEIVED";
        case AB_GP_TRAIN_DATA_VALIDATED: return "VALIDATED";
        case AB_GP_TRAIN_DATA_REJECTED:  return "REJECTED";
        default:                         return "UNKNOWN";
    }
}

static void log_event(const ab_gp_ertms_train_context_t *ctx, ab_gp_event_t event, bool handled,
                      ab_gp_train_data_state_t to)
{
    char storage[112];
    rte_string_t line;
    const char *out_cstr = NULL;
 
    if (rte_string_init(&line, storage, sizeof(storage)) != RTE_STATUS_OK)
    {
        return;
    }
    (void)rte_string_copy(&line, "train=");
    (void)rte_string_append_u32(&line, (uint32_t)ctx->train_id);
    (void)rte_string_concat(&line, " event=");
    (void)rte_string_append_u32(&line, (uint32_t)event);
    (void)rte_string_concat(&line, " state=");
    (void)rte_string_concat(&line, state_name(ctx->train_data.state));
    if (handled)
    {
        (void)rte_string_concat(&line, " -> ");
        (void)rte_string_concat(&line, state_name(to));
    }
    else
    {
        (void)rte_string_concat(&line, " NOT HANDLED");
    }
    if (rte_string_c_str(&line, &out_cstr) == RTE_STATUS_OK)
    {
        rte_log_write(RTE_LOG_LEVEL_DEBUG, "TRAIN_DATA_FSM", out_cstr);
    }
}
 
bool ab_gp_train_data_fsm_handle_event(ab_gp_ertms_train_context_t *ctx, ab_gp_event_t event)
{
    ab_gp_train_data_state_t to = AB_GP_TRAIN_DATA_NONE;
    bool handled;
 
    if (ctx == NULL)
    {
        return false;
    }
 
    handled = ab_gp_train_data_fsm_can_handle(ctx->train_data.state, event, &to);
    log_event(ctx, event, handled, to);
 
    if (!handled)
    {
        return false;
    }
    ctx->train_data.state = to;
    /* Keep the pre-FSM .valid field a derived mirror so every existing
     * reader (ab_gp_proc_train_data_is_valid(), ab_gp_proc_dispatch.c)
     * is unaffected. */
    ctx->train_data.valid = (to == AB_GP_TRAIN_DATA_VALIDATED);
    return true;
}