.. _program_listing_file_zeep_value-serializer.hpp:

Program Listing for File value-serializer.hpp
=============================================

|exhale_lsh| :ref:`Return to documentation for file <file_zeep_value-serializer.hpp>` (``zeep/value-serializer.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   //        Copyright Maarten L. Hekkelman, 2014-2023
   // Distributed under the Boost Software License, Version 1.0.
   //    (See accompanying file LICENSE_1_0.txt or copy at
   //          http://www.boost.org/LICENSE_1_0.txt)
   
   #pragma once
   
   #include <zeep/config.hpp>
   
   #include <charconv>
   #include <cstdint>
   #include <iomanip>
   #include <map>
   #include <regex>
   #include <sstream>
   
   #include <zeep/exception.hpp>
   
   #if __has_include(<date/date.h>)
   #include <date/date.h>
   #endif
   
   namespace zeep
   {
   
   // --------------------------------------------------------------------
   
   template <typename T, typename = void>
   struct value_serializer;
   
   template <>
   struct value_serializer<bool>
   {
       static constexpr const char *type_name() { return "xsd:boolean"; }
       static std::string to_string(bool value) { return value ? "true" : "false"; }
       static bool from_string(const std::string &value) { return value == "true" or value == "1" or value == "yes"; }
   };
   
   template <>
   struct value_serializer<std::string>
   {
       static constexpr const char *type_name() { return "xsd:string"; }
       static std::string to_string(const std::string &value) { return value; }
       static std::string from_string(const std::string &value) { return value; }
   };
   
   template<typename T>
   struct char_conv_serializer
   {
       using value_type = T;
   
       static constexpr const char *derived_type_name()
       {
           using value_serializer_type = value_serializer<value_type>;
           return value_serializer_type::type_name();
       }
   
       static std::string to_string(value_type value) { return std::to_string(value); }
       static value_type from_string(const std::string &value)
       {
           value_type result{};
   
           auto r = std::from_chars(value.data(), value.data() + value.length(), result);
   
           if (r.ec != std::errc{} or r.ptr != value.data() + value.length())
               throw std::system_error(std::make_error_code(r.ec), "Error converting value '" + value + "' to type " + derived_type_name());
   
           return result;
       }
   };
   
   template <>
   struct value_serializer<int8_t> : char_conv_serializer<int8_t>
   {
       static constexpr const char *type_name() { return "xsd:byte"; }
   };
   
   template <>
   struct value_serializer<uint8_t> : char_conv_serializer<uint8_t>
   {
       static constexpr const char *type_name() { return "xsd:unsignedByte"; }
   };
   
   template <>
   struct value_serializer<int16_t> : char_conv_serializer<int16_t>
   {
       static constexpr const char *type_name() { return "xsd:short"; }
   };
   
   template <>
   struct value_serializer<uint16_t> : char_conv_serializer<uint16_t>
   {
       static constexpr const char *type_name() { return "xsd:unsignedShort"; }
   };
   
   template <>
   struct value_serializer<int32_t> : char_conv_serializer<int32_t>
   {
       static constexpr const char *type_name() { return "xsd:int"; }
   };
   
   template <>
   struct value_serializer<uint32_t> : char_conv_serializer<uint32_t>
   {
       static constexpr const char *type_name() { return "xsd:unsignedInt"; }
   };
   
   template <>
   struct value_serializer<int64_t> : char_conv_serializer<int64_t>
   {
       static constexpr const char *type_name() { return "xsd:long"; }
   };
   
   template <>
   struct value_serializer<uint64_t> : char_conv_serializer<uint64_t>
   {
       static constexpr const char *type_name() { return "xsd:unsignedLong"; }
   };
   
   template <>
   struct value_serializer<float>
   {
       static constexpr const char *type_name() { return "xsd:float"; }
       // static std::string to_string(float value)                { return std::to_string(value); }
       static std::string to_string(float value)
       {
           std::ostringstream s;
           s << value;
           return s.str();
       }
       static float from_string(const std::string &value) { return std::stof(value); }
   };
   
   template <>
   struct value_serializer<double>
   {
       static constexpr const char *type_name() { return "xsd:double"; }
       // static std::string to_string(double value)               { return std::to_string(value); }
       static std::string to_string(double value)
       {
           std::ostringstream s;
           s << value;
           return s.str();
       }
       static double from_string(const std::string &value) { return std::stod(value); }
   };
   
   
   template <typename T>
   struct value_serializer<T, std::enable_if_t<std::is_enum_v<T>>>
   {
       std::string m_type_name;
   
       using value_map_type = std::map<T, std::string>;
       using value_map_value_type = typename value_map_type::value_type;
   
       value_map_type m_value_map;
   
       static void init(const char *name, std::initializer_list<value_map_value_type> values)
       {
           instance(name).m_value_map = value_map_type(values);
       }
   
       static void init(std::initializer_list<value_map_value_type> values)
       {
           instance().m_value_map = value_map_type(values);
       }
   
       static value_serializer &instance(const char *name = nullptr)
       {
           static value_serializer s_instance;
           if (name and s_instance.m_type_name.empty())
               s_instance.m_type_name = name;
           return s_instance;
       }
   
       value_serializer &operator()(T v, const std::string &name)
       {
           m_value_map[v] = name;
           return *this;
       }
   
       value_serializer &operator()(const std::string &name, T v)
       {
           m_value_map[v] = name;
           return *this;
       }
   
       static const char *type_name()
       {
           return instance().m_type_name;
       }
   
       static std::string to_string(T value)
       {
           return instance().m_value_map[value];
       }
   
       static T from_string(const std::string &value)
       {
           T result = {};
           for (auto &t : instance().m_value_map)
               if (t.second == value)
               {
                   result = t.first;
                   break;
               }
           return result;
       }
   
       static bool empty()
       {
           return instance().m_value_map.empty();
       }
   };
   
   // --------------------------------------------------------------------
   // date/time support
   // We're using Howard Hinands date functions here. If available...
   
   #if __has_include(<date/date.h>)
   
   
   template <>
   struct value_serializer<std::chrono::system_clock::time_point>
   {
       using time_type = std::chrono::system_clock::time_point;
   
       static constexpr const char *type_name() { return "xsd:dateTime"; }
   
       static std::string to_string(const time_type &v)
       {
           std::ostringstream ss;
           ss << date::format("%FT%TZ", v);
           return ss.str();
       }
   
       static time_type from_string(const std::string &s)
       {
           time_type result;
   
           std::regex kRX(R"(^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(Z|[-+]\d{2}:\d{2})?)");
           std::smatch m;
   
           if (not std::regex_match(s, m, kRX))
               throw std::runtime_error("Invalid date format");
   
           std::istringstream is(s);
   
           if (m[1].matched)
           {
               if (m[1] == "Z")
                   date::from_stream(is, "%FT%TZ", result);
               else
                   date::from_stream(is, "%FT%T%0z", result);
           }
           else
               date::from_stream(is, "%FT%T", result);
   
           if (is.bad() or is.fail())
               throw std::runtime_error("invalid formatted date");
   
           return result;
       }
   };
   
   
   template <>
   struct value_serializer<date::sys_days>
   {
       static constexpr const char *type_name() { return "xsd:date"; }
   
       static std::string to_string(const date::sys_days &v)
       {
           std::ostringstream ss;
           date::to_stream(ss, "%F", v);
           return ss.str();
       }
   
       static date::sys_days from_string(const std::string &s)
       {
           date::sys_days result;
   
           std::istringstream is(s);
           date::from_stream(is, "%F", result);
   
           if (is.bad() or is.fail())
               throw std::runtime_error("invalid formatted date");
           
           return result;
       }
   };
   
   #endif
   
   } // namespace zeep