hierarchical-state-machine.cpp

#include "Hierarchical_State_Machine.h"
#include "Unit_Messages.h"
#include "assert.h"

void Hierarchical_State_Machine::On_Message(const Message *p_Message)
{
    switch (p_Message->GetType())
    {
    case Message::FAULT_TRIGGER:
        p_Current_State->On_Fault_Trigger(*this, p_Message);
        break;

    case Message::SWITCHOVER:
        p_Current_State->On_Switchover(*this, p_Message);
        break;

    case Message::DIAGNOSTICS_PASSED:
        p_Current_State->On_Diagnostics_Passed(*this, p_Message);
        break;

    case Message::DIAGNOSTICS_FAILED:
        p_Current_State->On_Diagnostics_Failed(*this, p_Message);
        break;

    case Message::OPERATOR_INSERVICE:
        p_Current_State->On_Operator_Inservice(*this, p_Message);
        break;

    default:
        assert(false);
        break;
    }
}

void Hierarchical_State_Machine::Inservice::On_Fault_Trigger(
                                   Hierarchical_State_Machine &u, 
                                   const Message *p_Message)
{
    u.Next_State(u.Suspect_State);
    u.Send_Diagnostics_Request();
    u.Raise_Alarm(LOSS_OF_REDUNDANCY);
}


void Hierarchical_State_Machine::Inservice::On_Switchover(
                                   Hierarchical_State_Machine &u, 
                                   const Message *p_Message)
{
    u.Perform_Switchover();
    u.Check_Mate_Status();
    u.Send_Switchover_Response();
}


void Hierarchical_State_Machine::Active::On_Fault_Trigger(
                                   Hierarchical_State_Machine &u, 
                                   const Message *p_Message)
{
    u.Perform_Switchover();
    Inservice::On_Fault_Trigger(u, p_Message);  
}


void Hierarchical_State_Machine::Active::On_Switchover(
                                   Hierarchical_State_Machine &u, 
                                   const Message *p_Message)
{
    Inservice::On_Switchover(u, p_Message);
    u.Next_State(u.Standby_State);
}


void Hierarchical_State_Machine::Standby::On_Switchover(
                                   Hierarchical_State_Machine &u, 
                                   const Message *p_Message)
{
    Inservice::On_Switchover(u, p_Message);
    u.Next_State(u.Active_State);
}

void Hierarchical_State_Machine::Out_Of_Service::On_Operator_Inservice(
                                   Hierarchical_State_Machine &u, 
                                   const Message *p_Message)
{
    // Operator has replaced the card, so abort the current diagnostics
    // and restart new diagnostics on the replaced card.  
    u.Send_Diagnostics_Request();
    u.Send_Operator_Inservice_Response();
    u.Next_State(u.Suspect_State);
}

void Hierarchical_State_Machine::Suspect::On_Diagnostics_Failed(
                                   Hierarchical_State_Machine &u, 
                                   const Message *p_Message)
{
    u.Send_Diagnostics_Failure_Report();
    u.Next_State(u.Failed_State);
}

void Hierarchical_State_Machine::Suspect::On_Diagnostics_Passed(
                                            Hierarchical_State_Machine &u, 
                                            const Message *p_Message)
{
    u.Send_Diagnostics_Pass_Report();
    u.Clear_Alarm(LOSS_OF_REDUNDANCY);
    u.Next_State(u.Standby_State);
}

void Hierarchical_State_Machine::Suspect::On_Operator_Inservice(
                                            Hierarchical_State_Machine &u, 
                                            const Message *p_Message)
{
    u.Abort_Diagnostics();
    Out_Of_Service::On_Operator_Inservice(u, p_Message); 
}