detail_network.hpp

#pragma once
 
#include "../../global.hpp"
#include "../../string.hpp"
#include "../ui.hpp"
 
#include <sstream>
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace UI
  {
    namespace Private
    {
      inline uint32_t IPV4AddressStringToInt(const std::string &ip)
      {
        std::istringstream iss(ip);
 
        uint32_t ipv4 = 0;
        for (int i = 0; i < 4; ++i)
        {
          uint32_t part;
          iss >> part;
          if (iss.fail() || part > 255)
            throw std::runtime_error("Invalid IP address");
 
          ipv4 |= part << (8 * (3 - i));
 
          if (i != 3)
          {
            char delimiter;
            iss >> delimiter;
            if (iss.fail() || delimiter != '.')
              throw std::runtime_error("Invalid IP address");
          }
        }
 
        return ipv4;
      }
 
      inline std::string IPV4AddressIntToString(uint32_t ip)
      {
        std::ostringstream oss;
        oss << ((ip & 0xFF000000) >> 24) << '.'
            << ((ip & 0x00FF0000) >> 16) << '.'
            << ((ip & 0x0000FF00) >> 8) << '.'
            << (ip & 0x000000FF);
 
        return oss.str();
      }
 
      class MacAddress final
      {
 
      public:
        enum MacDelimiter
        {
          Minus,
          Colon
        };
 
        explicit MacAddress(int64_t addr) noexcept
        {
          Convert(addr);
          Check();
        }
 
        explicit MacAddress(const String &addr) noexcept
            : address_(UI::CvbToQt(addr))
        {
 
          Check();
        }
 
        explicit MacAddress(const QString &addr) noexcept
            : address_(addr)
        {
          Check();
        }
 
        bool operator==(const MacAddress &addr) const noexcept
        {
          return (address_ == addr.address_);
        }
 
        bool operator!=(const MacAddress &addr) const noexcept
        {
          return !(*this == addr);
        }
 
        String ToString()
        {
          return UI::QtToCvb(address_);
        }
 
        QString ToQString()
        {
          return address_;
        }
 
        int64_t ToInt64()
        {
          if (address_.isEmpty())
            return 0;
 
          return Int64();
        }
 
        bool IsValid()
        {
          return !(ToInt64() == 0);
        }
 
        void SetDelimiter(const MacDelimiter delimiter)
        {
          separator_ = delimiter;
        }
 
        MacDelimiter Delimiter()
        {
          return separator_;
        }
 
      private:
        void Check()
        {
          QRegularExpression rx(macRegExp);
          auto match = rx.match(address_);
          if (!match.hasMatch())
            address_ = defaultAddress_;
 
          ChangeSeparator();
        }
 
        void ChangeSeparator()
        {
          if (address_.count(Separator()) == 5)
            return;
          else
          {
            switch (separator_)
            {
              case Colon:
                address_.replace('-', ':');
                break;
              case Minus:
              default:
                address_.replace(':', '-');
                break;
            }
          }
        }
 
        void Convert(int64_t value)
        {
          auto tmp   = QString("%1").arg(value, 8, 16, QLatin1Char('0'));
          auto pos   = tmp.size() - 2;
          auto count = 0;
          while (pos > 0)
          {
            tmp.insert(pos, Separator());
            pos -= 2;
            ++count;
          }
          while (count < 5)
          {
            tmp.insert(0, Separator()).insert(0, "00");
            ++count;
          }
          address_ = tmp;
        }
 
        int64_t Int64()
        {
          auto tmp = address_;
          tmp.remove(':').remove('-');
          bool valid = false;
          return static_cast<int64_t>(tmp.toLongLong(&valid, 16));
        }
 
        QChar Separator()
        {
          if (separator_ == Colon)
            return ':';
          return '-';
        }
 
        QString address_;
        const QString defaultAddress_ = "00-00-00-00-00-00";
        MacDelimiter separator_       = Minus;
        const QString macRegExp       = "([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})";
      };
 
    } /* namespace Private */
  } /* namespace UI */
 
  CVB_END_INLINE_NS
 
} /* namespace Cvb */