Horizon
Loading...
Searching...
No Matches
output_adapters.hpp
1#pragma once
2
3#include <algorithm> // copy
4#include <cstddef> // size_t
5#include <iterator> // back_inserter
6#include <memory> // shared_ptr, make_shared
7#include <string> // basic_string
8#include <vector> // vector
9
10#ifndef JSON_NO_IO
11 #include <ios> // streamsize
12 #include <ostream> // basic_ostream
13#endif // JSON_NO_IO
14
15#include <nlohmann/detail/macro_scope.hpp>
16
17namespace nlohmann
18{
19namespace detail
20{
22template<typename CharType> struct output_adapter_protocol
23{
24 virtual void write_character(CharType c) = 0;
25 virtual void write_characters(const CharType* s, std::size_t length) = 0;
26 virtual ~output_adapter_protocol() = default;
27
28 output_adapter_protocol() = default;
31 output_adapter_protocol& operator=(const output_adapter_protocol&) = default;
32 output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default;
33};
34
36template<typename CharType>
37using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
38
40template<typename CharType, typename AllocatorType = std::allocator<CharType>>
42{
43 public:
44 explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
45 : v(vec)
46 {}
47
48 void write_character(CharType c) override
49 {
50 v.push_back(c);
51 }
52
53 JSON_HEDLEY_NON_NULL(2)
54 void write_characters(const CharType* s, std::size_t length) override
55 {
56 std::copy(s, s + length, std::back_inserter(v));
57 }
58
59 private:
60 std::vector<CharType, AllocatorType>& v;
61};
62
63#ifndef JSON_NO_IO
65template<typename CharType>
67{
68 public:
69 explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
70 : stream(s)
71 {}
72
73 void write_character(CharType c) override
74 {
75 stream.put(c);
76 }
77
78 JSON_HEDLEY_NON_NULL(2)
79 void write_characters(const CharType* s, std::size_t length) override
80 {
81 stream.write(s, static_cast<std::streamsize>(length));
82 }
83
84 private:
85 std::basic_ostream<CharType>& stream;
86};
87#endif // JSON_NO_IO
88
90template<typename CharType, typename StringType = std::basic_string<CharType>>
92{
93 public:
94 explicit output_string_adapter(StringType& s) noexcept
95 : str(s)
96 {}
97
98 void write_character(CharType c) override
99 {
100 str.push_back(c);
101 }
102
103 JSON_HEDLEY_NON_NULL(2)
104 void write_characters(const CharType* s, std::size_t length) override
105 {
106 str.append(s, length);
107 }
108
109 private:
110 StringType& str;
111};
112
113template<typename CharType, typename StringType = std::basic_string<CharType>>
115{
116 public:
117 template<typename AllocatorType = std::allocator<CharType>>
118 output_adapter(std::vector<CharType, AllocatorType>& vec)
119 : oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {}
120
121#ifndef JSON_NO_IO
122 output_adapter(std::basic_ostream<CharType>& s)
123 : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
124#endif // JSON_NO_IO
125
126 output_adapter(StringType& s)
127 : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
128
130 {
131 return oa;
132 }
133
134 private:
135 output_adapter_t<CharType> oa = nullptr;
136};
137} // namespace detail
138} // namespace nlohmann
Definition output_adapters.hpp:115
output adapter for output streams
Definition output_adapters.hpp:67
output adapter for basic_string
Definition output_adapters.hpp:92
output adapter for byte vectors
Definition output_adapters.hpp:42
std::shared_ptr< output_adapter_protocol< CharType > > output_adapter_t
a type to simplify interfaces
Definition output_adapters.hpp:37
namespace for Niels Lohmann
Definition adl_serializer.hpp:12
abstract output adapter interface
Definition output_adapters.hpp:23