ioprint.h

#pragma once
#include <sstream>
#include <vector>
 
namespace tinker {
inline namespace v1 {
template <class T>
const T& formatForward(const T& t)
{
   return t;
}
 
inline const char* formatForward(const std::string& s)
{
   return s.c_str();
}
}
 
template <class F, class... Ts>
void print(std::FILE* out, const F& f, Ts&&... args)
{
   std::fprintf(out, formatForward(f), formatForward(args)...);
}
 
template <class F>
void print(std::FILE* out, const F& f)
{
   std::fprintf(out, "%s", formatForward(f));
}
 
template <class F, class... Ts>
std::string format(const F& f, Ts&&... args)
{
   const char* fmt = formatForward(f);
   size_t l = std::snprintf(nullptr, 0, fmt, formatForward(args)...);
   size_t sz = l + 1;
   const int len = 128;
   if (sz <= len) {
      char buf[len];
      std::snprintf(buf, sz, fmt, formatForward(args)...);
      return std::string(buf, buf + l);
   } else {
      std::vector<char> ptr(sz);
      char* buf = ptr.data();
      std::snprintf(buf, sz, fmt, formatForward(args)...);
      return std::string(buf, buf + l);
   }
}
 
inline std::string operator*(size_t k, std::string str)
{
   std::ostringstream oss;
   for (size_t i = 0; i < k; ++i) {
      oss << str;
   }
   return oss.str();
}
 
inline std::string operator*(std::string str, size_t k)
{
   return k * str;
}
 
inline std::string operator""_s(const char* s, size_t len)
{
   return std::string(s, len);
}
}