ab_gp_logic.c

Go to the documentation of this file.

#include "ab_gp_logic.h"
 
#include "rte/utils/lifecycle/rte_lifecycle.h"
#include "rte/utils/notify/rte_notify.h"
#include "rte/oal/log/rte_log.h"
 
#include "../../common/common_config.h"
#include "ab_siteGP.h"
#include "../train/ab_gp_train.h"


/* GA callback registries - module-private storage (same "static
 * singleton" convention as ab_gp_channel.c's own g_ab_ctx). Relies on C's
 * static zero-initialization (count == 0, every slot NULL) rather than
 * a separate explicit list-init step - see rte_notify.h's own doc
 * (safeAPIFreamwork, ADR-030) for the storage shape these are declared
 * from and why init/register/dispatch are hand-written here, not
 * macro-generated. */
RTE_DECLARE_CALLBACK_LIST(ab_gp_logic_route_validator_list_t, ab_gp_logic_route_validator_fn,
                               AB_GP_LOGIC_MAX_ROUTE_VALIDATORS);
 
RTE_DECLARE_CALLBACK_LIST(ab_gp_logic_shunting_validator_list_t, ab_gp_logic_shunting_validator_fn,
                               AB_GP_LOGIC_MAX_SHUNTING_VALIDATORS);

static ab_gp_logic_route_validator_list_t g_validators;
static ab_gp_logic_shunting_validator_list_t g_shunting_validators;


static bool route_validators_all_agree(uint16_t route_id, uint8_t train_id);
 

rte_status_t ab_gp_ga_register_init(ab_gp_logic_route_validator_fn fn, void *context)
{
    rte_status_t lifecycle_status;
 
    if (fn == NULL)
    {
        return RTE_STATUS_INVALID_PARAM;
    }
    lifecycle_status = rte_lifecycle_check_setup_allowed();
    if (lifecycle_status != RTE_STATUS_OK)
    {
        return lifecycle_status;
    }
    if (g_validators.count >= (uint32_t)AB_GP_LOGIC_MAX_ROUTE_VALIDATORS)
    {
        return RTE_STATUS_RESOURCE_EXHAUSTED;
    }
    g_validators.slots[g_validators.count].fn = fn;
    g_validators.slots[g_validators.count].context = context;
    g_validators.count++;
    return RTE_STATUS_OK;
}
 
rte_status_t ab_gp_ga_register_shunting_validator(ab_gp_logic_shunting_validator_fn fn, void *context)
{
    rte_status_t lifecycle_status;
 
    if (fn == NULL)
    {
        return RTE_STATUS_INVALID_PARAM;
    }
    lifecycle_status = rte_lifecycle_check_setup_allowed();
    if (lifecycle_status != RTE_STATUS_OK)
    {
        return lifecycle_status;
    }
    if (g_shunting_validators.count >= (uint32_t)AB_GP_LOGIC_MAX_SHUNTING_VALIDATORS)
    {
        return RTE_STATUS_RESOURCE_EXHAUSTED;
    }
    g_shunting_validators.slots[g_shunting_validators.count].fn = fn;
    g_shunting_validators.slots[g_shunting_validators.count].context = context;
    g_shunting_validators.count++;
    return RTE_STATUS_OK;
}
 
bool ab_gp_logic_shunting_allowed(uint8_t train_id)
{
    uint32_t i;
    bool     result = true;
 
    if (g_shunting_validators.count == 0U)
    {
        /* Default-deny, reported here so it does not look like a silent refusal (same as the route gate). */
        RTE_LOG_WRITE_EVENT_F(RTE_LOG_LEVEL_WARNING, "LOGIC", 0U, "GP", "GA", "SHUNTING_VALIDATION",
                               "train %u: no GA shunting validator registered - refusing SH",
                               (unsigned int)train_id);
        return false;
    }
 
    for (i = 0U; i < g_shunting_validators.count; i++)
    {
        if ((g_shunting_validators.slots[i].fn != NULL)
            && (!g_shunting_validators.slots[i].fn(g_shunting_validators.slots[i].context, train_id)))
        {
            RTE_LOG_WRITE_EVENT_F(RTE_LOG_LEVEL_DEBUG, "LOGIC", 0U, "GP", "GA", "SHUNTING_VALIDATION",
                                   "validator #%u refused SH for train %u",
                                   (unsigned int)i, (unsigned int)train_id);
            result = false;
        }
    }
    return result;
}
 
bool ab_gp_logic_connect_route_for_train(ab_gp_db_t *db, uint8_t train_id)
{
    uint32_t nid_lrbg = 0U;
    uint32_t i;
    bool     connected_any = false;
    uint32_t connected_count = 0U;
 
    if (!ab_gp_train_get_last_position(db, train_id, &nid_lrbg))
    {
        RTE_LOG_WRITE_EVENT_F(RTE_LOG_LEVEL_DEBUG, "LOGIC", 0U, "GP", "GA", "ROUTE_CONNECT",
                               "train %u not currently connected - skipping route connect",
                               (unsigned int)train_id);
        return false; /* not a currently-connected train */
    }
    if (nid_lrbg == 0U)
    {
        RTE_LOG_WRITE_EVENT_F(RTE_LOG_LEVEL_DEBUG, "LOGIC", 0U, "GP", "GA", "ROUTE_CONNECT",
                               "train %u has not reported a position yet (nid_lrbg=0) - skipping",
                               (unsigned int)train_id);
        return false;
    }
 
    RTE_LOG_WRITE_EVENT_F(RTE_LOG_LEVEL_DEBUG, "LOGIC", 0U, "GP", "GA", "ROUTE_CONNECT",
                           "train %u at nid_lrbg=%u: checking every tracked route for a connect",
                           (unsigned int)train_id, (unsigned int)nid_lrbg);
 
    for (i = 0U; i < (uint32_t)RTE_EXAMPLE_MAX_ROUTES; i++)
    {
        uint16_t route_id = db->routes[i].id;
        if (route_id == 0U)
        {
            continue; /* unused slot - not logged, this loop runs every cycle */
        }
 
        if (db->routes[i].used_in_ma)
        {
            if (db->routes[i].train_id == train_id)
            {
                connected_any = true;
                RTE_LOG_WRITE_EVENT_F(RTE_LOG_LEVEL_DEBUG, "LOGIC", 0U, "GP", "GA", "ROUTE_CONNECT",
                                       "route %u already connected to train %u - no-op",
                                       (unsigned int)route_id, (unsigned int)train_id);
            }
            else
            {
                RTE_LOG_WRITE_EVENT_F(RTE_LOG_LEVEL_DEBUG, "LOGIC", 0U, "GP", "GA", "ROUTE_CONNECT",
                                       "route %u already connected to train %u - skipping for train %u",
                                       (unsigned int)route_id, (unsigned int)db->routes[i].train_id,
                                       (unsigned int)train_id);
            }
            continue; /* route already assigned */
        }
 
        if (!route_validators_all_agree(route_id, train_id))
        {
            RTE_LOG_WRITE_EVENT_F(RTE_LOG_LEVEL_DEBUG, "LOGIC", 0U, "GP", "GA", "ROUTE_CONNECT",
                                   "route %u -> train %u: no GA validator approved - not connecting",
                                   (unsigned int)route_id, (unsigned int)train_id);
            continue; /* no registered GA validator approved - see that function's own doc */
        }
 
        /* AB/GP/db/ab_gp_db.h's own ab_gp_db_route_connect_train() fires its OWN
         * registered-subscriber notification on success - see this file's
         * own module doc for why this function itself does not do that. */
        if (ab_gp_db_route_connect_train(db, route_id, train_id))
        {
            connected_any = true;
            connected_count++;
            RTE_LOG_WRITE_EVENT_F(RTE_LOG_LEVEL_INFO, "LOGIC", 0U, "GP", "GA", "ROUTE_CONNECT",
                                   "connected route %u to train %u (at nid_lrbg=%u)",
                                   (unsigned int)route_id, (unsigned int)train_id,
                                   (unsigned int)nid_lrbg);
        }
        else
        {
            RTE_LOG_WRITE_EVENT_F(RTE_LOG_LEVEL_WARNING, "LOGIC", 0U, "GP", "GA", "ROUTE_CONNECT",
                                   "route %u -> train %u: ab_gp_db_route_connect_train() refused",
                                   (unsigned int)route_id, (unsigned int)train_id);
        }
    }
 
    if (connected_count > 0U)
    {
        RTE_LOG_WRITE_EVENT_F(RTE_LOG_LEVEL_INFO, "LOGIC", 0U, "GP", "GA", "ROUTE_CONNECT",
                               "train %u: %u route(s) newly connected this pass (holds %s)",
                               (unsigned int)train_id, (unsigned int)connected_count,
                               connected_any ? "at least one route" : "no route");
    }
    else
    {
        RTE_LOG_WRITE_EVENT_F(RTE_LOG_LEVEL_DEBUG, "LOGIC", 0U, "GP", "GA", "ROUTE_CONNECT",
                               "train %u: %u route(s) newly connected this pass (holds %s)",
                               (unsigned int)train_id, (unsigned int)connected_count,
                               connected_any ? "at least one route" : "no route");
    }
 
    return connected_any;
}
 
void ab_gp_logic_connect_routes_and_trains(ab_gp_db_t *db)
{
    uint8_t train_id;
 
    /* Per-train "attempting" logging lives in
     * ab_gp_logic_connect_route_for_train() itself - not duplicated here. */
    for (train_id = 1U; train_id <= (uint8_t)RTE_EXAMPLE_MAX_TRAINS; train_id++)
    {
        if (ab_gp_train_is_connected(db, train_id))
        {
            (void)ab_gp_logic_connect_route_for_train(db, train_id);
        }
    }
}
 
 
/****Local functions ****/
 
static bool route_validators_all_agree(uint16_t route_id, uint8_t train_id)
{
    uint32_t i;
    bool     result = true;
 
    if (g_validators.count == 0U)
    {
        /* Doc contract (ab_gp_ga_register_init()): default-DENY when no
         * validator is registered - reported once here rather than
         * looking like a silent rejection at the call site. */
        RTE_LOG_WRITE_EVENT_F(RTE_LOG_LEVEL_WARNING, "LOGIC", 0U, "GP", "GA", "ROUTE_VALIDATION",
                               "route %u -> train %u: no GA route validator registered - denying",
                               (unsigned int)route_id, (unsigned int)train_id);
        return false;
    }
 
    for (i = 0U; i < g_validators.count; i++)
    {
        if ((g_validators.slots[i].fn != NULL)
            && (!g_validators.slots[i].fn(g_validators.slots[i].context, route_id, train_id)))
        {
            RTE_LOG_WRITE_EVENT_F(RTE_LOG_LEVEL_DEBUG, "LOGIC", 0U, "GP", "GA", "ROUTE_VALIDATION",
                                   "validator #%u rejected route %u -> train %u",
                                   (unsigned int)i, (unsigned int)route_id, (unsigned int)train_id);
            result = false;
        }
    }
    if (result)
    {
        RTE_LOG_WRITE_EVENT_F(RTE_LOG_LEVEL_DEBUG, "LOGIC", 0U, "GP", "GA", "ROUTE_VALIDATION",
                               "route %u -> train %u: all %u registered validator(s) approved",
                               (unsigned int)route_id, (unsigned int)train_id,
                               (unsigned int)g_validators.count);
    }
    return result;
}