Horizon
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 
17 namespace nlohmann
18 {
19 namespace detail
20 {
22 template<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 
36 template<typename CharType>
37 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
38 
40 template<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
65 template<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 
90 template<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 
113 template<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 
129  operator output_adapter_t<CharType>()
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