Serialization.h

Go to the documentation of this file.

#ifndef LINTEL_POSTGRES_SERIALIZATION_H
#define LINTEL_POSTGRES_SERIALIZATION_H
 
#include <chrono>
#include <string>
#include <type_traits>
 
#include "lintel/core/utils/DateTimeFormat.h"
 
#define IMPLEMENT_SERIALIZE(type, convertToString, convertToValue)                      \
  template<> class Serialization<type>                                                  \
  {                                                                                     \
  public:                                                                               \
    static std::string serialize(const type &value) { return convertToString(value); }  \
    static type deserialize(const std::string &value) { return convertToValue(value); } \
  };
 
namespace lintel {
namespace postgresql {
  template<typename T, typename Enable = void> class Serialization
  {
  };
 
  IMPLEMENT_SERIALIZE(int8_t, std::to_string, std::stoi)
 
  IMPLEMENT_SERIALIZE(int16_t, std::to_string, std::stoi)
 
  IMPLEMENT_SERIALIZE(int32_t, std::to_string, std::stoi)
 
  IMPLEMENT_SERIALIZE(int64_t, std::to_string, std::stol)
 
  IMPLEMENT_SERIALIZE(uint8_t, std::to_string, std::stoul)
 
  IMPLEMENT_SERIALIZE(uint16_t, std::to_string, std::stoul)
 
  IMPLEMENT_SERIALIZE(uint32_t, std::to_string, std::stoul)
 
  IMPLEMENT_SERIALIZE(uint64_t, std::to_string, std::stoul)
 
  IMPLEMENT_SERIALIZE(float, std::to_string, std::stof)
 
  IMPLEMENT_SERIALIZE(double, std::to_string, std::stod)
 
  IMPLEMENT_SERIALIZE(
    std::string,
    [](const std::string &string) -> std::string { return string; },
    [](const std::string &string) -> std::string { return string; })
 
  template<> class Serialization<bool>
  {
  public:
    static std::string serialize(const bool &value) { return value ? "t" : "f"; }
    static bool deserialize(const std::string &value) { return value == "t"; }
  };
 
  IMPLEMENT_SERIALIZE(
    std::chrono::sys_time<std::chrono::microseconds>,
    [](const std::chrono::sys_time<std::chrono::microseconds> &time) -> std::string {
      return datetime::formatSystemTime(time);
    },
    [](const std::string &timeString) -> std::chrono::sys_time<std::chrono::microseconds> {
      return datetime::parseSystemTime(timeString);
    })
 
  // Only activated when std::size_t is distinct from all fixed-width integer types
  // (full specializations above take precedence over this partial specialization)
  template<typename T> class Serialization<T, std::enable_if_t<std::is_same_v<T, std::size_t>>>
  {
  public:
    static std::string serialize(const T &value) { return std::to_string(value); }
    static T deserialize(const std::string &value) { return static_cast<T>(std::stoul(value)); }
  };
}// namespace postgresql
 
}// namespace lintel
#endif// LINTEL_POSTGRES_SERIALIZATION_H