CodePorting.Translator Cs2Cpp
CodePorting.Translator.Cs2Cpp.Framework
defines.h
1
2#pragma once
3
4#if defined _MSC_VER
5// This needed to silence std::allocator<void> depreacation warning in C++17
6# define _SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING true
7#endif
8
9#include <type_traits>
10#include <utility>
11#include <limits>
12#include <iterator>
13#include <string>
14#include <codecvt>
15#include <locale>
16
17#if defined(_WIN32) && !defined(WIN32)
18#define WIN32
19#endif
20
21#if defined(WIN32)
22 #define CODEPORTING_WINDOWS 1
23#elif defined(__APPLE__)
24 #define CODEPORTING_MACOS 1
25#elif defined(__linux__)
26 #define CODEPORTING_LINUX 1
27#elif defined(__EMSCRIPTEN__)
28 #define CODEPORTING_WEBASSEMBLY 1
29#else
30 #error "Unknown platform"
31#endif
32
33// Determine C++ version in portable way
34#if __cplusplus >= 202002L || _MSVC_LANG >= 202002L
35# define CODEPORTING_CPP_STANDARD 20
36#elif __cplusplus >= 201703L || _MSVC_LANG >= 201703L
37# define CODEPORTING_CPP_STANDARD 17
38#elif __cplusplus >= 201402L || _MSVC_LANG >= 201402L
39# define CODEPORTING_CPP_STANDARD 14
40#else
41# error The C++ language standard you specified is not supported.
42#endif
43
44#if defined(__GNUC__)
45 #define __GCC__
46#elif defined(_MSC_VER)
47 #define __MSVC__
48#else
49 #error unsupported compiler.
50#endif
51
52#if defined __GCC__
54 #define ABSTRACT
55#elif defined __MSVC__
57 #define ABSTRACT __declspec(novtable)
58#endif
59
61#define ASPOSE_CONST const
62
63#ifdef ASPOSECPP_STATIC_LIB
64 #define ASPOSECPP_SHARED_API
65 #define ASPOSECPP_SHARED_CLASS
66 #define ASPOSECPP_SHARED_RTTI_INFO_DECL() RTTI_INFO_DECL()
67#elif defined(CODEPORTING_WINDOWS)
68 #if defined(__MSVC__)
69 #ifdef ASPOSECPP_SHARED_EXPORTS
71 #define ASPOSECPP_SHARED_API __declspec(dllexport)
72 #define ASPOSECPP_SHARED_CLASS
73 #else
75 #define ASPOSECPP_SHARED_API __declspec(dllimport)
76 #define ASPOSECPP_SHARED_CLASS
77 #endif
79 #define ASPOSECPP_SHARED_RTTI_INFO_DECL() RTTI_INFO_DECL_EX(ASPOSECPP_SHARED_API)
80 #else
81 #ifdef ASPOSECPP_SHARED_EXPORTS
83 #define ASPOSECPP_SHARED_API __attribute__ ((dllexport))
84 #define ASPOSECPP_SHARED_CLASS __attribute__ ((dllexport))
85 #else
87 #define ASPOSECPP_SHARED_API __attribute__ ((dllimport))
88 #define ASPOSECPP_SHARED_CLASS __attribute__ ((dllimport))
89 #endif
91 #define ASPOSECPP_SHARED_RTTI_INFO_DECL() RTTI_INFO_DECL()
92 #endif
93#elif defined(CODEPORTING_MACOS)
94 #define ASPOSECPP_SHARED_API __attribute__ ((visibility ("default")))
95 #define ASPOSECPP_SHARED_CLASS __attribute__ ((visibility ("default")))
96 #define ASPOSECPP_SHARED_RTTI_INFO_DECL() RTTI_INFO_DECL()
97#else
98 #ifdef ASPOSECPP_SHARED_EXPORTS
100 #define ASPOSECPP_SHARED_API __attribute__ ((visibility ("default")))
101 #define ASPOSECPP_SHARED_CLASS __attribute__ ((visibility ("default")))
102 #else
104 #define ASPOSECPP_SHARED_API
105 #define ASPOSECPP_SHARED_CLASS
106 #endif
108 #define ASPOSECPP_SHARED_RTTI_INFO_DECL() RTTI_INFO_DECL()
109#endif
110
111
112#if defined(_MSC_VER) && (_MSC_VER < 1910)
113 #error "Only Microsoft Visual Studio 2017 (and higher) is supported"
114#endif
115
116#if (defined(_MSC_VER) || defined(FORCE_BUILD_DEBUG)) && (defined(_DEBUG) || defined(DEBUG))
117 #if !defined(ASPOSECPP_DEBUG)
121 #define ASPOSECPP_DEBUG
122 #endif
123#else
124 #undef ASPOSECPP_DEBUG
125#endif
126
127namespace System { namespace Detail {
129 typedef enum {} empty_enum;
130 typedef enum class empty_enum_class {} empty_enum_class;
131
132 template <int PtrSize, int A, int B, int C, int D>
133 struct __InternalTypeStub {};
134
135 template <int A, int B, int C, int D>
136 struct __InternalTypeStub<4, A, B, C, D>
137 {
138 typedef typename std::aligned_storage<A, B>::type type;
139 };
140
141 template <int A, int B, int C, int D>
142 struct __InternalTypeStub<8, A, B, C, D>
143 {
144 typedef typename std::aligned_storage<C, D>::type type;
145 };
146} }
147
148#define ASPOSE_NO_EXPORT
149
150// Internal fast RTTI implementation
151#define ASPOSE_FAST_RTTI_DECL(keyword) \
152 keyword bool FastCast(const ::System::Details::FastRttiBase& helper, void** out_ptr) const override;
153
154#define ASPOSE_FAST_RTTI_IMPL(class_name) \
155 bool class_name::FastCast(const ::System::Details::FastRttiBase& helper, void** out_ptr) const \
156 { \
157 *out_ptr = helper.Cast(this); \
158 return true; \
159 }
160
161//Wrappers for types from 3rd party libraries
162#ifdef ASPOSECPPLIB_BEING_BUILT
165 #define ASPOSECPP_3RD_PARTY_CLASS(type_name) class type_name;
168 #define ASPOSECPP_3RD_PARTY_STRUCT(type_name) struct type_name;
169
172 #define ASPOSECPP_3RD_PARTY_ENUM_CLASS_WITHOUT_UNDERLYING(type_name) {}
177 #define ASPOSECPP_3RD_PARTY_ENUM_WITH_UNDERLYING(type_name, underlying) \
178 static_assert(std::is_enum<type_name>::value, #type_name " is not a enum but is declared as one!"); \
179 static_assert(sizeof(type_name) == sizeof(underlying), "Declaring " #type_name " enum with wrong size of underlying type " #underlying "!"); \
180 static_assert(std::is_signed<std::underlying_type<type_name>::type>::value == std::is_signed<underlying>::value, "Declaring " #type_name " enum with wrong signedness of underlying type " #underlying "!"); \
181 static_assert(std::is_same<std::underlying_type<type_name>::type, underlying>::value, "Declaring " #type_name " enum with wrong underlying type " #underlying "!");
182 #define ASPOSECPP_3RD_PARTY_ENUM_CLASS_WITH_UNDERLYING(type_name, underlying) ASPOSECPP_3RD_PARTY_ENUM_WITH_UNDERLYING(type_name, underlying)
186 #define ASPOSECPP_3RD_PARTY_ENUM(type_name) ASPOSECPP_3RD_PARTY_ENUM_WITH_UNDERLYING(type_name, std::underlying_type<::System::Detail::empty_enum>::type);
187 #define ASPOSECPP_3RD_PARTY_ENUM_CLASS(type_name) ASPOSECPP_3RD_PARTY_ENUM_CLASS_WITH_UNDERLYING(type_name, std::underlying_type<::System::Detail::empty_enum_class>::type);
188
193 #define ASPOSECPP_3RD_PARTY_TYPEDEF(name, type) \
194 static_assert(std::is_same<name, type>::value, "Wrong type " #type " specified for typedef " #name "!");
195
201 #define ASPOSECPP_3RD_PARTY_TYPEDEF_WITH_PTR(name, type) \
202 ASPOSECPP_3RD_PARTY_TYPEDEF(name, type) \
203 ASPOSECPP_3RD_PARTY_TYPEDEF(name##Ptr, type*)
204
210 #define ASPOSECPP_3RD_PARTY_CONSTANT(constant_name, constant_type, constant_value) \
211 static_assert(std::is_same<decltype(constant_name), constant_type>::value || \
212 std::is_enum<decltype(constant_name)>::value && \
213 std::is_integral<constant_type>::value && \
214 sizeof(constant_type) == sizeof(decltype(constant_name)), \
215 "Wrong type " #constant_type " specified for constant " #constant_name "!"); \
216 static_assert(constant_name == constant_value, "Wrong value " #constant_value " specified for constant " #constant_name "!");
217
222 #define ASPOSECPP_3RD_PARTY_ENUM_HOLDER(enum_name, underlying, alias) \
223 class alias { \
224 static_assert(std::is_enum<enum_name>::value, #enum_name " is not a enum!"); \
225 static_assert(std::is_integral<underlying>::value && sizeof(underlying) == sizeof(enum_name) && alignof(underlying) == alignof(enum_name), \
226 "Wrong underlying type " #underlying " is specified for enum " #enum_name "!"); \
227 std::aligned_storage<sizeof(underlying), alignof(underlying)>::type m_data; \
228 public: \
229 alias(enum_name value) { *reinterpret_cast<enum_name*>(&m_data) = value; } \
230 inline alias(const alias &other) { *reinterpret_cast<enum_name*>(&m_data) = *reinterpret_cast<const enum_name*>(&other.m_data); } \
231 inline alias& operator = (const alias &other) { *reinterpret_cast<enum_name*>(&m_data) = *reinterpret_cast<const enum_name*>(&other.m_data); return *this; } \
232 operator enum_name& () { return *reinterpret_cast<enum_name*>(&m_data); } \
233 operator enum_name () const { return *reinterpret_cast<const enum_name*>(&m_data); } \
234 enum_name* operator & () { return reinterpret_cast<enum_name*>(&m_data); } \
235 const enum_name* operator & () const { return reinterpret_cast<const enum_name*>(&m_data); } \
236 };
237
245 #define ASPOSECPP_3RD_PARTY_TYPE_HOLDER(type_name, destructor_name, type_size, alignment, alias) \
246 class alias { \
247 public: \
248 typedef type_name value_type; \
249 private: \
250 static_assert(sizeof(value_type) == type_size, "Wrong size of storage generated when wrapping type " #type_name "!"); \
251 static_assert(alignof(value_type) == alignof(alignment), "Wrong alignment '" #alignment "' specified for type " #type_name "!"); \
252 std::aligned_storage<type_size, alignof(alignment)>::type m_data; \
253 public: \
254 template <typename ...Args> alias(Args&& ...args) { new (&m_data) value_type(std::forward<Args>(args)...); } \
255 alias(const alias &other) { new (&m_data) value_type(*reinterpret_cast<const value_type*>(&other.m_data)); } \
256 alias(alias&& other) noexcept { new(&m_data) value_type(std::move(*reinterpret_cast<value_type*>(&other.m_data))); }\
257 alias& operator = (const alias &other) { if (this == std::addressof(other)) { return *this; } ; *reinterpret_cast<value_type*>(&m_data) = *reinterpret_cast<const value_type*>(&other.m_data); return *this; } \
258 alias& operator = (alias&& other) noexcept { if (this == std::addressof(other)) { return *this; } ; *reinterpret_cast<value_type*>(&m_data) = std::move(*reinterpret_cast<value_type*>(&other.m_data)); return *this; } \
259 ~alias() { reinterpret_cast<value_type*>(&m_data)->~destructor_name(); } \
260 operator value_type& () { return *reinterpret_cast<value_type*>(&m_data); } \
261 operator const value_type& () const { return *reinterpret_cast<const value_type*>(&m_data); } \
262 value_type& operator * () { return *reinterpret_cast<value_type*>(&m_data); } \
263 const value_type& operator * () const { return *reinterpret_cast<const value_type*>(&m_data); } \
264 value_type* operator -> () { return reinterpret_cast<value_type*>(&m_data); } \
265 const value_type* operator -> () const { return reinterpret_cast<const value_type*>(&m_data); } \
266 value_type* operator & () { return reinterpret_cast<value_type*>(&m_data); } \
267 const value_type* operator & () const { return reinterpret_cast<const value_type*>(&m_data); } \
268 };
269
277 #define ASPOSECPP_3RD_PARTY_UNCOPYBALE_TYPE_HOLDER(type_name, destructor_name, type_size, alignment, alias) \
278 class alias { \
279 public: \
280 typedef type_name value_type; \
281 private: \
282 static_assert(sizeof(value_type) == type_size, "Wrong size of storage generated when wrapping type " #type_name "!"); \
283 static_assert(alignof(value_type) == alignof(alignment), "Wrong alignment '" #alignment "' specified for type " #type_name "!"); \
284 std::aligned_storage<type_size, alignof(alignment)>::type m_data; \
285 public: \
286 template <typename ...Args> alias(Args&& ...args) { new (&m_data) value_type(std::forward<Args>(args)...); } \
287 alias() { new (&m_data) value_type(); } \
288 alias(alias&& other) noexcept { new(&m_data) value_type(std::move(*reinterpret_cast<value_type*>(&other.m_data))); }\
289 alias& operator = (alias&& other) noexcept { if (this == std::addressof(other)) { return *this; } ; *reinterpret_cast<value_type*>(&m_data) = std::move(*reinterpret_cast<value_type*>(&other.m_data)); return *this; } \
290 ~alias() { reinterpret_cast<value_type*>(&m_data)->~destructor_name(); } \
291 operator value_type& () { return *reinterpret_cast<value_type*>(&m_data); } \
292 operator const value_type& () const { return *reinterpret_cast<const value_type*>(&m_data); } \
293 value_type& operator * () { return *reinterpret_cast<value_type*>(&m_data); } \
294 const value_type& operator * () const { return *reinterpret_cast<const value_type*>(&m_data); } \
295 value_type* operator -> () { return reinterpret_cast<value_type*>(&m_data); } \
296 const value_type* operator -> () const { return reinterpret_cast<const value_type*>(&m_data); } \
297 value_type* operator & () { return reinterpret_cast<value_type*>(&m_data); } \
298 const value_type* operator & () const { return reinterpret_cast<const value_type*>(&m_data); } \
299 };
300
302 #define ASPOSECPP_3RD_PARTY_TYPE_HOLDER_HIDDEN_TYPE(type_name, destructor_name, type_size, alignment, alias) \
303 ASPOSECPP_3RD_PARTY_TYPE_HOLDER(type_name, destructor_name, type_size, alignment, alias)
304#else
307 #define ASPOSECPP_3RD_PARTY_CLASS(type_name) class type_name;
310 #define ASPOSECPP_3RD_PARTY_STRUCT(type_name) struct type_name;
311
314 #define ASPOSECPP_3RD_PARTY_ENUM_CLASS_WITHOUT_UNDERLYING(type_name) enum class type_name;
318 #define ASPOSECPP_3RD_PARTY_ENUM_WITH_UNDERLYING(type_name, underlying) enum type_name : underlying;
319 #define ASPOSECPP_3RD_PARTY_ENUM_CLASS_WITH_UNDERLYING(type_name, underlying) enum class type_name : underlying;
322 #define ASPOSECPP_3RD_PARTY_ENUM(type_name) ASPOSECPP_3RD_PARTY_ENUM_WITH_UNDERLYING(type_name, std::underlying_type<::System::Detail::empty_enum>::type);
323 #define ASPOSECPP_3RD_PARTY_ENUM_CLASS(type_name) ASPOSECPP_3RD_PARTY_ENUM_CLASS_WITH_UNDERLYING(type_name, std::underlying_type<::System::Detail::empty_enum_class>::type);
324
328 #define ASPOSECPP_3RD_PARTY_TYPEDEF(name, type) typedef type name;
332 #define ASPOSECPP_3RD_PARTY_TYPEDEF_WITH_PTR(name, type) \
333 ASPOSECPP_3RD_PARTY_TYPEDEF(name, type) \
334 ASPOSECPP_3RD_PARTY_TYPEDEF(name##Ptr, type*)
335
340 #define ASPOSECPP_3RD_PARTY_CONSTANT(name, constant_type, value) namespace { constexpr constant_type name = value; }
341
347 #define ASPOSECPP_3RD_PARTY_ENUM_HOLDER(enum_name, underlying, alias) \
348 class alias { \
349 std::aligned_storage<sizeof(underlying), alignof(underlying)>::type m_data; \
350 public: \
351 alias(enum_name value); \
352 alias(const alias&); \
353 alias& operator = (const alias&); \
354 operator enum_name& (); \
355 operator enum_name (); \
356 enum_name* operator & (); \
357 const enum_name* operator & () const; \
358 };
359
368 #define ASPOSECPP_3RD_PARTY_TYPE_HOLDER(type_name, destructor_name, type_size, alignment, alias) \
369 class alias { \
370 std::aligned_storage<type_size, alignof(alignment)>::type m_data; \
371 public: \
372 template <typename ...Args> alias(Args&& ...args); \
373 alias(const alias&); \
374 alias(alias&& other) noexcept; \
375 alias& operator = (const alias&); \
376 alias& operator = (alias&& other) noexcept; \
377 ~alias(); \
378 operator type_name& (); \
379 operator const type_name& () const; \
380 type_name& operator * (); \
381 const type_name& operator * () const; \
382 type_name* operator -> (); \
383 const type_name* operator -> () const; \
384 type_name* operator & (); \
385 const type_name* operator & () const; \
386 };
387
395 #define ASPOSECPP_3RD_PARTY_UNCOPYBALE_TYPE_HOLDER(type_name, destructor_name, type_size, alignment, alias) \
396 class alias { \
397 std::aligned_storage<type_size, alignof(alignment)>::type m_data; \
398 public: \
399 template <typename ...Args> alias(Args&& ...args); \
400 alias(alias&& other) noexcept; \
401 alias& operator = (alias&& other) noexcept; \
402 ~alias(); \
403 operator type_name& (); \
404 operator const type_name& () const; \
405 type_name& operator * (); \
406 const type_name& operator * () const; \
407 type_name* operator -> (); \
408 const type_name* operator -> () const; \
409 type_name* operator & (); \
410 const type_name* operator & () const; \
411 };
412
421 #define ASPOSECPP_3RD_PARTY_TYPE_HOLDER_HIDDEN_TYPE(type_name, destructor_name, type_size, alignment, alias) \
422 class alias { \
423 std::aligned_storage<type_size, alignof(alignment)>::type m_data; \
424 public: \
425 template <typename ...T> alias(const T& ...args); \
426 ~alias(); \
427 };
428
429#endif
430
432template <int A, int B, int C, int D>
433struct __TypeStub
434{
435 typedef typename ::System::Detail::__InternalTypeStub<sizeof(int*), A, B, C, D>::type type;
436};
437
438
439namespace System { namespace Detail {
442 void ASPOSECPP_SHARED_API CodePortingCheckedCastAssert(bool within_bounds);
443
449 template <typename From, typename To,
450 bool canUnderflow = std::numeric_limits<From>::is_signed && ((sizeof(To) < sizeof(From)) || !std::numeric_limits<To>::is_signed),
451 bool canOverflow = (sizeof(To) < sizeof(From)) || ((sizeof(To) == sizeof(From)) && !std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed)
452 >
453 struct AssertedFitter
454 {
455 static constexpr typename std::remove_cv<typename std::remove_reference<To>::type>::type convert(From value)
456 {
457 return static_cast<typename std::remove_cv<typename std::remove_reference<To>::type>::type>(value);
458 }
459 };
465 template <typename From, typename To>
466 struct AssertedFitter<From, To, true, true>
467 {
468 static constexpr typename std::remove_cv<typename std::remove_reference<To>::type>::type convert(From value)
469 {
470 CodePortingCheckedCastAssert(value >= static_cast<typename std::remove_cv<typename std::remove_reference<From>::type>::type>((std::numeric_limits<typename std::remove_cv<typename std::remove_reference<From>::type>::type>::min)()));
471 CodePortingCheckedCastAssert(value <= static_cast<typename std::remove_cv<typename std::remove_reference<From>::type>::type>((std::numeric_limits<typename std::remove_cv<typename std::remove_reference<From>::type>::type>::max)()));
472 return static_cast<typename std::remove_cv<typename std::remove_reference<To>::type>::type>(value);
473 }
474 };
480 template <typename From, typename To>
481 struct AssertedFitter<From, To, true, false>
482 {
483 static constexpr typename std::remove_cv<typename std::remove_reference<To>::type>::type convert(From value)
484 {
485 CodePortingCheckedCastAssert(value >= static_cast<typename std::remove_cv<typename std::remove_reference<From>::type>::type>((std::numeric_limits<typename std::remove_cv<typename std::remove_reference<From>::type>::type>::min)()));
486 return static_cast<typename std::remove_cv<typename std::remove_reference<To>::type>::type>(value);
487 }
488 };
494 template <typename From, typename To>
495 struct AssertedFitter<From, To, false, true>
496 {
497 static constexpr typename std::remove_cv<typename std::remove_reference<To>::type>::type convert(From value)
498 {
499 CodePortingCheckedCastAssert(value <= static_cast<typename std::remove_cv<typename std::remove_reference<From>::type>::type>((std::numeric_limits<typename std::remove_cv<typename std::remove_reference<From>::type>::type>::max)()));
500 return static_cast<typename std::remove_cv<typename std::remove_reference<To>::type>::type>(value);
501 }
502 };
503} }
504
505#if defined(OPTIMIZE_ALL)
506 #define ASPOSECPP_NO_CHECKED_CASTS
507#endif
508
509#if !defined(ASPOSE_NO_COMPARE_BY_REF)
510 #define ASPOSE_COMPARE_BY_REF
511#elif defined (ASPOSE_COMPARE_BY_REF)
512 #undef ASPOSE_COMPARE_BY_REF
513#endif
514
515#if (defined(DEBUG) || defined(_DEBUG)) && !defined(ASPOSECPP_NO_CHECKED_CASTS)
516 #define ASPOSECPP_CHECKED_CAST(to, value) (::System::Detail::AssertedFitter<decltype(value), to>::convert(value))
517#else
518 #define ASPOSECPP_CHECKED_CAST(to, value) static_cast<to>(value)
519#endif
520
521#ifdef min
522#undef min
523#endif
524
525#ifdef max
526#undef max
527#endif
528
529#if (defined(ENABLE_CYCLES_DETECTION_EXT) || defined(__DBG_GARBAGE_COLLECTION))
530#define ASPOSE_GET_SHARED_MEMBERS
531#endif
532
533#define ASPOSE_UNUSED(arg) (void)arg;
534
535namespace System { namespace Details {
536
537// For internal purposes only
538class FastRttiBase;
539class BoxableObjectBase
540{};
541
542// Portable invocation result determination
543#ifdef __cpp_lib_is_invocable
544template <typename T, typename... Args>
545using ResultOf = typename std::invoke_result<T, Args...>::type;
546#else
547template <typename T, typename... Args>
548using ResultOf = typename std::result_of<T(Args...)>::type;
549#endif
550
551// Portable POD-type determination
552#if CODEPORTING_CPP_STANDARD >= 17
553template <typename T>
554using IsPod = typename std::bool_constant<std::is_standard_layout<T>::value && std::is_trivial<T>::value>;
555#else
556template <typename T>
557using IsPod = typename std::is_pod<T>;
558#endif
559
560#if CODEPORTING_CPP_STANDARD >= 17
561// In C++17 inheritance from std::iterator is deprecated. The easiest way is to define equivalent class.
562template <class _Category, class _Ty, class _Diff = std::ptrdiff_t, class _Pointer = _Ty*, class _Reference = _Ty&>
563struct BaseIterator
564{
565 using iterator_category = _Category;
566 using value_type = _Ty;
567 using difference_type = _Diff;
568 using pointer = _Pointer;
569 using reference = _Reference;
570};
571#else
572template <class _Category, class _Ty, class _Diff = std::ptrdiff_t, class _Pointer = _Ty*, class _Reference = _Ty&>
573using BaseIterator = std::iterator<_Category, _Ty, _Diff, _Pointer, _Reference>;
574#endif
575
576// In C++17 std::codecvt_utf8_utf16 is deprecated. The easiest way is to supress warning.
577#if CODEPORTING_CPP_STANDARD >= 17
578# ifdef __MSVC__
579# pragma warning(push)
580# pragma warning(disable : 4996)
581# else
582# pragma clang diagnostic push
583# pragma clang diagnostic ignored "-Wdeprecated-declarations"
584# endif
585#endif
586inline std::wstring Utf8ToWString(const char* utf8Str)
587{
588 return std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>, wchar_t>().from_bytes(utf8Str);
589}
590inline std::basic_string<char16_t> Utf8To16String(const char* utf8Str)
591{
592 return std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t>().from_bytes(utf8Str);
593}
594#if CODEPORTING_CPP_STANDARD >= 17
595# ifdef __MSVC__
596# pragma warning(pop)
597# else
598# pragma clang diagnostic pop
599# endif
600#endif
601
602}} // namespace System::Details
603
604#if defined __MSVC__
605// Fix for ppltasks.h being broken by global operators.
606# include <atomic>
608inline bool operator == (const std::atomic_long &lhs, int rhs)
609{
610 return lhs.load() == rhs;
611}
612# if CODEPORTING_CPP_STANDARD >= 20
613// For some reason with C++20 is on we need separate overload for long too
614inline bool operator == (const std::atomic_long &lhs, long rhs)
615{
616 return lhs.load() == rhs;
617}
618# endif
620#endif
System::Net::HttpRequestHeader::From
@ From
The 'From' header.
System
Definition: db_command.h:9