diff --git a/include/client_util.hpp b/include/client_util.hpp index 5e370d4..1df0a4a 100644 --- a/include/client_util.hpp +++ b/include/client_util.hpp @@ -4,9 +4,15 @@ #include using string_view = std::string_view; #else +#ifdef ASIO_STANDALONE +#include "string_view.hpp" +using namespace nonstd; +#else #include using string_view = boost::string_view; #endif +#endif + #include "codec.h" namespace rest_rpc { diff --git a/include/connection.h b/include/connection.h index 6392e81..f5da70a 100644 --- a/include/connection.h +++ b/include/connection.h @@ -4,15 +4,14 @@ #include #include #include -#include -#include #include "const_vars.h" #include "router.h" +#include "use_asio.hpp" using boost::asio::ip::tcp; namespace rest_rpc { namespace rpc_service { -class connection : public std::enable_shared_from_this, private boost::noncopyable { +class connection : public std::enable_shared_from_this, private asio::noncopyable { public: connection(boost::asio::io_service& io_service, std::size_t timeout_seconds) : socket_(io_service), @@ -122,7 +121,7 @@ class connection : public std::enable_shared_from_this, private boos if (timeout_seconds_ == 0) { return; } auto self(this->shared_from_this()); - timer_.expires_from_now(boost::posix_time::seconds((long)timeout_seconds_)); + timer_.expires_from_now(std::chrono::seconds(timeout_seconds_)); timer_.async_wait([this, self](const boost::system::error_code& ec) { if (has_closed()) { return; } @@ -155,7 +154,7 @@ class connection : public std::enable_shared_from_this, private boos std::string write_msg_; - boost::asio::deadline_timer timer_; + asio::steady_timer timer_; std::size_t timeout_seconds_; int64_t conn_id_ = 0; std::atomic_bool has_closed_; diff --git a/include/io_service_pool.h b/include/io_service_pool.h index 72f8b35..219430d 100644 --- a/include/io_service_pool.h +++ b/include/io_service_pool.h @@ -1,14 +1,13 @@ #ifndef REST_RPC_IO_SERVICE_POOL_H_ #define REST_RPC_IO_SERVICE_POOL_H_ -#include #include #include -#include +#include "use_asio.hpp" namespace rest_rpc { namespace rpc_service { -class io_service_pool : private boost::noncopyable { +class io_service_pool : private asio::noncopyable { public: explicit io_service_pool(std::size_t pool_size) : next_io_service_(0) { if (pool_size == 0) throw std::runtime_error("io_service_pool size is 0"); diff --git a/include/router.h b/include/router.h index 8d014b0..473fda6 100644 --- a/include/router.h +++ b/include/router.h @@ -1,8 +1,7 @@ #ifndef REST_RPC_ROUTER_H_ #define REST_RPC_ROUTER_H_ -#include -#include +#include "use_asio.hpp" #include "codec.h" #include "meta_util.hpp" @@ -12,7 +11,7 @@ enum class ExecMode { sync, async }; namespace rpc_service { class connection; -class router : boost::noncopyable { +class router : asio::noncopyable { public: static router& get() { static router instance; diff --git a/include/rpc_client.hpp b/include/rpc_client.hpp index 26a8a28..73a3d7e 100644 --- a/include/rpc_client.hpp +++ b/include/rpc_client.hpp @@ -2,11 +2,7 @@ #include #include #include -#include -#include -#include -#include -using boost::asio::ip::tcp; +#include "use_asio.hpp" #include "client_util.hpp" #include "const_vars.h" #include "meta_util.hpp" @@ -14,7 +10,6 @@ using boost::asio::ip::tcp; using namespace rest_rpc::rpc_service; namespace rest_rpc { - using namespace boost::system; class req_result { public: req_result() = default; @@ -43,7 +38,7 @@ namespace rest_rpc { const constexpr size_t DEFAULT_TIMEOUT = 1000; //milliseconds - class rpc_client : private boost::noncopyable { + class rpc_client : private asio::noncopyable { public: rpc_client() : socket_(ios_), work_(ios_), strand_(ios_), deadline_(ios_), body_(INIT_BUF_SIZE) { @@ -161,7 +156,7 @@ namespace rest_rpc { has_connected_ = false; if (socket_.is_open()) { boost::system::error_code ignored_ec; - socket_.shutdown(tcp::socket::shutdown_both, ignored_ec); + socket_.shutdown(asio::ip::tcp::socket::shutdown_both, ignored_ec); socket_.close(ignored_ec); } } @@ -251,7 +246,7 @@ namespace rest_rpc { private: using message_type = std::pair; void reset_deadline_timer(size_t timeout) { - deadline_.expires_from_now(boost::posix_time::seconds((long)timeout)); + deadline_.expires_from_now(std::chrono::seconds(timeout)); deadline_.async_wait([this](const boost::system::error_code& ec) { if (!ec) { socket_.close(); @@ -322,7 +317,7 @@ namespace rest_rpc { if (body_len == 0 || body_len > MAX_BUF_LEN) { //LOG(INFO) << "invalid body len"; close(); - call_back(req_id, boost::system::errc::make_error_code(boost::system::errc::invalid_argument), {}); + call_back(req_id, asio::error::make_error_code(asio::error::invalid_argument), {}); return; } } @@ -343,7 +338,7 @@ namespace rest_rpc { if (!socket_.is_open()) { //LOG(INFO) << "socket already closed"; - call_back(req_id, boost::system::errc::make_error_code(boost::system::errc::connection_aborted), {}); + call_back(req_id, asio::error::make_error_code(asio::error::connection_aborted), {}); return; } @@ -397,7 +392,7 @@ namespace rest_rpc { void reset_socket(){ boost::system::error_code igored_ec; - socket_.shutdown(tcp::socket::shutdown_both, igored_ec); + socket_.shutdown(asio::ip::tcp::socket::shutdown_both, igored_ec); socket_.close(igored_ec); socket_ = decltype(socket_)(ios_); if(!socket_.is_open()){ @@ -406,7 +401,7 @@ namespace rest_rpc { } boost::asio::io_service ios_; - tcp::socket socket_; + asio::ip::tcp::socket socket_; boost::asio::io_service::work work_; boost::asio::io_service::strand strand_; std::shared_ptr thd_ = nullptr; @@ -421,7 +416,7 @@ namespace rest_rpc { std::condition_variable conn_cond_; bool has_wait_ = false; - boost::asio::deadline_timer deadline_; + asio::steady_timer deadline_; std::deque outbox_; uint64_t req_id_ = 0; diff --git a/include/rpc_server.h b/include/rpc_server.h index 4570b79..71ef1b3 100644 --- a/include/rpc_server.h +++ b/include/rpc_server.h @@ -11,7 +11,7 @@ using boost::asio::ip::tcp; namespace rest_rpc { namespace rpc_service { -class rpc_server : private boost::noncopyable { +class rpc_server : private asio::noncopyable { public: rpc_server(short port, size_t size, size_t timeout_seconds = 15, size_t check_seconds = 10) : io_service_pool_(size), diff --git a/include/string_view.hpp b/include/string_view.hpp new file mode 100644 index 0000000..840599e --- /dev/null +++ b/include/string_view.hpp @@ -0,0 +1,1324 @@ +#pragma once + +#ifndef NONSTD_SV_LITE_H_INCLUDED +#define NONSTD_SV_LITE_H_INCLUDED + +#define string_view_lite_MAJOR 1 +#define string_view_lite_MINOR 2 +#define string_view_lite_PATCH 0 + +#define string_view_lite_VERSION nssv_STRINGIFY(string_view_lite_MAJOR) "." nssv_STRINGIFY(string_view_lite_MINOR) "." nssv_STRINGIFY(string_view_lite_PATCH) + +#define nssv_STRINGIFY( x ) nssv_STRINGIFY_( x ) +#define nssv_STRINGIFY_( x ) #x + +// string-view lite configuration: + +#define nssv_STRING_VIEW_DEFAULT 0 +#define nssv_STRING_VIEW_NONSTD 1 +#define nssv_STRING_VIEW_STD 2 + +#if !defined( nssv_CONFIG_SELECT_STRING_VIEW ) +# define nssv_CONFIG_SELECT_STRING_VIEW ( nssv_HAVE_STD_STRING_VIEW ? nssv_STRING_VIEW_STD : nssv_STRING_VIEW_NONSTD ) +#endif + +#if defined( nssv_CONFIG_SELECT_STD_STRING_VIEW ) || defined( nssv_CONFIG_SELECT_NONSTD_STRING_VIEW ) +# error nssv_CONFIG_SELECT_STD_STRING_VIEW and nssv_CONFIG_SELECT_NONSTD_STRING_VIEW are deprecated and removed, please use nssv_CONFIG_SELECT_STRING_VIEW=nssv_STRING_VIEW_... +#endif + +#ifndef nssv_CONFIG_STD_SV_OPERATOR +# define nssv_CONFIG_STD_SV_OPERATOR 0 +#endif + +#ifndef nssv_CONFIG_USR_SV_OPERATOR +# define nssv_CONFIG_USR_SV_OPERATOR 1 +#endif + +#ifdef nssv_CONFIG_CONVERSION_STD_STRING +# define nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS nssv_CONFIG_CONVERSION_STD_STRING +# define nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS nssv_CONFIG_CONVERSION_STD_STRING +#endif + +#ifndef nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS +# define nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS 1 +#endif + +#ifndef nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS +# define nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS 1 +#endif + +// Control presence of exception handling (try and auto discover): + +#ifndef nssv_CONFIG_NO_EXCEPTIONS +# if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND) +# define nssv_CONFIG_NO_EXCEPTIONS 0 +# else +# define nssv_CONFIG_NO_EXCEPTIONS 1 +# endif +#endif + +// C++ language version detection (C++20 is speculative): +// Note: VC14.0/1900 (VS2015) lacks too much from C++14. + +#ifndef nssv_CPLUSPLUS +# if defined(_MSVC_LANG ) && !defined(__clang__) +# define nssv_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG ) +# else +# define nssv_CPLUSPLUS __cplusplus +# endif +#endif + +#define nssv_CPP98_OR_GREATER ( nssv_CPLUSPLUS >= 199711L ) +#define nssv_CPP11_OR_GREATER ( nssv_CPLUSPLUS >= 201103L ) +#define nssv_CPP11_OR_GREATER_ ( nssv_CPLUSPLUS >= 201103L ) +#define nssv_CPP14_OR_GREATER ( nssv_CPLUSPLUS >= 201402L ) +#define nssv_CPP17_OR_GREATER ( nssv_CPLUSPLUS >= 201703L ) +#define nssv_CPP20_OR_GREATER ( nssv_CPLUSPLUS >= 202000L ) + +// use C++17 std::string_view if available and requested: + +#if nssv_CPP17_OR_GREATER && defined(__has_include ) +# if __has_include( ) +# define nssv_HAVE_STD_STRING_VIEW 1 +# else +# define nssv_HAVE_STD_STRING_VIEW 0 +# endif +#else +# define nssv_HAVE_STD_STRING_VIEW 0 +#endif + +#define nssv_USES_STD_STRING_VIEW ( (nssv_CONFIG_SELECT_STRING_VIEW == nssv_STRING_VIEW_STD) || ((nssv_CONFIG_SELECT_STRING_VIEW == nssv_STRING_VIEW_DEFAULT) && nssv_HAVE_STD_STRING_VIEW) ) + +#define nssv_HAVE_STARTS_WITH ( nssv_CPP20_OR_GREATER || !nssv_USES_STD_STRING_VIEW ) +#define nssv_HAVE_ENDS_WITH nssv_HAVE_STARTS_WITH + +// +// Use C++17 std::string_view: +// + +#if nssv_USES_STD_STRING_VIEW + +#include + +// Extensions for std::string: + +#if nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS + +namespace nonstd { + + template< class CharT, class Traits, class Allocator = std::allocator > + std::basic_string + to_string(std::basic_string_view v, Allocator const& a = Allocator()) { + return std::basic_string(v.begin(), v.end(), a); + } + + template< class CharT, class Traits, class Allocator > + std::basic_string_view + to_string_view(std::basic_string const& s) { + return std::basic_string_view(s.data(), s.size()); + } + + // Literal operators sv and _sv: + +#if nssv_CONFIG_STD_SV_OPERATOR + + using namespace std::literals::string_view_literals; + +#endif + +#if nssv_CONFIG_USR_SV_OPERATOR + + inline namespace literals { + inline namespace string_view_literals { + + + constexpr std::string_view operator "" _sv(const char* str, size_t len) noexcept // (1) + { + return std::string_view{ str, len }; + } + + constexpr std::u16string_view operator "" _sv(const char16_t* str, size_t len) noexcept // (2) + { + return std::u16string_view{ str, len }; + } + + constexpr std::u32string_view operator "" _sv(const char32_t* str, size_t len) noexcept // (3) + { + return std::u32string_view{ str, len }; + } + + constexpr std::wstring_view operator "" _sv(const wchar_t* str, size_t len) noexcept // (4) + { + return std::wstring_view{ str, len }; + } + + } + } // namespace literals::string_view_literals + +#endif // nssv_CONFIG_USR_SV_OPERATOR + +} // namespace nonstd + +#endif // nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS + +namespace nonstd { + + using std::string_view; + using std::wstring_view; + using std::u16string_view; + using std::u32string_view; + using std::basic_string_view; + + // literal "sv" and "_sv", see above + + using std::operator==; + using std::operator!=; + using std::operator<; + using std::operator<=; + using std::operator>; + using std::operator>=; + + using std::operator<<; + +} // namespace nonstd + +#else // nssv_HAVE_STD_STRING_VIEW + +// +// Before C++17: use string_view lite: +// + +// Compiler versions: +// +// MSVC++ 6.0 _MSC_VER == 1200 (Visual Studio 6.0) +// MSVC++ 7.0 _MSC_VER == 1300 (Visual Studio .NET 2002) +// MSVC++ 7.1 _MSC_VER == 1310 (Visual Studio .NET 2003) +// MSVC++ 8.0 _MSC_VER == 1400 (Visual Studio 2005) +// MSVC++ 9.0 _MSC_VER == 1500 (Visual Studio 2008) +// MSVC++ 10.0 _MSC_VER == 1600 (Visual Studio 2010) +// MSVC++ 11.0 _MSC_VER == 1700 (Visual Studio 2012) +// MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013) +// MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015) +// MSVC++ 14.1 _MSC_VER >= 1910 (Visual Studio 2017) + +#if defined(_MSC_VER ) && !defined(__clang__) +# define nssv_COMPILER_MSVC_VER (_MSC_VER ) +# define nssv_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * ( 5 + (_MSC_VER < 1900 ) ) ) +#else +# define nssv_COMPILER_MSVC_VER 0 +# define nssv_COMPILER_MSVC_VERSION 0 +#endif + +#define nssv_COMPILER_VERSION( major, minor, patch ) ( 10 * ( 10 * (major) + (minor) ) + (patch) ) + +#if defined(__clang__) +# define nssv_COMPILER_CLANG_VERSION nssv_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__) +#else +# define nssv_COMPILER_CLANG_VERSION 0 +#endif + +#if defined(__GNUC__) && !defined(__clang__) +# define nssv_COMPILER_GNUC_VERSION nssv_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) +#else +# define nssv_COMPILER_GNUC_VERSION 0 +#endif + +// half-open range [lo..hi): +#define nssv_BETWEEN( v, lo, hi ) ( (lo) <= (v) && (v) < (hi) ) + +// Presence of language and library features: + +#ifdef _HAS_CPP0X +# define nssv_HAS_CPP0X _HAS_CPP0X +#else +# define nssv_HAS_CPP0X 0 +#endif + +// Unless defined otherwise below, consider VC14 as C++11 for variant-lite: + +#if nssv_COMPILER_MSVC_VER >= 1900 +# undef nssv_CPP11_OR_GREATER +# define nssv_CPP11_OR_GREATER 1 +#endif + +#define nssv_CPP11_90 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1500) +#define nssv_CPP11_100 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1600) +#define nssv_CPP11_110 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1700) +#define nssv_CPP11_120 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1800) +#define nssv_CPP11_140 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1900) +#define nssv_CPP11_141 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1910) + +#define nssv_CPP14_000 (nssv_CPP14_OR_GREATER) +#define nssv_CPP17_000 (nssv_CPP17_OR_GREATER) + +// Presence of C++11 language features: + +#define nssv_HAVE_CONSTEXPR_11 nssv_CPP11_140 +#define nssv_HAVE_EXPLICIT_CONVERSION nssv_CPP11_140 +#define nssv_HAVE_INLINE_NAMESPACE nssv_CPP11_140 +#define nssv_HAVE_NOEXCEPT nssv_CPP11_140 +#define nssv_HAVE_NULLPTR nssv_CPP11_100 +#define nssv_HAVE_REF_QUALIFIER nssv_CPP11_140 +#define nssv_HAVE_UNICODE_LITERALS nssv_CPP11_140 +#define nssv_HAVE_USER_DEFINED_LITERALS nssv_CPP11_140 +#define nssv_HAVE_WCHAR16_T nssv_CPP11_100 +#define nssv_HAVE_WCHAR32_T nssv_CPP11_100 + +#if ! ( ( nssv_CPP11_OR_GREATER && nssv_COMPILER_CLANG_VERSION ) || nssv_BETWEEN( nssv_COMPILER_CLANG_VERSION, 300, 400 ) ) +# define nssv_HAVE_STD_DEFINED_LITERALS nssv_CPP11_140 +#else +# define nssv_HAVE_STD_DEFINED_LITERALS 0 +#endif + +// Presence of C++14 language features: + +#define nssv_HAVE_CONSTEXPR_14 nssv_CPP14_000 + +// Presence of C++17 language features: + +#define nssv_HAVE_NODISCARD nssv_CPP17_000 + +// Presence of C++ library features: + +#define nssv_HAVE_STD_HASH nssv_CPP11_120 + +// C++ feature usage: + +#if nssv_HAVE_CONSTEXPR_11 +# define nssv_constexpr constexpr +#else +# define nssv_constexpr /*constexpr*/ +#endif + +#if nssv_HAVE_CONSTEXPR_14 +# define nssv_constexpr14 constexpr +#else +# define nssv_constexpr14 /*constexpr*/ +#endif + +#if nssv_HAVE_EXPLICIT_CONVERSION +# define nssv_explicit explicit +#else +# define nssv_explicit /*explicit*/ +#endif + +#if nssv_HAVE_INLINE_NAMESPACE +# define nssv_inline_ns inline +#else +# define nssv_inline_ns /*inline*/ +#endif + +#if nssv_HAVE_NOEXCEPT +# define nssv_noexcept noexcept +#else +# define nssv_noexcept /*noexcept*/ +#endif + +//#if nssv_HAVE_REF_QUALIFIER +//# define nssv_ref_qual & +//# define nssv_refref_qual && +//#else +//# define nssv_ref_qual /*&*/ +//# define nssv_refref_qual /*&&*/ +//#endif + +#if nssv_HAVE_NULLPTR +# define nssv_nullptr nullptr +#else +# define nssv_nullptr NULL +#endif + +#if nssv_HAVE_NODISCARD +# define nssv_nodiscard [[nodiscard]] +#else +# define nssv_nodiscard /*[[nodiscard]]*/ +#endif + +// Additional includes: + +#include +#include +#include +#include +#include +#include // std::char_traits<> + +#if ! nssv_CONFIG_NO_EXCEPTIONS +# include +#endif + +#if nssv_CPP11_OR_GREATER +# include +#endif + +// Clang, GNUC, MSVC warning suppression macros: + +#if defined(__clang__) +# pragma clang diagnostic ignored "-Wreserved-user-defined-literal" +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wuser-defined-literals" +#elif defined(__GNUC__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wliteral-suffix" +#endif // __clang__ + +#if nssv_COMPILER_MSVC_VERSION >= 140 +# define nssv_SUPPRESS_MSGSL_WARNING(expr) [[gsl::suppress(expr)]] +# define nssv_SUPPRESS_MSVC_WARNING(code, descr) __pragma(warning(suppress: code) ) +# define nssv_DISABLE_MSVC_WARNINGS(codes) __pragma(warning(push)) __pragma(warning(disable: codes)) +#else +# define nssv_SUPPRESS_MSGSL_WARNING(expr) +# define nssv_SUPPRESS_MSVC_WARNING(code, descr) +# define nssv_DISABLE_MSVC_WARNINGS(codes) +#endif + +#if defined(__clang__) +# define nssv_RESTORE_WARNINGS() _Pragma("clang diagnostic pop") +#elif defined(__GNUC__) +# define nssv_RESTORE_WARNINGS() _Pragma("GCC diagnostic pop") +#elif nssv_COMPILER_MSVC_VERSION >= 140 +# define nssv_RESTORE_WARNINGS() __pragma(warning(pop )) +#else +# define nssv_RESTORE_WARNINGS() +#endif + +// Suppress the following MSVC (GSL) warnings: +// - C4455, non-gsl : 'operator ""sv': literal suffix identifiers that do not +// start with an underscore are reserved +// - C26472, gsl::t.1 : don't use a static_cast for arithmetic conversions; +// use brace initialization, gsl::narrow_cast or gsl::narow +// - C26481: gsl::b.1 : don't use pointer arithmetic. Use span instead + +nssv_DISABLE_MSVC_WARNINGS(4455 26481 26472) +//nssv_DISABLE_CLANG_WARNINGS( "-Wuser-defined-literals" ) +//nssv_DISABLE_GNUC_WARNINGS( -Wliteral-suffix ) + +namespace nonstd { + namespace sv_lite { + +#if nssv_CPP11_OR_GREATER + + namespace detail { + + // Expect tail call optimization to make length() non-recursive: + + template< typename CharT > + inline constexpr std::size_t length(CharT* s, std::size_t result = 0) { + return *s == '\0' ? result : length(s + 1, result + 1); + } + + } // namespace detail + +#endif // nssv_CPP11_OR_GREATER + + template + < + class CharT, + class Traits = std::char_traits + > + class basic_string_view; + + // + // basic_string_view: + // + + template + < + class CharT, + class Traits /* = std::char_traits */ + > + class basic_string_view { + public: + // Member types: + + typedef Traits traits_type; + typedef CharT value_type; + + typedef CharT* pointer; + typedef CharT const* const_pointer; + typedef CharT& reference; + typedef CharT const& const_reference; + + typedef const_pointer iterator; + typedef const_pointer const_iterator; + typedef std::reverse_iterator< const_iterator > reverse_iterator; + typedef std::reverse_iterator< const_iterator > const_reverse_iterator; + + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + // 24.4.2.1 Construction and assignment: + + nssv_constexpr basic_string_view() nssv_noexcept + : data_(nssv_nullptr) + , size_(0) { + } + +#if nssv_CPP11_OR_GREATER + nssv_constexpr basic_string_view(basic_string_view const& other) nssv_noexcept = default; +#else + nssv_constexpr basic_string_view(basic_string_view const& other) nssv_noexcept + : data_(other.data_) + , size_(other.size_) { + } +#endif + + nssv_constexpr basic_string_view(CharT const* s, size_type count) nssv_noexcept // non-standard noexcept + : data_(s) + , size_(count) { + } + + nssv_constexpr basic_string_view(CharT const* s) nssv_noexcept // non-standard noexcept + : data_(s) +#if nssv_CPP17_OR_GREATER + , size_(Traits::length(s)) +#elif nssv_CPP11_OR_GREATER + , size_(detail::length(s)) +#else + , size_(Traits::length(s)) +#endif + { + } + + // Assignment: + +#if nssv_CPP11_OR_GREATER + nssv_constexpr14 basic_string_view& operator=(basic_string_view const& other) nssv_noexcept = default; +#else + nssv_constexpr14 basic_string_view& operator=(basic_string_view const& other) nssv_noexcept { + data_ = other.data_; + size_ = other.size_; + return *this; + } +#endif + + // 24.4.2.2 Iterator support: + + nssv_constexpr const_iterator begin() const nssv_noexcept { return data_; } + nssv_constexpr const_iterator end() const nssv_noexcept { return data_ + size_; } + + nssv_constexpr const_iterator cbegin() const nssv_noexcept { return begin(); } + nssv_constexpr const_iterator cend() const nssv_noexcept { return end(); } + + nssv_constexpr const_reverse_iterator rbegin() const nssv_noexcept { return const_reverse_iterator(end()); } + nssv_constexpr const_reverse_iterator rend() const nssv_noexcept { return const_reverse_iterator(begin()); } + + nssv_constexpr const_reverse_iterator crbegin() const nssv_noexcept { return rbegin(); } + nssv_constexpr const_reverse_iterator crend() const nssv_noexcept { return rend(); } + + // 24.4.2.3 Capacity: + + nssv_constexpr size_type size() const nssv_noexcept { return size_; } + nssv_constexpr size_type length() const nssv_noexcept { return size_; } + nssv_constexpr size_type max_size() const nssv_noexcept { return (std::numeric_limits< size_type >::max)(); } + + // since C++20 + nssv_nodiscard nssv_constexpr bool empty() const nssv_noexcept { + return 0 == size_; + } + + // 24.4.2.4 Element access: + + nssv_constexpr const_reference operator[](size_type pos) const { + return data_at(pos); + } + + nssv_constexpr14 const_reference at(size_type pos) const { +#if nssv_CONFIG_NO_EXCEPTIONS + assert(pos < size()); +#else + if (pos >= size()) { + throw std::out_of_range("nonstd::string_view::at()"); + } +#endif + return data_at(pos); + } + + nssv_constexpr const_reference front() const { return data_at(0); } + nssv_constexpr const_reference back() const { return data_at(size() - 1); } + + nssv_constexpr const_pointer data() const nssv_noexcept { return data_; } + + // 24.4.2.5 Modifiers: + + nssv_constexpr14 void remove_prefix(size_type n) { + assert(n <= size()); + data_ += n; + size_ -= n; + } + + nssv_constexpr14 void remove_suffix(size_type n) { + assert(n <= size()); + size_ -= n; + } + + nssv_constexpr14 void swap(basic_string_view & other) nssv_noexcept { + using std::swap; + swap(data_, other.data_); + swap(size_, other.size_); + } + + // 24.4.2.6 String operations: + + size_type copy(CharT * dest, size_type n, size_type pos = 0) const { +#if nssv_CONFIG_NO_EXCEPTIONS + assert(pos <= size()); +#else + if (pos > size()) { + throw std::out_of_range("nonstd::string_view::copy()"); + } +#endif + const size_type rlen = (std::min)(n, size() - pos); + + (void)Traits::copy(dest, data() + pos, rlen); + + return rlen; + } + + nssv_constexpr14 basic_string_view substr(size_type pos = 0, size_type n = npos) const { +#if nssv_CONFIG_NO_EXCEPTIONS + assert(pos <= size()); +#else + if (pos > size()) { + throw std::out_of_range("nonstd::string_view::substr()"); + } +#endif + return basic_string_view(data() + pos, (std::min)(n, size() - pos)); + } + + // compare(), 6x: + + nssv_constexpr14 int compare(basic_string_view other) const nssv_noexcept // (1) + { + if (const int result = Traits::compare(data(), other.data(), (std::min)(size(), other.size()))) { + return result; + } + + return size() == other.size() ? 0 : size() < other.size() ? -1 : 1; + } + + nssv_constexpr int compare(size_type pos1, size_type n1, basic_string_view other) const // (2) + { + return substr(pos1, n1).compare(other); + } + + nssv_constexpr int compare(size_type pos1, size_type n1, basic_string_view other, size_type pos2, size_type n2) const // (3) + { + return substr(pos1, n1).compare(other.substr(pos2, n2)); + } + + nssv_constexpr int compare(CharT const* s) const // (4) + { + return compare(basic_string_view(s)); + } + + nssv_constexpr int compare(size_type pos1, size_type n1, CharT const* s) const // (5) + { + return substr(pos1, n1).compare(basic_string_view(s)); + } + + nssv_constexpr int compare(size_type pos1, size_type n1, CharT const* s, size_type n2) const // (6) + { + return substr(pos1, n1).compare(basic_string_view(s, n2)); + } + + // 24.4.2.7 Searching: + + // starts_with(), 3x, since C++20: + + nssv_constexpr bool starts_with(basic_string_view v) const nssv_noexcept // (1) + { + return size() >= v.size() && compare(0, v.size(), v) == 0; + } + + nssv_constexpr bool starts_with(CharT c) const nssv_noexcept // (2) + { + return starts_with(basic_string_view(&c, 1)); + } + + nssv_constexpr bool starts_with(CharT const* s) const // (3) + { + return starts_with(basic_string_view(s)); + } + + // ends_with(), 3x, since C++20: + + nssv_constexpr bool ends_with(basic_string_view v) const nssv_noexcept // (1) + { + return size() >= v.size() && compare(size() - v.size(), npos, v) == 0; + } + + nssv_constexpr bool ends_with(CharT c) const nssv_noexcept // (2) + { + return ends_with(basic_string_view(&c, 1)); + } + + nssv_constexpr bool ends_with(CharT const* s) const // (3) + { + return ends_with(basic_string_view(s)); + } + + // find(), 4x: + + nssv_constexpr14 size_type find(basic_string_view v, size_type pos = 0) const nssv_noexcept // (1) + { + return assert(v.size() == 0 || v.data() != nssv_nullptr) + , pos >= size() + ? npos + : to_pos(std::search(cbegin() + pos, cend(), v.cbegin(), v.cend(), Traits::eq)); + } + + nssv_constexpr14 size_type find(CharT c, size_type pos = 0) const nssv_noexcept // (2) + { + return find(basic_string_view(&c, 1), pos); + } + + nssv_constexpr14 size_type find(CharT const* s, size_type pos, size_type n) const // (3) + { + return find(basic_string_view(s, n), pos); + } + + nssv_constexpr14 size_type find(CharT const* s, size_type pos = 0) const // (4) + { + return find(basic_string_view(s), pos); + } + + // rfind(), 4x: + + nssv_constexpr14 size_type rfind(basic_string_view v, size_type pos = npos) const nssv_noexcept // (1) + { + if (size() < v.size()) { + return npos; + } + + if (v.empty()) { + return (std::min)(size(), pos); + } + + const_iterator last = cbegin() + (std::min)(size() - v.size(), pos) + v.size(); + const_iterator result = std::find_end(cbegin(), last, v.cbegin(), v.cend(), Traits::eq); + + return result != last ? size_type(result - cbegin()) : npos; + } + + nssv_constexpr14 size_type rfind(CharT c, size_type pos = npos) const nssv_noexcept // (2) + { + return rfind(basic_string_view(&c, 1), pos); + } + + nssv_constexpr14 size_type rfind(CharT const* s, size_type pos, size_type n) const // (3) + { + return rfind(basic_string_view(s, n), pos); + } + + nssv_constexpr14 size_type rfind(CharT const* s, size_type pos = npos) const // (4) + { + return rfind(basic_string_view(s), pos); + } + + // find_first_of(), 4x: + + nssv_constexpr size_type find_first_of(basic_string_view v, size_type pos = 0) const nssv_noexcept // (1) + { + return pos >= size() + ? npos + : to_pos(std::find_first_of(cbegin() + pos, cend(), v.cbegin(), v.cend(), Traits::eq)); + } + + nssv_constexpr size_type find_first_of(CharT c, size_type pos = 0) const nssv_noexcept // (2) + { + return find_first_of(basic_string_view(&c, 1), pos); + } + + nssv_constexpr size_type find_first_of(CharT const* s, size_type pos, size_type n) const // (3) + { + return find_first_of(basic_string_view(s, n), pos); + } + + nssv_constexpr size_type find_first_of(CharT const* s, size_type pos = 0) const // (4) + { + return find_first_of(basic_string_view(s), pos); + } + + // find_last_of(), 4x: + + nssv_constexpr size_type find_last_of(basic_string_view v, size_type pos = npos) const nssv_noexcept // (1) + { + return empty() + ? npos + : pos >= size() + ? find_last_of(v, size() - 1) + : to_pos(std::find_first_of(const_reverse_iterator(cbegin() + pos + 1), crend(), v.cbegin(), v.cend(), Traits::eq)); + } + + nssv_constexpr size_type find_last_of(CharT c, size_type pos = npos) const nssv_noexcept // (2) + { + return find_last_of(basic_string_view(&c, 1), pos); + } + + nssv_constexpr size_type find_last_of(CharT const* s, size_type pos, size_type count) const // (3) + { + return find_last_of(basic_string_view(s, count), pos); + } + + nssv_constexpr size_type find_last_of(CharT const* s, size_type pos = npos) const // (4) + { + return find_last_of(basic_string_view(s), pos); + } + + // find_first_not_of(), 4x: + + nssv_constexpr size_type find_first_not_of(basic_string_view v, size_type pos = 0) const nssv_noexcept // (1) + { + return pos >= size() + ? npos + : to_pos(std::find_if(cbegin() + pos, cend(), not_in_view(v))); + } + + nssv_constexpr size_type find_first_not_of(CharT c, size_type pos = 0) const nssv_noexcept // (2) + { + return find_first_not_of(basic_string_view(&c, 1), pos); + } + + nssv_constexpr size_type find_first_not_of(CharT const* s, size_type pos, size_type count) const // (3) + { + return find_first_not_of(basic_string_view(s, count), pos); + } + + nssv_constexpr size_type find_first_not_of(CharT const* s, size_type pos = 0) const // (4) + { + return find_first_not_of(basic_string_view(s), pos); + } + + // find_last_not_of(), 4x: + + nssv_constexpr size_type find_last_not_of(basic_string_view v, size_type pos = npos) const nssv_noexcept // (1) + { + return empty() + ? npos + : pos >= size() + ? find_last_not_of(v, size() - 1) + : to_pos(std::find_if(const_reverse_iterator(cbegin() + pos + 1), crend(), not_in_view(v))); + } + + nssv_constexpr size_type find_last_not_of(CharT c, size_type pos = npos) const nssv_noexcept // (2) + { + return find_last_not_of(basic_string_view(&c, 1), pos); + } + + nssv_constexpr size_type find_last_not_of(CharT const* s, size_type pos, size_type count) const // (3) + { + return find_last_not_of(basic_string_view(s, count), pos); + } + + nssv_constexpr size_type find_last_not_of(CharT const* s, size_type pos = npos) const // (4) + { + return find_last_not_of(basic_string_view(s), pos); + } + + // Constants: + +#if nssv_CPP17_OR_GREATER + static nssv_constexpr size_type npos = size_type(-1); +#elif nssv_CPP11_OR_GREATER + enum : size_type { npos = size_type(-1) }; +#else + enum { npos = size_type(-1) }; +#endif + + private: + struct not_in_view { + const basic_string_view v; + + nssv_constexpr explicit not_in_view(basic_string_view v) : v(v) {} + + nssv_constexpr bool operator()(CharT c) const { + return npos == v.find_first_of(c); + } + }; + + nssv_constexpr size_type to_pos(const_iterator it) const { + return it == cend() ? npos : size_type(it - cbegin()); + } + + nssv_constexpr size_type to_pos(const_reverse_iterator it) const { + return it == crend() ? npos : size_type(crend() - it - 1); + } + + nssv_constexpr const_reference data_at(size_type pos) const { +#if nssv_BETWEEN( nssv_COMPILER_GNUC_VERSION, 1, 500 ) + return data_[pos]; +#else + return assert(pos < size()), data_[pos]; +#endif + } + + private: + const_pointer data_; + size_type size_; + + public: +#if nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS + + template< class Allocator > + basic_string_view(std::basic_string const& s) nssv_noexcept + : data_(s.data()) + , size_(s.size()) { + } + +#if nssv_HAVE_EXPLICIT_CONVERSION + + template< class Allocator > + explicit operator std::basic_string() const { + return to_string(Allocator()); + } + +#endif // nssv_HAVE_EXPLICIT_CONVERSION + +#if nssv_CPP11_OR_GREATER + + template< class Allocator = std::allocator > + std::basic_string + to_string(Allocator const& a = Allocator()) const { + return std::basic_string(begin(), end(), a); + } + +#else + + std::basic_string + to_string() const { + return std::basic_string(begin(), end()); + } + + template< class Allocator > + std::basic_string + to_string(Allocator const& a) const { + return std::basic_string(begin(), end(), a); + } + +#endif // nssv_CPP11_OR_GREATER + +#endif // nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS + }; + + // + // Non-member functions: + // + + // 24.4.3 Non-member comparison functions: + // lexicographically compare two string views (function template): + + template< class CharT, class Traits > + nssv_constexpr bool operator== ( + basic_string_view lhs, + basic_string_view rhs) nssv_noexcept { + return lhs.compare(rhs) == 0; + } + + template< class CharT, class Traits > + nssv_constexpr bool operator!= ( + basic_string_view lhs, + basic_string_view rhs) nssv_noexcept { + return lhs.compare(rhs) != 0; + } + + template< class CharT, class Traits > + nssv_constexpr bool operator< ( + basic_string_view lhs, + basic_string_view rhs) nssv_noexcept { + return lhs.compare(rhs) < 0; + } + + template< class CharT, class Traits > + nssv_constexpr bool operator<= ( + basic_string_view lhs, + basic_string_view rhs) nssv_noexcept { + return lhs.compare(rhs) <= 0; + } + + template< class CharT, class Traits > + nssv_constexpr bool operator> ( + basic_string_view lhs, + basic_string_view rhs) nssv_noexcept { + return lhs.compare(rhs) > 0; + } + + template< class CharT, class Traits > + nssv_constexpr bool operator>= ( + basic_string_view lhs, + basic_string_view rhs) nssv_noexcept { + return lhs.compare(rhs) >= 0; + } + + // Let S be basic_string_view, and sv be an instance of S. + // Implementations shall provide sufficient additional overloads marked + // constexpr and noexcept so that an object t with an implicit conversion + // to S can be compared according to Table 67. + +#if nssv_CPP11_OR_GREATER && ! nssv_BETWEEN( nssv_COMPILER_MSVC_VERSION, 100, 141 ) + +#define nssv_BASIC_STRING_VIEW_I(T,U) typename std::decay< basic_string_view >::type + +#if nssv_BETWEEN( nssv_COMPILER_MSVC_VERSION, 140, 150 ) +# define nssv_MSVC_ORDER(x) , int=x +#else +# define nssv_MSVC_ORDER(x) /*, int=x*/ +#endif + +// == + + template< class CharT, class Traits nssv_MSVC_ORDER(1) > + nssv_constexpr bool operator==( + basic_string_view lhs, + nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept { + return lhs.compare(rhs) == 0; + } + + template< class CharT, class Traits nssv_MSVC_ORDER(2) > + nssv_constexpr bool operator==( + nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, + basic_string_view rhs) nssv_noexcept { + return lhs.size() == rhs.size() && lhs.compare(rhs) == 0; + } + + // != + + template< class CharT, class Traits nssv_MSVC_ORDER(1) > + nssv_constexpr bool operator!= ( + basic_string_view < CharT, Traits > lhs, + nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept { + return lhs.size() != rhs.size() || lhs.compare(rhs) != 0; + } + + template< class CharT, class Traits nssv_MSVC_ORDER(2) > + nssv_constexpr bool operator!= ( + nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, + basic_string_view < CharT, Traits > rhs) nssv_noexcept { + return lhs.compare(rhs) != 0; + } + + // < + + template< class CharT, class Traits nssv_MSVC_ORDER(1) > + nssv_constexpr bool operator< ( + basic_string_view < CharT, Traits > lhs, + nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept { + return lhs.compare(rhs) < 0; + } + + template< class CharT, class Traits nssv_MSVC_ORDER(2) > + nssv_constexpr bool operator< ( + nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, + basic_string_view < CharT, Traits > rhs) nssv_noexcept { + return lhs.compare(rhs) < 0; + } + + // <= + + template< class CharT, class Traits nssv_MSVC_ORDER(1) > + nssv_constexpr bool operator<= ( + basic_string_view < CharT, Traits > lhs, + nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept { + return lhs.compare(rhs) <= 0; + } + + template< class CharT, class Traits nssv_MSVC_ORDER(2) > + nssv_constexpr bool operator<= ( + nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, + basic_string_view < CharT, Traits > rhs) nssv_noexcept { + return lhs.compare(rhs) <= 0; + } + + // > + + template< class CharT, class Traits nssv_MSVC_ORDER(1) > + nssv_constexpr bool operator> ( + basic_string_view < CharT, Traits > lhs, + nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept { + return lhs.compare(rhs) > 0; + } + + template< class CharT, class Traits nssv_MSVC_ORDER(2) > + nssv_constexpr bool operator> ( + nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, + basic_string_view < CharT, Traits > rhs) nssv_noexcept { + return lhs.compare(rhs) > 0; + } + + // >= + + template< class CharT, class Traits nssv_MSVC_ORDER(1) > + nssv_constexpr bool operator>= ( + basic_string_view < CharT, Traits > lhs, + nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept { + return lhs.compare(rhs) >= 0; + } + + template< class CharT, class Traits nssv_MSVC_ORDER(2) > + nssv_constexpr bool operator>= ( + nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, + basic_string_view < CharT, Traits > rhs) nssv_noexcept { + return lhs.compare(rhs) >= 0; + } + +#undef nssv_MSVC_ORDER +#undef nssv_BASIC_STRING_VIEW_I + +#endif // nssv_CPP11_OR_GREATER + + // 24.4.4 Inserters and extractors: + + namespace detail { + + template< class Stream > + void write_padding(Stream& os, std::streamsize n) { + for (std::streamsize i = 0; i < n; ++i) + os.rdbuf()->sputc(os.fill()); + } + + template< class Stream, class View > + Stream& write_to_stream(Stream & os, View const& sv) { + typename Stream::sentry sentry(os); + + if (!os) + return os; + + const std::streamsize length = static_cast(sv.length()); + + // Whether, and how, to pad: + const bool pad = (length < os.width()); + const bool left_pad = pad && (os.flags() & std::ios_base::adjustfield) == std::ios_base::right; + + if (left_pad) + write_padding(os, os.width() - length); + + // Write span characters: + os.rdbuf()->sputn(sv.begin(), length); + + if (pad && !left_pad) + write_padding(os, os.width() - length); + + // Reset output stream width: + os.width(0); + + return os; + } + + } // namespace detail + + template< class CharT, class Traits > + std::basic_ostream& + operator<<( + std::basic_ostream & os, + basic_string_view sv) { + return detail::write_to_stream(os, sv); + } + + // Several typedefs for common character types are provided: + + typedef basic_string_view string_view; + typedef basic_string_view wstring_view; +#if nssv_HAVE_WCHAR16_T + typedef basic_string_view u16string_view; + typedef basic_string_view u32string_view; +#endif + + } +} // namespace nonstd::sv_lite + +// +// 24.4.6 Suffix for basic_string_view literals: +// + +#if nssv_HAVE_USER_DEFINED_LITERALS + +namespace nonstd { + nssv_inline_ns namespace literals { + nssv_inline_ns namespace string_view_literals { + +#if nssv_CONFIG_STD_SV_OPERATOR && nssv_HAVE_STD_DEFINED_LITERALS + + nssv_constexpr nonstd::sv_lite::string_view operator "" sv(const char* str, size_t len) nssv_noexcept // (1) + { + return nonstd::sv_lite::string_view{ str, len }; + } + + nssv_constexpr nonstd::sv_lite::u16string_view operator "" sv(const char16_t* str, size_t len) nssv_noexcept // (2) + { + return nonstd::sv_lite::u16string_view{ str, len }; + } + + nssv_constexpr nonstd::sv_lite::u32string_view operator "" sv(const char32_t* str, size_t len) nssv_noexcept // (3) + { + return nonstd::sv_lite::u32string_view{ str, len }; + } + + nssv_constexpr nonstd::sv_lite::wstring_view operator "" sv(const wchar_t* str, size_t len) nssv_noexcept // (4) + { + return nonstd::sv_lite::wstring_view{ str, len }; + } + +#endif // nssv_CONFIG_STD_SV_OPERATOR && nssv_HAVE_STD_DEFINED_LITERALS + +#if nssv_CONFIG_USR_SV_OPERATOR + + nssv_constexpr nonstd::sv_lite::string_view operator "" _sv(const char* str, size_t len) nssv_noexcept // (1) + { + return nonstd::sv_lite::string_view{ str, len }; + } + + nssv_constexpr nonstd::sv_lite::u16string_view operator "" _sv(const char16_t* str, size_t len) nssv_noexcept // (2) + { + return nonstd::sv_lite::u16string_view{ str, len }; + } + + nssv_constexpr nonstd::sv_lite::u32string_view operator "" _sv(const char32_t* str, size_t len) nssv_noexcept // (3) + { + return nonstd::sv_lite::u32string_view{ str, len }; + } + + nssv_constexpr nonstd::sv_lite::wstring_view operator "" _sv(const wchar_t* str, size_t len) nssv_noexcept // (4) + { + return nonstd::sv_lite::wstring_view{ str, len }; + } + +#endif // nssv_CONFIG_USR_SV_OPERATOR + + } + } +} // namespace nonstd::literals::string_view_literals + +#endif + +// +// Extensions for std::string: +// + +#if nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS + +namespace nonstd { + namespace sv_lite { + + // Exclude MSVC 14 (19.00): it yields ambiguous to_string(): + +#if nssv_CPP11_OR_GREATER && nssv_COMPILER_MSVC_VERSION != 140 + + template< class CharT, class Traits, class Allocator = std::allocator > + std::basic_string + to_string(basic_string_view v, Allocator const& a = Allocator()) { + return std::basic_string(v.begin(), v.end(), a); + } + +#else + + template< class CharT, class Traits > + std::basic_string + to_string(basic_string_view v) { + return std::basic_string(v.begin(), v.end()); + } + + template< class CharT, class Traits, class Allocator > + std::basic_string + to_string(basic_string_view v, Allocator const& a) { + return std::basic_string(v.begin(), v.end(), a); + } + +#endif // nssv_CPP11_OR_GREATER + + template< class CharT, class Traits, class Allocator > + basic_string_view + to_string_view(std::basic_string const& s) { + return basic_string_view(s.data(), s.size()); + } + + } +} // namespace nonstd::sv_lite + +#endif // nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS + +// +// make types and algorithms available in namespace nonstd: +// + +namespace nonstd { + + using sv_lite::basic_string_view; + using sv_lite::string_view; + using sv_lite::wstring_view; + +#if nssv_HAVE_WCHAR16_T + using sv_lite::u16string_view; +#endif +#if nssv_HAVE_WCHAR32_T + using sv_lite::u32string_view; +#endif + + // literal "sv" + + using sv_lite::operator==; + using sv_lite::operator!=; + using sv_lite::operator<; + using sv_lite::operator<=; + using sv_lite::operator>; + using sv_lite::operator>=; + + using sv_lite::operator<<; + +#if nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS + using sv_lite::to_string; + using sv_lite::to_string_view; +#endif + +} // namespace nonstd + +// 24.4.5 Hash support (C++11): + +// Note: The hash value of a string view object is equal to the hash value of +// the corresponding string object. + +#if nssv_HAVE_STD_HASH + +#include + +namespace std { + + template<> + struct hash< nonstd::string_view > { + public: + std::size_t operator()(nonstd::string_view v) const nssv_noexcept { + return std::hash()(std::string(v.data(), v.size())); + } + }; + + template<> + struct hash< nonstd::wstring_view > { + public: + std::size_t operator()(nonstd::wstring_view v) const nssv_noexcept { + return std::hash()(std::wstring(v.data(), v.size())); + } + }; + + template<> + struct hash< nonstd::u16string_view > { + public: + std::size_t operator()(nonstd::u16string_view v) const nssv_noexcept { + return std::hash()(std::u16string(v.data(), v.size())); + } + }; + + template<> + struct hash< nonstd::u32string_view > { + public: + std::size_t operator()(nonstd::u32string_view v) const nssv_noexcept { + return std::hash()(std::u32string(v.data(), v.size())); + } + }; + +} // namespace std + +#endif // nssv_HAVE_STD_HASH + +nssv_RESTORE_WARNINGS() + +#endif // nssv_HAVE_STD_STRING_VIEW +#endif // NONSTD_SV_LITE_H_INCLUDED \ No newline at end of file diff --git a/include/use_asio.hpp b/include/use_asio.hpp new file mode 100644 index 0000000..1d2c4b7 --- /dev/null +++ b/include/use_asio.hpp @@ -0,0 +1,33 @@ +#pragma once + +#if defined(ASIO_STANDALONE) +//MSVC : define environment path 'ASIO_STANDALONE_INCLUDE', e.g. 'E:\bdlibs\asio-1.10.6\include' + +#include +#ifdef CINATRA_ENABLE_SSL +#include +#endif +#include +#include +namespace boost +{ + namespace asio + { + using namespace ::asio; + } + namespace system { + using ::std::error_code; + } +} +#else +#include +#ifdef CINATRA_ENABLE_SSL +#include +#endif +#include +using namespace boost; +using tcp_socket = boost::asio::ip::tcp::socket; +#ifdef CINATRA_ENABLE_SSL +using ssl_socket = boost::asio::ssl::stream; +#endif +#endif