util.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <array>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <span>
#include <string>
#include <vector>
 
namespace profinet
{
 
// =============================================================================
// Constants
// =============================================================================
 
// NOLINTBEGIN(readability-identifier-naming)
inline constexpr std::size_t MAX_ETHERNET_FRAME = 1522;
inline constexpr std::uint16_t PROFINET_ETHERTYPE = 0x8892;
inline constexpr std::uint16_t IP_ETHERTYPE = 0x8000;
inline constexpr std::uint16_t VLAN_ETHERTYPE = 0x8100;
 
inline constexpr int macAddressLength = 6;
 
inline constexpr int uuidLenght = 16;
 
inline constexpr std::size_t RECEIVE_BUFFER_LENGTH = 4096;
 
// NOLINTEND(readability-identifier-naming)
 
using MacAddress = std::array<std::uint8_t, macAddressLength>;
 
// =============================================================================
// Byte Conversion Utilities
// =============================================================================
 
std::string Hex4(std::uint16_t value);
 
std::string Hex2(std::uint8_t value);
 
std::vector<std::uint8_t> ToVec(const std::string& input);
 
std::string HexFallback(const char* widthPrefix, std::uint32_t value, int digitWidth);
// =============================================================================
// Address Conversion Utilities
// =============================================================================
 
std::size_t SkipVlanTags(std::span<const std::uint8_t> frame) noexcept;
 
std::string ToHex(const std::uint8_t* data, std::size_t len);
 
std::string ToHex(const std::vector<std::uint8_t>& data);
 
MacAddress String2Mac(const std::string& macStr);
 
std::string Mac2String(const MacAddress& mac);
 
std::string Mac2String(const std::uint8_t* macBytes, std::size_t len);
 
std::string String2Ip(std::span<const std::uint8_t> ipBytes);
 
std::string String2Ip(const std::uint8_t* ipBytes, std::size_t len);
 
std::array<std::uint8_t, 4> Ip2String(const std::string& ipStr);
 
std::string DecodeBytes(const std::uint8_t* data, std::size_t len);
 
std::string DecodeBytes(const std::vector<std::uint8_t>& data);
 
// =============================================================================
// Platform Network Utilities
// =============================================================================
class IMacAddressProvider
{
 public:
  virtual ~IMacAddressProvider() = default;
 
  virtual MacAddress GetMac(const std::string& interface) = 0;
};
 
class MacAddressProvider final : public IMacAddressProvider
{
 public:
  MacAddress GetMac(const std::string& interface) override;
};
 
MacAddress GetInterfaceMac(const std::string& interface);
 
std::filesystem::path GetExecutableDirectory();
 
template <typename T>
[[nodiscard]] constexpr T ByteSwap(T value)
{
  static_assert(std::is_integral_v<T>, "ByteSwap requires an integral type");
  static_assert(!std::is_same_v<T, bool>, "ByteSwap does not support bool");
 
  using UnsignedT = std::make_unsigned_t<T>;
 
  auto input = static_cast<UnsignedT>(value);
  UnsignedT result = 0;
 
  for (std::size_t i = 0U; i < sizeof(T); ++i)
  {
    result = static_cast<UnsignedT>((result << 8U) | (input & 0xFFU));
    input >>= 8U;
  }
 
  return static_cast<T>(result);
}
 
template <typename T>
[[nodiscard]] constexpr std::uint8_t ByteAt(T value, std::size_t index)
{
  static_assert(std::is_integral_v<T>, "ByteAt requires an integral type");
  static_assert(!std::is_same_v<T, bool>, "ByteAt does not support bool");
 
  using UnsignedT = std::make_unsigned_t<T>;
  const auto unsignedValue = static_cast<UnsignedT>(value);
 
  return static_cast<std::uint8_t>(
      (unsignedValue >> (index * 8U)) & 0xFFU);
}
 
// =============================================================================
// Timeout helper
// =============================================================================
 
class MaxTimeout
{
 public:
  explicit MaxTimeout(std::chrono::duration<double> seconds)
      : dieAfter(std::chrono::steady_clock::now() +
                 std::chrono::duration_cast<std::chrono::steady_clock::duration>(seconds))
  {
  }
 
  [[nodiscard]] bool TimedOut() const
  {
    return std::chrono::steady_clock::now() > dieAfter;
  }
 
  [[nodiscard]] std::chrono::duration<double> Remaining() const
  {
    auto rem = dieAfter - std::chrono::steady_clock::now();
    auto secs = std::chrono::duration<double>(rem);
    return secs.count() > 0 ? secs : std::chrono::duration<double>(0);
  }
 
 private:
  std::chrono::steady_clock::time_point dieAfter;
};
 
} // namespace profinet