utils.hpp

Go to the documentation of this file.

#ifndef IV_SRC_UNITS_BUILDERS_UTILS_HPP_
#define IV_SRC_UNITS_BUILDERS_UTILS_HPP_
 
#include "units/builders/constants.hpp"
#include "units/model/Unit.hpp"
 
#include <optional>
#include <regex>
#include <utility>
 
namespace iv::units::builders
{
 
namespace pmm
{
 
struct PmmAndChannelNames
{
    PmmAndChannelNames(std::string pmmName, std::string chName)
    {
        this->pmmName = std::move(pmmName);
        this->chName = std::move(chName);
    }
    std::string pmmName;
    std::string chName;
};
 
inline bool hasPmmChIdStructure(iv::types::channelId chId)
{
    std::regex pattern(R"(^.{1,3}_.+$)");
    return std::regex_match(chId, pattern);
}
 
inline std::optional<PmmAndChannelNames> getPmmAndChannelNames(const iv::types::channelId &channelId)
{
    if (not hasPmmChIdStructure(channelId))
    {
        return std::nullopt;
    }
 
    auto separatorPos = channelId.find('_');
    std::string pmmName = channelId.substr(0, separatorPos);
    std::string chName = channelId.substr(separatorPos + 1, channelId.size());
    return {PmmAndChannelNames(pmmName, chName)};
}
 
inline std::optional<std::string> getPmmName(const iv::units::Unit &pmmUnit)
{
    if (pmmUnit.m_unitType != iv::units::eUnitType::Pmm)
    {
        return std::nullopt;
    }
 
    std::string lastOccurrence;
    for (const auto &channelPair: pmmUnit.getChannels())
    {
        const auto pmmAndChannelNames = getPmmAndChannelNames(channelPair.first);
        if (pmmAndChannelNames.has_value())
        {
            if (lastOccurrence != pmmAndChannelNames->pmmName)
            {
                lastOccurrence = pmmAndChannelNames->pmmName;
                continue;
            }
 
            return pmmAndChannelNames->pmmName;
        }
    }
 
    return std::nullopt;
}
 
inline std::pair<bool, std::shared_ptr<iv::channels::AbstractChannel>>
hasPmmChannelByChName(const iv::units::Unit &pmmUnit, const std::string &channelName)
{
    const auto pmmChannels = pmmUnit.getChannels();
    auto it = std::find_if(
            pmmChannels.begin(), pmmChannels.end(),
            [channelName](
                    const std::pair<iv::types::channelId, std::shared_ptr<iv::channels::AbstractChannel>> &channelPair)
            {
                const auto pmmAndChannelNames = getPmmAndChannelNames(channelPair.first);
                if (pmmAndChannelNames.has_value() and pmmAndChannelNames->chName == channelName)
                {
                    return true;
                }
 
                return false;
            });
 
    if (it == pmmChannels.end())
    {
        return {false, 0};
    }
 
    return {true, it->second};
}
 
}// namespace pmm
 
}// namespace iv::units::builders
 
#endif//IV_SRC_UNITS_BUILDERS_UTILS_HPP_