network_configuration.h

#ifndef NETWORK_CONFIGURATION_H
#define NETWORK_CONFIGURATION_H
 
#include <map>
#include <string>
#include "../../arxml/arxml_reader.h"
#include "../../ara/com/option/option.h"
 
namespace application
{
    namespace helper
    {
        static const std::array<std::string, 7> cIpAddressShallowChildren(
            {"AUTOSAR",
             "AR-PACKAGES",
             "AR-PACKAGE",
             "ELEMENTS",
             "COMMUNICATION-CLUSTER",
             "ETHERNET-PHYSICAL-CHANNEL",
             "NETWORK-ENDPOINTS"});
 
        static const std::array<std::string, 4> cIpAddressDeepChildren(
            {"NETWORK-ENDPOINT",
             "NETWORK-ENDPOINT-ADDRESSES",
             "IPV-4-CONFIGURATION",
             "IPV-4-ADDRESS"});
 
        static const std::array<std::string, 6> cPortNumberShallowChildren(
            {"AUTOSAR",
             "AR-PACKAGES",
             "AR-PACKAGE",
             "ELEMENTS",
             "ETHERNET-COMMUNICATION-CONNECTOR",
             "AP-APPLICATION-ENDPOINTS"});
 
        static const std::array<std::string, 5> cTcpPortNumberDeepChildren(
            {"AP-APPLICATION-ENDPOINT",
             "TP-CONFIGURATION",
             "TCP-TP",
             "TCP-TP-PORT",
             "PORT-NUMBER"});
 
        static const std::array<std::string, 5> cUdpPortNumberDeepChildren(
            {"AP-APPLICATION-ENDPOINT",
             "TP-CONFIGURATION",
             "UDP-TP",
             "UDP-TP-PORT",
             "PORT-NUMBER"});
 
        struct NetworkConfiguration
        {
            std::string ipAddress;
 
            uint16_t portNumber;
        };
 
        template <typename T, size_t M, size_t N>
        bool TryExtractDeepValue(
            const arxml::ArxmlReader &shallowReader,
            const std::array<std::string, M> &shallowChildren,
            const std::array<std::string, N> &deepChildren,
            std::string shortNameFilter,
            T &deepValue)
        {
            const arxml::ArxmlNodeRange cShallowNodes{
                shallowReader.GetNodes(shallowChildren)};
 
            for (const auto cShallowNode : cShallowNodes)
            {
                if (shortNameFilter.empty())
                {
                    deepValue = cShallowNode.GetValue<T>();
                    return true;
                }
 
                std::string _shortName{cShallowNode.GetShortName()};
                if (_shortName == shortNameFilter)
                {
                    std::string _content{cShallowNode.GetContent()};
                    arxml::ArxmlReader _deepReader(_content.c_str(), _content.length());
                    arxml::ArxmlNode _deepNode{_deepReader.GetRootNode(deepChildren)};
                    deepValue = _deepNode.GetValue<T>();
 
                    return true;
                }
            }
 
            return false;
        }
 
        bool TryGetNetworkConfiguration(
            const arxml::ArxmlReader &reader,
            std::string networkEndpoint,
            std::string applicationEndpoint,
            ara::com::option::Layer4ProtocolType protocol,
            NetworkConfiguration &configuration);
 
        bool TryGetNetworkConfiguration(
            const std::string &configFilepath,
            std::string networkEndpoint,
            std::string applicationEndpoint,
            ara::com::option::Layer4ProtocolType protocol,
            NetworkConfiguration &configuration);
    }
 
}
 
#endif