/home/runner/work/rhmarine-oefenen/rhmarine-oefenen/profinet-io-controller-stack/include/profinet/util.h

Reverse the byte order of an integral value.

Reverse the byte order of an integral value.

Template Parameters

T	Integral value type.

Parameters

value

Value whose byte order is reversed.

Returns

The value with its byte order reversed.

The operation is performed on the corresponding unsigned representation, which avoids signed right-shift concerns. The original type is returned.

const std::uint32_t value = 0x07B280DEU;
const std::uint32_t swapped = ByteSwap(value);
// swapped == 0xDE80B207U

 
 
#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