Adding metadata

3 files changed, 698 insertions, 0 deletions

diff --git a/dev-cpp/cpprestsdk/cpprestsdk-2.10.19-r6.ebuild b/dev-cpp/cpprestsdk/cpprestsdk-2.10.19-r6.ebuild
new file mode 100644
index 000000000000..f8d72b655490
--- /dev/null
+++ b/dev-cpp/cpprestsdk/cpprestsdk-2.10.19-r6.ebuild
@@ -0,0 +1,41 @@
+# Copyright 1999-2025 Gentoo Authors
+# Distributed under the terms of the GNU General Public License v2
+
+EAPI=8
+
+inherit cmake
+
+DESCRIPTION="A Microsoft project for cloud-based client-server communication."
+HOMEPAGE="https://github.com/microsoft/cpprestsdk"
+SRC_URI="https://github.com/microsoft/cpprestsdk/archive/refs/tags/v${PV}.tar.gz -> ${P}.tar.gz"
+LICENSE="MIT"
+SLOT="0"
+KEYWORDS="~amd64 ~x86"
+
+RDEPEND=">=dev-libs/openssl-1.1.1q
+		>=dev-libs/boost-1.80.0-r1:=
+		>=sys-libs/zlib-1.2.13-r1"
+
+DEPEND="${RDEPEND}"
+
+BDEPEND="
+		app-alternatives/ninja
+		>=sys-devel/gcc-11.3.0
+		>=virtual/pkgconfig-2-r1
+		>=dev-cpp/websocketpp-0.8.2
+"
+
+PATCHES=(
+	"${FILESDIR}"/cpprestsdk-${PV}-warnings.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-disabl-int-tests.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-disable-werror-default.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-boost-1.87-compat.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-cmake-4.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-llvm-char-traits-patch.patch
+	"${FILESDIR}"/cpprestsdk-${PV}-llvm-json-unique-ptr.patch
+)
+
+src_configure() {
+	local mycmakeargs=( -DCMAKE_BUILD_TYPE=Release )
+	cmake_src_configure
+}
diff --git a/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-llvm-char-traits-patch.patch b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-llvm-char-traits-patch.patch
new file mode 100644
index 000000000000..d2a3ef900944
--- /dev/null
+++ b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-llvm-char-traits-patch.patch
@@ -0,0 +1,436 @@
+Also submitted upstream https://github.com/microsoft/cpprestsdk/pull/1829
+Cpprestsdk is using a lot of unsigned types like uint8_t with C++ streams, this
+seems to be fine with msvc/win32 and at least for now with gcc. This patch will
+provide a char_traits type to the streams types other than std::char_traits if
+needed. This is detected via template specialisations. Google & AIs will probably
+suggest adding a std::char_traits<unsingned char> implementation, but I think that
+is very innappropriate in a library for use by applications.
+--- a/Release/include/cpprest/streams.h	(revision 0b1ce318a757bbfb89bdb0fffb61ca4e38dc3b33)
++++ b/Release/include/cpprest/streams.h	(revision 32b322b564e5e540ff02393ffe3bd3bade8d299c)
+@@ -16,6 +16,7 @@
+ #define CASA_STREAMS_H
+ 
+ #include "cpprest/astreambuf.h"
++#include "cpprest/details/char_traits.h"
+ #include <iosfwd>
+ #include <cstdio>
+ 
+@@ -60,30 +61,95 @@
+     concurrency::streams::streambuf<CharType> m_buffer;
+ };
+ 
+-template<typename CharType>
++template<typename CharType, class Traits = typename utility::CanUseStdCharTraits<CharType>::TraitsType>
+ struct Value2StringFormatter
+ {
++    struct SanitizeInput
++    {
++        const std::basic_string<char> &operator () (const std::basic_string<char> &input)
++        {
++            return input;
++        }
++        template <class InputTraits> std::basic_string<char> operator () (const std::basic_string<unsigned char, InputTraits> &input)
++        {
++            return {reinterpret_cast<const char *>(input.c_str()), input.size()};
++        }
++        const char *operator () (const char *input) {
++            return input;
++        }
++        const char *operator () (const unsigned char *input)
++        {
++            return reinterpret_cast<const char *>(input);
++        }
++        template <class T> T operator () (T input)
++        {
++            return input;
++        }
++    };
++    struct GenerateFormatOutput
++    {
++        std::basic_string<CharType,Traits> &&operator() (std::basic_string<CharType,Traits> &&result)
++        {
++            return std::move(result);
++        }
++        std::basic_string<CharType,Traits> operator() (const std::basic_string<char> &intermediate)
++        {
++            return {reinterpret_cast<const CharType *>(intermediate.c_str()), intermediate.size()};
++        }
++    };
+     template<typename T>
+-    static std::basic_string<CharType> format(const T& val)
++    static std::basic_string<CharType, Traits> format(const T& val)
+     {
+-        std::basic_ostringstream<CharType> ss;
++        typename std::conditional<
++            sizeof(CharType) == 1,
++            std::basic_ostringstream<char>,
++            std::basic_ostringstream<typename std::make_signed<CharType>::type>
++        >::type ss;
++        SanitizeInput sanitizer;
++        ss << sanitizer(val);
++        typename std::conditional<
++            sizeof(CharType) == 1,
++            std::basic_string<char>,
++            std::basic_string<typename std::make_signed<CharType>::type>
++        >::type str = ss.str();
++        GenerateFormatOutput generateFormatOutput;
++        return generateFormatOutput(std::move(str));
++    }
++};
++
++template<class Traits, typename T>
++struct Value2StringFormatterUint8Format
++{
++    std::basic_string<uint8_t, Traits> operator () (const T& val)
++    {
++        std::basic_ostringstream<char> ss;
+         ss << val;
+-        return ss.str();
++        return reinterpret_cast<const uint8_t*>(ss.str().c_str());
++    }
++};
++
++template <class Traits>
++struct Value2StringFormatterUint8Format<Traits, std::basic_string<uint8_t,Traits>>
++{
++    std::basic_string<uint8_t, Traits> operator () (
++        const std::basic_string<uint8_t, typename utility::CanUseStdCharTraits<uint8_t>::TraitsType>& val)
++    {
++        Value2StringFormatterUint8Format<Traits,std::basic_string<char>> format;
++        return format(reinterpret_cast<const std::basic_string<char>&>(val));
+     }
+ };
+ 
+ template<>
+ struct Value2StringFormatter<uint8_t>
+ {
+-    template<typename T>
+-    static std::basic_string<uint8_t> format(const T& val)
++    template <typename T, class Traits = typename utility::CanUseStdCharTraits<uint8_t>::TraitsType>
++    static std::basic_string<uint8_t, Traits> format(const T& val)
+     {
+-        std::basic_ostringstream<char> ss;
+-        ss << val;
+-        return reinterpret_cast<const uint8_t*>(ss.str().c_str());
++        Value2StringFormatterUint8Format<Traits, T> format;
++        return format(val);
+     }
+ 
+-    static std::basic_string<uint8_t> format(const utf16string& val)
++    static std::basic_string<uint8_t, typename utility::CanUseStdCharTraits<uint8_t>::TraitsType> format(const utf16string& val)
+     {
+         return format(utility::conversions::utf16_to_utf8(val));
+     }
+@@ -262,7 +328,7 @@
+     /// Write the specified string to the output stream.
+     /// </summary>
+     /// <param name="str">Input string.</param>
+-    pplx::task<size_t> print(const std::basic_string<CharType>& str) const
++    pplx::task<size_t> print(const std::basic_string<CharType,traits>& str) const
+     {
+         pplx::task<size_t> result;
+         if (!_verify_and_return_task(details::_out_stream_msg, result)) return result;
+@@ -273,7 +339,7 @@
+         }
+         else
+         {
+-            auto sharedStr = std::make_shared<std::basic_string<CharType>>(str);
++            auto sharedStr = std::make_shared<std::basic_string<CharType,traits>>(str);
+             return helper()->m_buffer.putn_nocopy(sharedStr->c_str(), sharedStr->size()).then([sharedStr](size_t size) {
+                 return size;
+             });
+@@ -294,7 +360,7 @@
+         if (!_verify_and_return_task(details::_out_stream_msg, result)) return result;
+         // TODO in the future this could be improved to have Value2StringFormatter avoid another unnecessary copy
+         // by putting the string on the heap before calling the print string overload.
+-        return print(details::Value2StringFormatter<CharType>::format(val));
++        return print(details::Value2StringFormatter<CharType, traits>::format(val));
+     }
+ 
+     /// <summary>
+--- a/Release/include/cpprest/astreambuf.h	(revision d17f091b5a753b33fb455e92b590fc9f4e921119)
++++ b/Release/include/cpprest/astreambuf.h	(revision 4188ad89b2cf2e8de3cc3513adcf400fbfdc5ce7)
+@@ -15,6 +15,7 @@
+ 
+ #include "cpprest/asyncrt_utils.h"
+ #include "cpprest/details/basic_types.h"
++#include "cpprest/details/char_traits.h"
+ #include "pplx/pplxtasks.h"
+ #include <atomic>
+ #include <cstring>
+@@ -56,55 +57,28 @@
+ /// <typeparam name="_CharType">
+ /// The data type of the basic element of the stream.
+ /// </typeparam>
++namespace detail
++{
+ template<typename _CharType>
+-struct char_traits : std::char_traits<_CharType>
++struct char_traits : utility::CanUseStdCharTraits<_CharType>::TraitsType
+ {
+     /// <summary>
+     /// Some synchronous functions will return this value if the operation
+     /// requires an asynchronous call in a given situation.
+     /// </summary>
+     /// <returns>An <c>int_type</c> value which implies that an asynchronous call is required.</returns>
+-    static typename std::char_traits<_CharType>::int_type requires_async()
++    static typename utility::CanUseStdCharTraits<_CharType>::TraitsType::int_type requires_async()
+     {
+-        return std::char_traits<_CharType>::eof() - 1;
++        return utility::CanUseStdCharTraits<_CharType>::TraitsType::eof() - 1;
+     }
++};
++}
++template<typename _CharType> struct char_traits : detail::char_traits<_CharType> {
+ };
+ #if !defined(_WIN32)
+-template<>
+-struct char_traits<unsigned char> : private std::char_traits<char>
+-{
+-public:
+-    typedef unsigned char char_type;
+-
+-    using std::char_traits<char>::eof;
+-    using std::char_traits<char>::int_type;
+-    using std::char_traits<char>::off_type;
+-    using std::char_traits<char>::pos_type;
+-
+-    static size_t length(const unsigned char* str)
+-    {
+-        return std::char_traits<char>::length(reinterpret_cast<const char*>(str));
+-    }
+-
+-    static void assign(unsigned char& left, const unsigned char& right) { left = right; }
+-    static unsigned char* assign(unsigned char* left, size_t n, unsigned char value)
+-    {
+-        return reinterpret_cast<unsigned char*>(
+-            std::char_traits<char>::assign(reinterpret_cast<char*>(left), n, static_cast<char>(value)));
+-    }
+-
+-    static unsigned char* copy(unsigned char* left, const unsigned char* right, size_t n)
+-    {
+-        return reinterpret_cast<unsigned char*>(
+-            std::char_traits<char>::copy(reinterpret_cast<char*>(left), reinterpret_cast<const char*>(right), n));
+-    }
+-
+-    static unsigned char* move(unsigned char* left, const unsigned char* right, size_t n)
+-    {
+-        return reinterpret_cast<unsigned char*>(
+-            std::char_traits<char>::move(reinterpret_cast<char*>(left), reinterpret_cast<const char*>(right), n));
+-    }
+-
++template <> struct char_traits<unsigned char> : detail::char_traits<unsigned char> {
++    typedef typename std::char_traits<char>::int_type int_type;
++    static int_type eof() { return std::char_traits<char>::eof(); }
+     static int_type requires_async() { return eof() - 1; }
+ };
+ #endif
+new file mode 100644
+--- /dev/null	(revision 4188ad89b2cf2e8de3cc3513adcf400fbfdc5ce7)
++++ b/Release/include/cpprest/details/char_traits.h	(revision 4188ad89b2cf2e8de3cc3513adcf400fbfdc5ce7)
+@@ -0,0 +1,102 @@
++//
++// Created by sigsegv on 6/28/25.
++//
++
++#ifndef CPPRESTSDK_ROOT_CHAR_TRAITS_H
++#define CPPRESTSDK_ROOT_CHAR_TRAITS_H
++
++#include <type_traits>
++#include <string>
++
++namespace utility {
++
++namespace detail {
++
++template <typename T> struct IntTypeFor {
++    typedef typename std::conditional<std::is_unsigned<T>::value, unsigned long long int, long long int>::type type;
++};
++template <> struct IntTypeFor<char> {
++    typedef typename std::char_traits<char>::int_type type;
++};
++template <> struct IntTypeFor<unsigned char> {
++    typedef typename std::make_unsigned<typename std::char_traits<char>::int_type>::type type;
++};
++
++template <typename T> class DetailCharTraits
++{
++public:
++    using char_type  = T;
++    using int_type   = typename IntTypeFor<T>::type;
++    using off_type   = std::streamoff;
++    using pos_type   = std::streampos;
++    using state_type = mbstate_t;
++
++    static void assign(char_type& r, const char_type& a) noexcept { r = a; }
++    static char_type to_char_type(int_type c) noexcept { return char_type(c); }
++    static int_type  to_int_type(char_type c) noexcept { return c; }
++    static bool eq(char_type a, char_type b) noexcept { return a == b; }
++    static bool lt(char_type a, char_type b) noexcept { return a <  b; }
++    static int compare(const char_type* s1,const char_type* s2,size_t n){
++        for (; n--; ++s1, ++s2) {
++            if (!eq(*s1, *s2))
++                return lt(*s1,*s2)?-1:1;
++        }
++        return 0;
++    }
++    static size_t length(const char_type* s){
++        const char_type* p = s;
++        while (*p)
++            ++p;
++        return size_t(p - s);
++    }
++    static const char_type* find(const char_type* s,size_t n,const char_type& a){
++        for (; n--; ++s)
++        {
++            if (eq(*s, a))
++                return s;
++            return nullptr;
++        }
++    }
++    static char_type* move (char_type* r,const char_type* s,size_t n){
++        return (char_type*)memmove(r, s, n * sizeof(char_type));
++    }
++    static char_type* copy (char_type* r,const char_type* s,size_t n){
++        return (char_type*)memcpy (r, s, n * sizeof(char_type));
++    }
++    static char_type* assign(char_type* r,size_t n,char_type a){
++        if (sizeof(char_type) == 1)
++        {
++            return (char_type*)memset(r, a, n);
++        }
++        else
++        {
++            for (char_type *s = r; n--; ++s)
++            {
++                *s = a;
++            }
++        }
++    }
++    static int_type  eof() noexcept { return ~0u; }
++    static int_type  not_eof(int_type c) noexcept { return c == eof() ? 0 : c; }
++};
++
++template <typename T, typename = bool> struct CanUseStdCharTraits : public std::false_type
++{
++public:
++    typedef DetailCharTraits<T> TraitsType;
++};
++
++template <typename T> struct CanUseStdCharTraits<T, decltype(std::char_traits<T>::eq(std::declval<T>(), std::declval<T>()))> : public std::true_type
++{
++public:
++    typedef std::char_traits<T> TraitsType;
++};
++
++}
++
++template <typename T> struct CanUseStdCharTraits : detail::CanUseStdCharTraits<typename std::remove_const<typename std::remove_reference<T>::type>::type> {
++};
++
++}
++
++#endif // CPPRESTSDK_ROOT_CHAR_TRAITS_H
+--- a/Release/tests/functional/streams/memstream_tests.cpp	(revision d17f091b5a753b33fb455e92b590fc9f4e921119)
++++ b/Release/tests/functional/streams/memstream_tests.cpp	(revision 6df13a8c0417ef700c0f164bcd0686ad46f66fd9)
+@@ -8,6 +8,7 @@
+  *
+  * =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+  ****/
++#include "cpprest/details/char_traits.h"
+ #include "stdafx.h"
+ #if defined(__cplusplus_winrt)
+ #include <wrl.h>
+@@ -32,7 +33,7 @@
+ {
+     VERIFY_IS_TRUE(wbuf.can_write());
+ 
+-    std::basic_string<typename StreamBufferType::char_type> s;
++    std::basic_string<typename StreamBufferType::char_type,typename utility::CanUseStdCharTraits<typename StreamBufferType::char_type>::TraitsType> s;
+     s.push_back((typename StreamBufferType::char_type)0);
+     s.push_back((typename StreamBufferType::char_type)1);
+     s.push_back((typename StreamBufferType::char_type)2);
+@@ -137,7 +138,7 @@
+ {
+     VERIFY_IS_TRUE(wbuf.can_write());
+ 
+-    std::basic_string<typename StreamBufferType::char_type> s;
++    std::basic_string<typename StreamBufferType::char_type,typename utility::CanUseStdCharTraits<typename StreamBufferType::char_type>::TraitsType> s;
+     s.push_back((typename StreamBufferType::char_type)0);
+     s.push_back((typename StreamBufferType::char_type)1);
+     s.push_back((typename StreamBufferType::char_type)2);
+@@ -169,7 +170,7 @@
+ 
+     typedef concurrency::streams::rawptr_buffer<CharType> StreamBufferType;
+ 
+-    std::basic_string<CharType> s;
++    std::basic_string<CharType,typename CanUseStdCharTraits<CharType>::TraitsType> s;
+     s.push_back((CharType)0);
+     s.push_back((CharType)1);
+     s.push_back((CharType)2);
+@@ -198,7 +199,7 @@
+     typedef concurrency::streams::container_buffer<CollectionType> StreamBufferType;
+     typedef typename concurrency::streams::container_buffer<CollectionType>::char_type CharType;
+ 
+-    std::basic_string<CharType> s;
++    std::basic_string<CharType, typename utility::CanUseStdCharTraits<CharType>::TraitsType> s;
+     s.push_back((CharType)0);
+     s.push_back((CharType)1);
+     s.push_back((CharType)2);
+@@ -553,7 +554,7 @@
+     VERIFY_IS_TRUE(rwbuf.can_read());
+     VERIFY_IS_TRUE(rwbuf.can_write());
+     VERIFY_IS_FALSE(rwbuf.is_eof());
+-    std::basic_string<typename StreamBufferType::char_type> s;
++    std::basic_string<typename StreamBufferType::char_type, typename utility::CanUseStdCharTraits<typename StreamBufferType::char_type>::TraitsType> s;
+     s.push_back((typename StreamBufferType::char_type)0);
+     s.push_back((typename StreamBufferType::char_type)1);
+     s.push_back((typename StreamBufferType::char_type)2);
+@@ -684,7 +685,7 @@
+     VERIFY_IS_TRUE(rwbuf.can_write());
+ 
+     // Write 4 characters
+-    std::basic_string<typename StreamBufferType::char_type> s;
++    std::basic_string<typename StreamBufferType::char_type, typename utility::CanUseStdCharTraits<typename StreamBufferType::char_type>::TraitsType> s;
+     s.push_back((typename StreamBufferType::char_type)0);
+     s.push_back((typename StreamBufferType::char_type)1);
+     s.push_back((typename StreamBufferType::char_type)2);
+@@ -726,7 +727,7 @@
+     VERIFY_IS_TRUE(rwbuf.can_write());
+ 
+     // Write 4 characters
+-    std::basic_string<typename StreamBufferType::char_type> s;
++    std::basic_string<typename StreamBufferType::char_type, typename utility::CanUseStdCharTraits<typename StreamBufferType::char_type>::TraitsType> s;
+     s.push_back((typename StreamBufferType::char_type)0);
+     s.push_back((typename StreamBufferType::char_type)1);
+     s.push_back((typename StreamBufferType::char_type)2);
+--- a/Release/tests/functional/streams/stdstream_tests.cpp	(revision d17f091b5a753b33fb455e92b590fc9f4e921119)
++++ b/Release/tests/functional/streams/stdstream_tests.cpp	(revision 6df13a8c0417ef700c0f164bcd0686ad46f66fd9)
+@@ -13,6 +13,7 @@
+ #include "cpprest/filestream.h"
+ #include "cpprest/producerconsumerstream.h"
+ #include "cpprest/rawptrstream.h"
++#include "cpprest/details/char_traits.h"
+ 
+ #if (!defined(_WIN32) || !defined(CPPREST_EXCLUDE_WEBSOCKETS)) && !defined(__cplusplus_winrt)
+ #include <boost/interprocess/streams/bufferstream.hpp>
+@@ -303,7 +304,8 @@
+ 
+         const std::streamsize iterations = 100;
+ 
+-        const std::string the_alphabet("abcdefghijklmnopqrstuvwxyz");
++        const char *the_alphabet_characters = "abcdefghijklmnopqrstuvwxyz";
++        const std::basic_string<uint8_t,typename utility::CanUseStdCharTraits<uint8_t>::TraitsType> the_alphabet(reinterpret_cast<const uint8_t *>(the_alphabet_characters));
+ 
+         auto writer = pplx::create_task([ostream, iterations, the_alphabet]() {
+             auto os = ostream;
+@@ -341,7 +343,8 @@
+ 
+         const std::streamsize iterations = 100;
+ 
+-        const std::string the_alphabet("abcdefghijklmnopqrstuvwxyz");
++        const char *the_alphabet_chars = "abcdefghijklmnopqrstuvwxyz";
++        const std::basic_string<uint8_t,typename CanUseStdCharTraits<uint8_t>::TraitsType> the_alphabet(reinterpret_cast<const uint8_t *>(the_alphabet_chars));
+ 
+         auto writer = pplx::create_task([ostream, iterations, the_alphabet]() {
+             auto os = ostream;
diff --git a/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-llvm-json-unique-ptr.patch b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-llvm-json-unique-ptr.patch
new file mode 100644
index 000000000000..ce7f03741b0b
--- /dev/null
+++ b/dev-cpp/cpprestsdk/files/cpprestsdk-2.10.19-llvm-json-unique-ptr.patch
@@ -0,0 +1,221 @@
+This patch moves the implementations of certain json-methods to the cpp-file-implementations.
+This is needed because llvm needs sizeof(T) to be valid for a lot more methods on containers
+and std::unique_ptr, so these methods can't be header only on llvm. This patch is developed 
+by me and I cannot right now find an upstream bug-report on this just yet. I uploaded a similar 
+patch to FreeBSD ports a while ago. 
+--- a/Release/include/cpprest/json.h
++++ b/Release/include/cpprest/json.h
+@@ -737,12 +737,10 @@
+     _ASYNCRTIMP void format(std::basic_string<char>& string) const;
+ 
+ #ifdef ENABLE_JSON_VALUE_VISUALIZER
+-    explicit value(std::unique_ptr<details::_Value> v, value_type kind) : m_value(std::move(v)), m_kind(kind)
++    explicit value(std::unique_ptr<details::_Value> v, value_type kind);
+ #else
+-    explicit value(std::unique_ptr<details::_Value> v) : m_value(std::move(v))
++    explicit value(std::unique_ptr<details::_Value> v);
+ #endif
+-    {
+-    }
+ 
+     std::unique_ptr<details::_Value> m_value;
+ #ifdef ENABLE_JSON_VALUE_VISUALIZER
+@@ -831,9 +829,9 @@
+     typedef storage_type::size_type size_type;
+ 
+ private:
+-    array() : m_elements() {}
+-    array(size_type size) : m_elements(size) {}
+-    array(storage_type elements) : m_elements(std::move(elements)) {}
++    array();
++    array(size_type size);
++    array(storage_type elements);
+ 
+ public:
+     /// <summary>
+@@ -915,20 +913,13 @@
+     /// <returns>Iterator to the new location of the element following the erased element.</returns>
+     /// <remarks>GCC doesn't support erase with const_iterator on vector yet. In the future this should be
+     /// changed.</remarks>
+-    iterator erase(iterator position) { return m_elements.erase(position); }
++    iterator erase(iterator position);
+ 
+     /// <summary>
+     /// Deletes the element at an index of the JSON array.
+     /// </summary>
+     /// <param name="index">The index of the element to delete.</param>
+-    void erase(size_type index)
+-    {
+-        if (index >= m_elements.size())
+-        {
+-            throw json_exception("index out of bounds");
+-        }
+-        m_elements.erase(m_elements.begin() + index);
+-    }
++    void erase(size_type index);
+ 
+     /// <summary>
+     /// Accesses an element of a JSON array. Throws when index out of bounds.
+@@ -959,15 +950,7 @@
+     /// </summary>
+     /// <param name="index">The index of an element in the JSON array.</param>
+     /// <returns>A reference to the value kept in the field.</returns>
+-    json::value& operator[](size_type index)
+-    {
+-        msl::safeint3::SafeInt<size_type> nMinSize(index);
+-        nMinSize += 1;
+-        msl::safeint3::SafeInt<size_type> nlastSize(m_elements.size());
+-        if (nlastSize < nMinSize) m_elements.resize((size_type)nMinSize);
+-
+-        return m_elements[index];
+-    }
++    json::value& operator[](size_type index);
+ 
+     /// <summary>
+     /// Gets the number of elements of the array.
+@@ -998,14 +981,8 @@
+     typedef storage_type::size_type size_type;
+ 
+ private:
+-    object(bool keep_order = false) : m_elements(), m_keep_order(keep_order) {}
+-    object(storage_type elements, bool keep_order = false) : m_elements(std::move(elements)), m_keep_order(keep_order)
+-    {
+-        if (!keep_order)
+-        {
+-            sort(m_elements.begin(), m_elements.end(), compare_pairs);
+-        }
+-    }
++    object(bool keep_order = false);
++    object(storage_type elements, bool keep_order = false);
+ 
+ public:
+     /// <summary>
+@@ -1087,22 +1064,13 @@
+     /// <returns>Iterator to the new location of the element following the erased element.</returns>
+     /// <remarks>GCC doesn't support erase with const_iterator on vector yet. In the future this should be
+     /// changed.</remarks>
+-    iterator erase(iterator position) { return m_elements.erase(position); }
++    iterator erase(iterator position);
+ 
+     /// <summary>
+     /// Deletes an element of the JSON object. If the key doesn't exist, this method throws.
+     /// </summary>
+     /// <param name="key">The key of an element in the JSON object.</param>
+-    void erase(const utility::string_t& key)
+-    {
+-        auto iter = find_by_key(key);
+-        if (iter == m_elements.end())
+-        {
+-            throw web::json::json_exception("Key not found");
+-        }
+-
+-        m_elements.erase(iter);
+-    }
++    void erase(const utility::string_t& key);
+ 
+     /// <summary>
+     /// Accesses an element of a JSON object. If the key doesn't exist, this method throws.
+@@ -1142,17 +1110,7 @@
+     /// <param name="key">The key of an element in the JSON object.</param>
+     /// <returns>If the key exists, a reference to the value kept in the field, otherwise a newly created null value
+     /// that will be stored for the given key.</returns>
+-    json::value& operator[](const utility::string_t& key)
+-    {
+-        auto iter = find_insert_location(key);
+-
+-        if (iter == m_elements.end() || key != iter->first)
+-        {
+-            return m_elements.insert(iter, std::pair<utility::string_t, value>(key, value()))->second;
+-        }
+-
+-        return iter->second;
+-    }
++    json::value& operator[](const utility::string_t& key);
+ 
+     /// <summary>
+     /// Gets an iterator to an element of a JSON object.
+--- a/Release/src/json/json.cpp
++++ b/Release/src/json/json.cpp
+@@ -135,6 +135,14 @@
+ {
+ }
+ 
++#ifdef ENABLE_JSON_VALUE_VISUALIZER
++web::json::value::value(std::unique_ptr<details::_Value> v, value_type kind) : m_value(std::move(v)), m_kind(kind)
++#else
++web::json::value::value(std::unique_ptr<details::_Value> v) : m_value(std::move(v))
++#endif
++{
++}
++
+ web::json::value::value(const value& other)
+     : m_value(other.m_value->_copy_value())
+ #ifdef ENABLE_JSON_VALUE_VISUALIZER
+@@ -495,3 +503,67 @@
+ #endif
+     return instance;
+ }
++
++web::json::array::array() : m_elements() {}
++web::json::array::array(size_type size) : m_elements(size) {}
++web::json::array::array(storage_type elements) : m_elements(std::move(elements)) {}
++
++web::json::array::iterator web::json::array::erase(web::json::array::iterator position)
++{
++    return m_elements.erase(position);
++}
++
++void web::json::array::erase(web::json::array::size_type index)
++{
++    if (index >= m_elements.size())
++    {
++        throw json_exception("index out of bounds");
++    }
++    m_elements.erase(m_elements.begin() + index);
++}
++
++json::value& web::json::array::operator[](web::json::array::size_type index)
++{
++    msl::safeint3::SafeInt<size_type> nMinSize(index);
++    nMinSize += 1;
++    msl::safeint3::SafeInt<size_type> nlastSize(m_elements.size());
++    if (nlastSize < nMinSize) m_elements.resize((size_type)nMinSize);
++
++    return m_elements[index];
++}
++
++web::json::object::object(bool keep_order) : m_elements(), m_keep_order(keep_order) {}
++web::json::object::object(storage_type elements, bool keep_order) : m_elements(std::move(elements)), m_keep_order(keep_order)
++{
++    if (!keep_order)
++    {
++        sort(m_elements.begin(), m_elements.end(), compare_pairs);
++    }
++}
++web::json::object::iterator web::json::object::erase(iterator position)
++{
++    return m_elements.erase(position);
++}
++
++void web::json::object::erase(const utility::string_t& key)
++{
++    auto iter = find_by_key(key);
++    if (iter == m_elements.end())
++    {
++        throw web::json::json_exception("Key not found");
++    }
++
++    m_elements.erase(iter);
++}
++
++json::value& web::json::object::operator[](const utility::string_t& key)
++{
++    auto iter = find_insert_location(key);
++
++    if (iter == m_elements.end() || key != iter->first)
++    {
++        return m_elements.insert(iter, std::pair<utility::string_t, value>(key, value()))->second;
++    }
++
++    return iter->second;
++}