formatted_string.h

#pragma once

#include <algorithm>
#include <array>
#include <cstdio>
#include <string>
#include <vector>

template <typename... Args> class formatted_string {
public:
  static constexpr auto max_len = 32;

private:
  /*
   * The storage for the formatted string
   * A union is used to save space.
   */
  union arena {
    std::array<char, max_len> array;
    std::vector<char> vector;
    arena() {}
    ~arena() {}
  };
  arena storage;

  int len = 0;

  bool is_short() const noexcept { return len < max_len; }

public:
  explicit formatted_string(char const *format, Args... args) {
    static_assert(sizeof...(args) > 0, "Must specify at least one argument");

    len = std::snprintf(nullptr, 0, format, args...);
    char *const buffer = [&]() {
      if (is_short()) {
        new (&storage.array) decltype(storage.array)();
        return storage.array.data();
      } else {
        new (&storage.vector) decltype(storage.vector)(
            static_cast<size_t>(len) + 1);
        return storage.vector.data();
      }
    }();
    std::snprintf(buffer, static_cast<size_t>(len + 1), format, args...);
  }

  template <typename... Ts>
  formatted_string(formatted_string<Ts...> &&rhs) noexcept {
    this->len = rhs.len;
    if (is_short()) {
      new (&this->storage.array) decltype(this->storage.array)();
      std::copy(rhs.storage.array.begin(), rhs.storage.array.end(),
                this->storage.array.begin());
    } else {
      new (&this->storage.vector) decltype(storage.vector)(
          std::move(rhs.storage.vector));
    }
  }

  template <typename... Ts>
  formatted_string &operator=(formatted_string<Ts...> &&rhs) noexcept {
    new (this) formatted_string<Ts...>(std::move(rhs));
    return *this;
  }

  formatted_string(formatted_string const &) = delete;
  formatted_string &operator=(formatted_string const &) = delete;

  char const *c_str() const noexcept {
    return (is_short()) ? storage.array.data() : storage.vector.data();
  }

  std::string to_string() const { return c_str(); }

  ~formatted_string() {
    if (!is_short()) {
      storage.vector.~vector();
    }
  }
};

template <typename... Args>
formatted_string<Args...> make_formatted_string(char const *format,
                                                Args... args) {
  return formatted_string<Args...>(format, args...);
}

inline formatted_string<uint64_t, uint64_t> make_formatted_string(CmiUInt16 ui) {
    const auto lq = static_cast<uint64_t>(ui); // lower quad word
    const auto uq = static_cast<uint64_t>(ui>>64UL); // upper quad word
    return formatted_string<uint64_t, uint64_t>{"%016lx%016lx", uq, lq};
}

inline formatted_string<uint64_t> make_formatted_string(CmiUInt8 ui) {
    return formatted_string<uint64_t>{"%016lx", static_cast<uint64_t>(ui)};
}