mappers.hpp

Go to the documentation of this file.

#ifndef IV_SRC_UI_PANELS_EDITOR_PMS_MAPPERS_HPP_
#define IV_SRC_UI_PANELS_EDITOR_PMS_MAPPERS_HPP_
 
#include "model/pms/BusTie.hpp"
#include "model/pms/Generator.hpp"
#include "model/pms/MainBar.hpp"
#include "model/pms/Mode.hpp"
#include "ui/panels/editor/pms/structs.hpp"
 
namespace iv::panels::pms::mappers
{
 
inline iv::panels::pms::MainBarData mapMainBar(const std::shared_ptr<iv::model::pms::MainBar> &mainBar)
{
    return {.mainBarId = mainBar->m_mainBarId, .name = mainBar->m_name};
}
 
inline iv::panels::pms::BusTieData mapBusTie(const std::shared_ptr<iv::model::pms::BusTie> &busTie)
{
    return {.busTieId = busTie->m_busTieId,
            .name = busTie->m_name,
            .lomId = busTie->m_lomId,
            .leftMainBarId = busTie->m_leftMainBarId,
            .rightMainBarId = busTie->m_rightMainBarId};
}
 
inline iv::panels::pms::GeneratorData mapGenerator(const std::shared_ptr<iv::model::pms::Generator> &generator)
{
    return {.generatorId = generator->m_generatorId,
            .breakerId = generator->m_breakerId,
            .genBarId = generator->m_genBarId,
            .name = generator->m_name,
            .type = generator->m_genType,
            .lomId = generator->m_lomId,
            .mainBarId = generator->m_mainBarId,
            .ratedPower = generator->m_ratedPower};
}
 
inline iv::panels::pms::pmsMode::TransitionData
mapTransition(const std::shared_ptr<iv::model::pms::Transition> &transition)
{
    iv::panels::pms::pmsMode::TransitionData transitionData;
    transitionData.modeToReachId = transition->m_modeToReach;
    transitionData.sourceModeId = transition->m_sourceMode;
 
    return transitionData;
}
 
inline iv::model::pms::Transition mapTransitionData(const iv::panels::pms::pmsMode::TransitionData &transitionData)
{
    iv::model::pms::Transition transition;
    transition.m_modeToReach = transitionData.modeToReachId;
    transition.m_sourceMode = transitionData.sourceModeId;
 
    return transition;
}
 
inline iv::panels::pms::pmsMode::ActionData mapAction(const std::shared_ptr<iv::model::pms::AbstractPmsAction> &action)
{
    iv::panels::pms::pmsMode::ActionData actionData;
    actionData.type = action->m_actionType;
    actionData.maxProcessTime = action->m_maxProcessTime;
 
    switch (action->m_actionType)
    {
        case iv::model::pms::ePmsActionType::GenCmd:
        {
            const auto cmdAction = std::dynamic_pointer_cast<iv::model::pms::GenCmdAction>(action);
            actionData.cmdActionData = {.generatorId = cmdAction->m_generator->m_generatorId,
                                        .cmdType = cmdAction->m_cmdType};
        }
        break;
 
        case iv::model::pms::ePmsActionType::Priority:
        {
            const auto priorityAction = std::dynamic_pointer_cast<iv::model::pms::PriorityAction>(action);
            actionData.priorityActionData = {.generatorId = priorityAction->m_generator->m_generatorId,
                                             .value = priorityAction->m_value};
        }
        break;
 
        case iv::model::pms::ePmsActionType::BusTieCmd:
        {
            const auto busTieCmdAction = std::dynamic_pointer_cast<iv::model::pms::BusTieCmdAction>(action);
            actionData.busTieCmdActionData = {.busTieId = busTieCmdAction->m_busTie->m_busTieId,
                                              .cmdType = busTieCmdAction->m_busTieCmdType};
        }
        break;
 
        case iv::model::pms::ePmsActionType::CustomCmd:
        {
            const auto customAction = std::dynamic_pointer_cast<iv::model::pms::CustomAction>(action);
 
            auto customCmdChannel = customAction->m_cmdChannel.lock();
            auto customFeedbackChannel = customAction->m_feedbackChannel.lock();
 
            actionData.customActionData = {
                    .customCmdChannelId = customCmdChannel ? customCmdChannel->m_tag : iv::types::channelId {},
                    .customFeedbackChannelId =
                            customFeedbackChannel ? customFeedbackChannel->m_tag : iv::types::channelId {}};
        }
 
        default:
            IV_ASSERT_UNREACHABLE();
            break;
    }
 
    return actionData;
}
 
inline std::shared_ptr<iv::model::pms::AbstractPmsAction>
mapActionData(const iv::panels::pms::pmsMode::ActionData &actionData)
{
    std::shared_ptr<iv::model::pms::AbstractPmsAction> action;
 
    switch (actionData.type)
    {
        case iv::model::pms::ePmsActionType::GenCmd:
        {
            if (actionData.cmdActionData.has_value())
            {
                const auto cmdAction = std::make_shared<iv::model::pms::GenCmdAction>();
                cmdAction->m_cmdType = actionData.cmdActionData->cmdType;
 
                const auto controller = iv::appdiamar::Application::get()->getApplicationController().lock();
                const auto generators = controller->pmsManager()->generators();
 
                if (generators.contains(actionData.cmdActionData->generatorId))
                {
                    cmdAction->m_generator = generators.at(actionData.cmdActionData->generatorId);
                }
 
                action = cmdAction;
            }
        }
        break;
 
        case iv::model::pms::ePmsActionType::Priority:
        {
            if (actionData.priorityActionData.has_value())
            {
                const auto priorityAction = std::make_shared<iv::model::pms::PriorityAction>();
                priorityAction->m_value = actionData.priorityActionData->value;
 
                const auto controller = iv::appdiamar::Application::get()->getApplicationController().lock();
                const auto generators = controller->pmsManager()->generators();
 
                if (generators.contains(actionData.priorityActionData->generatorId))
                {
                    priorityAction->m_generator = generators.at(actionData.priorityActionData->generatorId);
                }
 
                action = priorityAction;
            }
        }
        break;
 
        case iv::model::pms::ePmsActionType::BusTieCmd:
        {
            if (actionData.busTieCmdActionData.has_value())
            {
                const auto busTieCmdAction = std::make_shared<iv::model::pms::BusTieCmdAction>();
                busTieCmdAction->m_busTieCmdType = actionData.busTieCmdActionData->cmdType;
 
                const auto controller = iv::appdiamar::Application::get()->getApplicationController().lock();
                const auto busTies = controller->pmsManager()->busTies();
 
                if (busTies.contains(actionData.busTieCmdActionData->busTieId))
                {
                    busTieCmdAction->m_busTie = busTies.at(actionData.busTieCmdActionData->busTieId);
                }
 
                action = busTieCmdAction;
            }
        }
        break;
 
        case iv::model::pms::ePmsActionType::CustomCmd:
        {
            if (actionData.customActionData.has_value())
            {
                const auto customAction = std::make_shared<iv::model::pms::CustomAction>();
 
                const auto controller = iv::appdiamar::Application::get()->getApplicationController().lock();
                const auto units = controller->units();
 
                customAction->m_cmdChannel = units->getChannel(actionData.customActionData->customCmdChannelId);
                customAction->m_feedbackChannel =
                        units->getChannel(actionData.customActionData->customFeedbackChannelId);
 
                action = customAction;
            }
        }
        break;
 
        case iv::model::pms::ePmsActionType::Sleep:
        {
            action = std::make_shared<iv::model::pms::SleepAction>();
        }
        break;
 
        default:
            IV_ASSERT_UNREACHABLE();
            break;
    }
    action->m_actionType = actionData.type;
    action->m_maxProcessTime = actionData.maxProcessTime;
 
    return action;
}
 
inline iv::panels::pms::pmsMode::ModeData mapMode(const std::shared_ptr<iv::model::pms::Mode> &mode)
{
    iv::panels::pms::pmsMode::ModeData modeData;
    modeData.modeId = mode->m_modeId;
    modeData.feedbackTimeout = mode->m_feedbackTimeout;
    if (const auto sharedMode = mode->m_modeFeedbackChannel.lock(); sharedMode)
    {
        modeData.modeFeedbackChannelId = sharedMode->m_tag;
    }
 
    return modeData;
}
 
}// namespace iv::panels::pms::mappers
 
#endif//IV_SRC_UI_PANELS_EDITOR_PMS_MAPPERS_HPP_