.. _program_listing_file_uconfig_format_impl_Rapidjson.ipp:

Program Listing for File Rapidjson.ipp
======================================

|exhale_lsh| :ref:`Return to documentation for file <file_uconfig_format_impl_Rapidjson.ipp>` (``uconfig/format/impl/Rapidjson.ipp``)

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

.. code-block:: cpp

   #pragma once
   
   namespace uconfig {
   
   template <typename AllocatorT>
   template <typename T>
   std::optional<T> RapidjsonFormat<AllocatorT>::Parse(const json_value_type* source, const std::string& path) const
   {
       const auto* target = Get(source, path);
       if (!target) {
           return std::nullopt;
       }
   
       T result;
       if (!this->Convert<T>(*target, result)) {
           return std::nullopt;
       }
       return result;
   }
   
   template <typename AllocatorT>
   template <typename T>
   void RapidjsonFormat<AllocatorT>::Emit(dest_type* dest, const std::string& path, const T& value) const
   {
       Set(MakeJson(value, dest->GetAllocator()), path, dest);
   }
   
   template <typename AllocatorT>
   std::string RapidjsonFormat<AllocatorT>::VectorElementPath(const std::string& vector_path,
                                                              std::size_t index) const noexcept
   {
       return vector_path + "/" + std::to_string(index);
   }
   
   template <typename AllocatorT>
   const typename RapidjsonFormat<AllocatorT>::json_value_type*
   RapidjsonFormat<AllocatorT>::Get(const json_value_type* source, const std::string& path)
   {
       return json_pointer_type(path).Get(*source);
   }
   
   template <typename AllocatorT>
   void RapidjsonFormat<AllocatorT>::Set(json_value_type&& value, const std::string& path, dest_type* dest)
   {
       json_pointer_type(path).Set(*dest, std::move(value), dest->GetAllocator());
   }
   
   template <typename AllocatorT>
   template <typename T, typename std::enable_if<std::is_same<T, std::string>::value>::type*>
   bool RapidjsonFormat<AllocatorT>::Convert(const json_value_type& source, T& result)
   {
       switch (source.GetType()) {
       case rapidjson::kStringType:
           result = source.GetString();
           break;
       default:
           return false;
       }
       return true;
   }
   
   template <typename AllocatorT>
   template <typename T, typename std::enable_if<std::is_same<T, bool>::value>::type*>
   bool RapidjsonFormat<AllocatorT>::Convert(const json_value_type& source, T& result)
   {
       switch (source.GetType()) {
       case rapidjson::kTrueType:
       case rapidjson::kFalseType:
           result = source.GetBool();
           break;
       default:
           return false;
       }
       return true;
   }
   
   template <typename AllocatorT>
   template <typename T, typename std::enable_if<std::is_same<T, int>::value>::type*>
   bool RapidjsonFormat<AllocatorT>::Convert(const json_value_type& source, T& result)
   {
       if (source.IsInt()) {
           result = source.GetInt();
           return true;
       }
   
       return false;
   }
   
   template <typename AllocatorT>
   template <typename T, typename std::enable_if<std::is_same<T, long>::value>::type*>
   bool RapidjsonFormat<AllocatorT>::Convert(const json_value_type& source, T& result)
   {
       if (source.IsInt64()) {
           result = source.GetInt64();
           return true;
       }
   
       return false;
   }
   
   template <typename AllocatorT>
   template <typename T, typename std::enable_if<std::is_same<T, long long>::value>::type*>
   bool RapidjsonFormat<AllocatorT>::Convert(const json_value_type& source, T& result)
   {
       if (source.IsInt64()) {
           result = source.GetInt64();
           return true;
       }
   
       return false;
   }
   
   template <typename AllocatorT>
   template <typename T, typename std::enable_if<std::is_same<T, unsigned>::value>::type*>
   bool RapidjsonFormat<AllocatorT>::Convert(const json_value_type& source, T& result)
   {
       if (source.IsUint()) {
           result = source.GetUint();
           return true;
       }
   
       return false;
   }
   
   template <typename AllocatorT>
   template <typename T, typename std::enable_if<std::is_same<T, unsigned long>::value>::type*>
   bool RapidjsonFormat<AllocatorT>::Convert(const json_value_type& source, T& result)
   {
       if (source.IsUint64()) {
           result = source.GetUint64();
           return true;
       }
   
       return false;
   }
   
   template <typename AllocatorT>
   template <typename T, typename std::enable_if<std::is_same<T, unsigned long long>::value>::type*>
   bool RapidjsonFormat<AllocatorT>::Convert(const json_value_type& source, T& result)
   {
       if (source.IsUint64()) {
           result = source.GetUint64();
           return true;
       }
   
       return false;
   }
   
   template <typename AllocatorT>
   template <typename T, typename std::enable_if<std::is_same<T, double>::value>::type*>
   bool RapidjsonFormat<AllocatorT>::Convert(const json_value_type& source, T& result)
   {
       if (source.IsLosslessDouble()) {
           result = source.GetDouble();
           return true;
       }
   
       return false;
   }
   
   template <typename AllocatorT>
   template <typename T, typename std::enable_if<std::is_same<T, float>::value>::type*>
   bool RapidjsonFormat<AllocatorT>::Convert(const json_value_type& source, T& result)
   {
       if (source.IsLosslessFloat()) {
           result = source.GetFloat();
           return true;
       }
   
       return false;
   }
   
   template <typename AllocatorT>
   template <typename SrcT,
             typename std::enable_if<std::is_same<SrcT, bool>::value || std::is_same<SrcT, int>::value ||
                                     std::is_same<SrcT, long long>::value || std::is_same<SrcT, unsigned>::value ||
                                     std::is_same<SrcT, unsigned long long>::value || std::is_same<SrcT, double>::value ||
                                     std::is_same<SrcT, float>::value>::type*>
   typename RapidjsonFormat<AllocatorT>::json_value_type RapidjsonFormat<AllocatorT>::MakeJson(const SrcT& source,
                                                                                               allocator_type& /*alloc*/)
   {
       return json_value_type(source);
   }
   
   template <typename AllocatorT>
   template <typename SrcT, typename std::enable_if<std::is_same<SrcT, long>::value>::type*>
   typename RapidjsonFormat<AllocatorT>::json_value_type RapidjsonFormat<AllocatorT>::MakeJson(const SrcT& source,
                                                                                               allocator_type& /*alloc*/)
   {
       return json_value_type((int64_t)source);
   }
   
   template <typename AllocatorT>
   template <typename SrcT, typename std::enable_if<std::is_same<SrcT, unsigned long>::value>::type*>
   typename RapidjsonFormat<AllocatorT>::json_value_type RapidjsonFormat<AllocatorT>::MakeJson(const SrcT& source,
                                                                                               allocator_type& /*alloc*/)
   {
       return json_value_type((uint64_t)source);
   }
   
   template <typename AllocatorT>
   template <typename SrcT, typename std::enable_if<std::is_same<SrcT, std::string>::value>::type*>
   typename RapidjsonFormat<AllocatorT>::json_value_type RapidjsonFormat<AllocatorT>::MakeJson(const SrcT& source,
                                                                                               allocator_type& alloc)
   {
       return json_value_type(source, alloc);
   }
   
   } // namespace uconfig