util.h

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <bit>
#include <charconv>
#include <chrono>
#include <condition_variable>
#include <cstdint>
#include <cstring>
#include <fstream>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <mutex>
#include <nlohmann/json.hpp>
#include <optional>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <string_view>
#include <thread>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <utility>
#include <variant>
#include <vector>
 
namespace mm::core::util {
 
template <typename T>
T parseHex(const std::string& s) {
  static_assert(std::is_unsigned<T>::value,
                "parseHex only supports unsigned integer types");
 
  // Use the appropriate std::stoul or std::stoull depending on size
  if constexpr (sizeof(T) <= sizeof(unsigned long)) {
    // Use std::stoul
    return static_cast<T>(std::stoul(s, nullptr, 16));
  } else {
    // Use std::stoull for larger types like uint64_t
    return static_cast<T>(std::stoull(s, nullptr, 16));
  }
}
 
enum class Endianness { LITTLE, BIG };
 
template <typename T>
T toInteger(const std::vector<std::uint8_t>& data, std::size_t offset = 0,
            Endianness endian = Endianness::LITTLE) {
  // Ensure T is an integral type
  static_assert(std::is_integral<T>::value, "T must be an integral type");
 
  // Use unsigned type for accumulation to avoid sign extension issues
  using U = typename std::make_unsigned<T>::type;
  U value = 0;
 
  // Check if offset is within bounds
  // If offset is greater than the size of data, return 0
  std::size_t remaining = (data.size() > offset) ? (data.size() - offset) : 0;
  std::size_t byteCount = (sizeof(T) < remaining) ? sizeof(T) : remaining;
 
  if (endian == Endianness::LITTLE) {
    for (std::size_t i = 0; i < byteCount; ++i) {
      value |= static_cast<U>(data[offset + i]) << (8 * i);
    }
  } else {
    for (std::size_t i = 0; i < byteCount; ++i) {
      value |= static_cast<U>(data[offset + i]) << (8 * (sizeof(T) - 1 - i));
    }
  }
 
  return static_cast<T>(value);
}
 
std::vector<std::vector<uint8_t>> splitIntoParts(
    const std::vector<uint8_t>& input, size_t partSize);
 
std::vector<uint8_t> zipData(const std::string& filename,
                             const std::vector<uint8_t>& data);
 
std::unordered_map<std::string, std::vector<uint8_t>> unzipData(
    const std::vector<uint8_t>& data);
 
template <typename T>
bool stringViewToNumber(std::string_view sv, T& result) {
  static_assert(std::is_arithmetic_v<T>, "T must be an arithmetic type");
 
  auto [ptr, ec] = std::from_chars(sv.data(), sv.data() + sv.size(), result);
  return ec == std::errc();
}
 
template <typename T>
std::vector<uint8_t> toBytes(T value, bool bigEndian = false) {
  static_assert(std::is_trivially_copyable<T>::value,
                "T must be trivially copyable");
 
  std::vector<uint8_t> bytes(sizeof(T));
  std::memcpy(bytes.data(), &value, sizeof(T));
 
  if (bigEndian) {
    std::reverse(bytes.begin(), bytes.end());
  }
 
  return bytes;
}
 
template <typename T>
T fromBytes(const std::vector<uint8_t>& bytes, bool bigEndian = false) {
  static_assert(std::is_trivially_copyable<T>::value,
                "T must be trivially copyable");
 
  if (bytes.size() != sizeof(T)) {
    throw std::invalid_argument(
        "Byte vector size does not match target type size");
  }
 
  std::vector<uint8_t> temp = bytes;
 
  if (bigEndian) {
    std::reverse(temp.begin(), temp.end());
  }
 
  T value;
  std::memcpy(&value, temp.data(), sizeof(T));
  return value;
}
 
inline std::string makeParameterId(int index, int subindex) {
  std::stringstream oss;
  // Format index and subindex into "0xINDEX:SUBINDEX"
  oss << "0x" << std::setw(4) << std::setfill('0') << std::hex << std::uppercase
      << index << ":" << std::setw(2) << std::setfill('0') << std::hex
      << std::uppercase << subindex;
 
  return oss.str();
}
 
inline std::string toHex(const std::vector<uint8_t>& data) {
  std::ostringstream oss;
  oss << std::uppercase;  // Ensure hex letters are uppercase
  for (size_t i = 0; i < data.size(); ++i) {
    oss << "0x" << std::hex << std::setw(2) << std::setfill('0')
        << static_cast<int>(data[i]);
    if (i != data.size() - 1) {
      oss << " ";
    }
  }
  return oss.str();
}
 
template <typename T>
inline std::string toHex(T value) {
  static_assert(std::is_integral<T>::value, "toHex requires an integer type");
  constexpr size_t hexWidth = sizeof(T) * 2;
 
  std::ostringstream oss;
  oss << "0x" << std::hex << std::uppercase << std::setw(hexWidth)
      << std::setfill('0') << static_cast<uint64_t>(value);
  return oss.str();
}
 
std::vector<uint8_t> readBinaryFile(const std::string& filename);
 
std::string readTextFile(const std::string& filename);
 
std::string joinStrings(const std::vector<std::string>& list,
                        const std::string& delimiter);
 
std::string formatMacAddress(const std::string& originalMacAddress);
 
std::string extractIpAddress(const std::string& socketAddress);
 
unsigned short extractPort(const std::string& socketAddress);
 
inline bool endsWith(const std::string& str, const std::string& suffix) {
  return str.size() >= suffix.size() &&
         std::equal(suffix.rbegin(), suffix.rend(), str.rbegin());
}
 
inline size_t countStringsStartingWith(const std::vector<std::string>& strings,
                                       const std::string& prefix) {
  return std::count_if(
      strings.begin(), strings.end(), [&](const std::string& s) {
        return s.rfind(prefix, 0) == 0;  // checks if s starts with prefix
      });
}
 
inline std::vector<std::string> split(const std::string& input,
                                      char delimiter) {
  std::vector<std::string> result;
  std::istringstream stream(input);
  std::string token;
 
  while (std::getline(stream, token, delimiter)) {
    result.push_back(token);
  }
 
  return result;
}
 
template <typename T>
class ThreadSafeQueue {
 private:
  std::queue<T> queue_;
 
  mutable std::mutex mtx_;
 
  std::condition_variable cv_;
 
 public:
  ThreadSafeQueue() = default;
 
  ThreadSafeQueue(const ThreadSafeQueue&) = delete;
 
  ThreadSafeQueue& operator=(const ThreadSafeQueue&) = delete;
 
  void push(T value) {
    {
      std::lock_guard<std::mutex> lock(mtx_);
      queue_.push(std::move(value));
    }
    cv_.notify_one();
  }
 
  std::optional<T> try_pop() {
    std::lock_guard<std::mutex> lock(mtx_);
    if (queue_.empty()) return std::nullopt;
    T value = std::move(queue_.front());
    queue_.pop();
    return value;
  }
 
  T wait_and_pop() {
    std::unique_lock<std::mutex> lock(mtx_);
    cv_.wait(lock, [this] { return !queue_.empty(); });
    T value = std::move(queue_.front());
    queue_.pop();
    return value;
  }
 
  bool empty() const {
    std::lock_guard<std::mutex> lock(mtx_);
    return queue_.empty();
  }
 
  size_t size() const {
    std::lock_guard<std::mutex> lock(mtx_);
    return queue_.size();
  }
};
 
inline int64_t currentTimeMillis() {
  // Get current time point from system clock
  auto now = std::chrono::system_clock::now();
 
  // Convert to duration since epoch in milliseconds
  auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(
      now.time_since_epoch());
 
  // Return the count as an integer (int64_t)
  return duration.count();
}
 
template <typename T>
inline constexpr T linearScale(T value, T inMin, T inMax, T outMin, T outMax) {
  static_assert(std::is_arithmetic<T>::value,
                "linearScale requires a numeric type");
  return outMin + (value - inMin) * (outMax - outMin) / (inMax - inMin);
}
 
}  // namespace mm::core::util
 
namespace std {
template <>
struct hash<std::pair<uint16_t, uint8_t>> {
  size_t operator()(const std::pair<uint16_t, uint8_t>& p) const {
    return hash<uint16_t>()(p.first) ^ (hash<uint8_t>()(p.second) << 1);
  }
};
 
}  // namespace std