1 #ifndef CPR_API_H
2 #define CPR_API_H
3
4 #include <fstream>
5 #include <functional>
6 #include <future>
7 #include <string>
8 #include <utility>
9
10 #include "cpr/auth.h"
11 #include "cpr/bearer.h"
12 #include "cpr/cprtypes.h"
13 #include "cpr/digest.h"
14 #include "cpr/multipart.h"
15 #include "cpr/ntlm.h"
16 #include "cpr/payload.h"
17 #include "cpr/response.h"
18 #include "cpr/session.h"
19 #include <utility>
20
21 namespace cpr {
22
23 using AsyncResponse = std::future<Response>;
24
25 namespace priv {
26
27 template <typename... Ts>
set_option(Session & session,Ts &&...ts)28 void set_option(Session& session, Ts&&... ts) {
29 std::initializer_list<int> ignore = { (session.SetOption(std::forward<Ts>(ts)), 0)... };
30 (void)ignore;
31 }
32
33 } // namespace priv
34
35 // Get methods
36 template <typename... Ts>
Get(Ts &&...ts)37 Response Get(Ts&&... ts) {
38 Session session;
39 priv::set_option(session, std::forward<Ts>(ts)...);
40 return session.Get();
41 }
42
43 // Get async methods
44 template <typename... Ts>
GetAsync(Ts...ts)45 AsyncResponse GetAsync(Ts... ts) {
46 return std::async(
47 std::launch::async, [](Ts... ts_inner) { return Get(std::move(ts_inner)...); }, std::move(ts)...);
48 }
49
50 // Get callback methods
51 template <typename Then, typename... Ts>
52 // NOLINTNEXTLINE(fuchsia-trailing-return)
53 auto GetCallback(Then then, Ts... ts) -> std::future<decltype(then(Get(std::move(ts)...)))> {
54 return std::async(
55 std::launch::async, [](Then then_inner, Ts... ts_inner) { return then_inner(Get(std::move(ts_inner)...)); },
56 std::move(then), std::move(ts)...);
57 }
58
59 // Post methods
60 template <typename... Ts>
Post(Ts &&...ts)61 Response Post(Ts&&... ts) {
62 Session session;
63 priv::set_option(session, std::forward<Ts>(ts)...);
64 return session.Post();
65 }
66
67 // Post async methods
68 template <typename... Ts>
PostAsync(Ts...ts)69 AsyncResponse PostAsync(Ts... ts) {
70 return std::async(
71 std::launch::async, [](Ts... ts_inner) { return Post(std::move(ts_inner)...); }, std::move(ts)...);
72 }
73
74 // Post callback methods
75 template <typename Then, typename... Ts>
76 // NOLINTNEXTLINE(fuchsia-trailing-return)
77 auto PostCallback(Then then, Ts... ts) -> std::future<decltype(then(Post(std::move(ts)...)))> {
78 return std::async(
79 std::launch::async, [](Then then_inner, Ts... ts_inner) { return then_inner(Post(std::move(ts_inner)...)); },
80 std::move(then), std::move(ts)...);
81 }
82
83 // Put methods
84 template <typename... Ts>
Put(Ts &&...ts)85 Response Put(Ts&&... ts) {
86 Session session;
87 priv::set_option(session, std::forward<Ts>(ts)...);
88 return session.Put();
89 }
90
91 // Put async methods
92 template <typename... Ts>
PutAsync(Ts...ts)93 AsyncResponse PutAsync(Ts... ts) {
94 return std::async(
95 std::launch::async, [](Ts... ts_inner) { return Put(std::move(ts_inner)...); }, std::move(ts)...);
96 }
97
98 // Put callback methods
99 template <typename Then, typename... Ts>
100 // NOLINTNEXTLINE(fuchsia-trailing-return)
101 auto PutCallback(Then then, Ts... ts) -> std::future<decltype(then(Put(std::move(ts)...)))> {
102 return std::async(
103 std::launch::async, [](Then then_inner, Ts... ts_inner) { return then_inner(Put(std::move(ts_inner)...)); },
104 std::move(then), std::move(ts)...);
105 }
106
107 // Head methods
108 template <typename... Ts>
Head(Ts &&...ts)109 Response Head(Ts&&... ts) {
110 Session session;
111 priv::set_option(session, std::forward<Ts>(ts)...);
112 return session.Head();
113 }
114
115 // Head async methods
116 template <typename... Ts>
HeadAsync(Ts...ts)117 AsyncResponse HeadAsync(Ts... ts) {
118 return std::async(
119 std::launch::async, [](Ts... ts_inner) { return Head(std::move(ts_inner)...); }, std::move(ts)...);
120 }
121
122 // Head callback methods
123 template <typename Then, typename... Ts>
124 // NOLINTNEXTLINE(fuchsia-trailing-return)
125 auto HeadCallback(Then then, Ts... ts) -> std::future<decltype(then(Head(std::move(ts)...)))> {
126 return std::async(
127 std::launch::async, [](Then then_inner, Ts... ts_inner) { return then_inner(Head(std::move(ts_inner)...)); },
128 std::move(then), std::move(ts)...);
129 }
130
131 // Delete methods
132 template <typename... Ts>
Delete(Ts &&...ts)133 Response Delete(Ts&&... ts) {
134 Session session;
135 priv::set_option(session, std::forward<Ts>(ts)...);
136 return session.Delete();
137 }
138
139 // Delete async methods
140 template <typename... Ts>
DeleteAsync(Ts...ts)141 AsyncResponse DeleteAsync(Ts... ts) {
142 return std::async(
143 std::launch::async, [](Ts... ts_inner) { return Delete(std::move(ts_inner)...); },
144 std::move(ts)...);
145 }
146
147 // Delete callback methods
148 template <typename Then, typename... Ts>
149 // NOLINTNEXTLINE(fuchsia-trailing-return)
150 auto DeleteCallback(Then then, Ts... ts) -> std::future<decltype(then(Delete(std::move(ts)...)))> {
151 return std::async(
152 std::launch::async, [](Then then_inner, Ts... ts_inner) { return then_inner(Delete(std::move(ts_inner)...)); },
153 std::move(then), std::move(ts)...);
154 }
155
156 // Options methods
157 template <typename... Ts>
Options(Ts &&...ts)158 Response Options(Ts&&... ts) {
159 Session session;
160 priv::set_option(session, std::forward<Ts>(ts)...);
161 return session.Options();
162 }
163
164 // Options async methods
165 template <typename... Ts>
OptionsAsync(Ts...ts)166 AsyncResponse OptionsAsync(Ts... ts) {
167 return std::async(
168 std::launch::async, [](Ts... ts_inner) { return Options(std::move(ts_inner)...); },
169 std::move(ts)...);
170 }
171
172 // Options callback methods
173 template <typename Then, typename... Ts>
174 // NOLINTNEXTLINE(fuchsia-trailing-return)
175 auto OptionsCallback(Then then, Ts... ts)
176 -> std::future<decltype(then(Options(std::move(ts)...)))> {
177 return std::async(
178 std::launch::async, [](Then then_inner, Ts... ts_inner) { return then_inner(Options(std::move(ts_inner)...)); },
179 std::move(then), std::move(ts)...);
180 }
181
182 // Patch methods
183 template <typename... Ts>
Patch(Ts &&...ts)184 Response Patch(Ts&&... ts) {
185 Session session;
186 priv::set_option(session, std::forward<Ts>(ts)...);
187 return session.Patch();
188 }
189
190 // Patch async methods
191 template <typename... Ts>
PatchAsync(Ts...ts)192 AsyncResponse PatchAsync(Ts... ts) {
193 return std::async(
194 std::launch::async, [](Ts... ts_inner) { return Patch(std::move(ts_inner)...); }, std::move(ts)...);
195 }
196
197 // Patch callback methods
198 template <typename Then, typename... Ts>
199 // NOLINTNEXTLINE(fuchsia-trailing-return)
200 auto PatchCallback(Then then, Ts... ts) -> std::future<decltype(then(Patch(std::move(ts)...)))> {
201 return std::async(
202 std::launch::async, [](Then then_inner, Ts... ts_inner) { return then_inner(Patch(std::move(ts_inner)...)); },
203 std::move(then), std::move(ts)...);
204 }
205
206 // Download methods
207 template <typename... Ts>
Download(std::ofstream & file,Ts &&...ts)208 Response Download(std::ofstream& file, Ts&&... ts) {
209 Session session;
210 priv::set_option(session, std::forward<Ts>(ts)...);
211 return session.Download(file);
212 }
213
214 // Download with user callback
215 template <typename... Ts>
Download(const WriteCallback & write,Ts &&...ts)216 Response Download(const WriteCallback& write, Ts&&... ts) {
217 Session session;
218 priv::set_option(session, std::forward<Ts>(ts)...);
219 return session.Download(write);
220 }
221
222 } // namespace cpr
223
224 #endif
225