- Boost-users - lists.preview.boost.org

cannot compile boost pmr small_vector snippet
by Pedro Pinto pedro.pinto＠bluetradesys.com 02 Apr '19

02 Apr '19

Hi there, I am trying to use the pmr version of the boost small_vector container. I expected the following to work: #include <boost/container/pmr/polymorphic_allocator.hpp>#include <boost/container/pmr/small_vector.hpp> boost::container::pmr::polymorphic_allocator<int> alloc; boost::container::pmr::small_vector<int,4> vec(alloc); But this does not compile with boost 65, gcc 7.3/clang 6.0. The compile error seems to suggest I should be using small_vector_allocator which is an internal class. The exact clang error is below. Am I missing something here? Thanks /usr/include/boost/container/small_vector.hpp:514:41: note: candidate constructor not viable: no known conversion from 'boost::container::pmr::polymorphic_allocator<int>' to 'const boost::container::small_vector<int, 4, boost::container::pmr::polymorphic_allocator<int> >::allocator_type' (aka 'const small_vector_allocator<boost::container::pmr::polymorphic_allocator<int> >') for 1st argument BOOST_CONTAINER_FORCEINLINE explicit small_vector(const allocator_type &a)

1 0

[variant2] Review of Variant2 started today : April 1 - April 10
by Michael Caisse 02 Apr '19

02 Apr '19

The Boost formal review of Peter Dimov's Variant2 library will take place April 1 - 10, 2019. Please consider participating in this review. The success of Boost is partially a result of the quality review process which is conducted by the community. You are part of the Boost community. I will be grateful to receive a review based on whatever level of effort or time you can devote. Variant2 is a never-valueless C++11/14/17 implementation of std::variant. >From the README: The class boost::variant2::variant<T...> is an almost conforming implementation of std::variant with the following differences: * A converting constructor from, e.g. variant<int, float> to variant<float, double, int> is provided as an extension; * The reverse operation, going from variant<float, double, int> to variant<int, float> is provided as the member function subset<U...>. (This operation can throw if the current state of the variant cannot be represented.) * variant<T...> is not trivial when all contained types are trivial. To avoid going into a valueless-by-exception state, this implementation falls back to using double storage unless * one of the alternatives is the type monostate, * one of the alternatives has a nonthrowing default constructor, or * all the contained types are nothrow move constructible. If the first two bullets don't hold, but the third does, the variant uses single storage, but emplace constructs a temporary and moves it into place if the construction of the object can throw. In case this is undesirable, one can force emplace into always constructing in- place by adding monostate as one of the alternatives. You can find the source code here: <https://github.com/pdimov/variant2> The master branch will be stable for the review: <https://github.com/pdimov/variant2/tree/master> Find the documentation here (also stable during the review): <https://pdimov.github.io/variant2/doc/html/variant2.html> Note: The repository contains an expected implementation also; however, that is not being considered in this review. Please provide in your review information you think is valuable to understand your choice to ACCEPT or REJECT including Variant2 as a Boost library. Please be explicit about your decision (ACCEPT or REJECT). Some other questions you might want to consider answering: - What is your evaluation of the design? - What is your evaluation of the implementation? - What is your evaluation of the documentation? - What is your evaluation of the potential usefulness of the library? - Did you try to use the library? With which compiler(s)? Did you have any problems? - How much effort did you put into your evaluation? A glance? A quick reading? In-depth study? - Are you knowledgeable about the problem domain? More information about the Boost Formal Review Process can be found here: <http://www.boost.org/community/reviews.html> Thank you for your effort in the Boost community. Happy coding - michael -- Michael Caisse Ciere Consulting ciere.com

1 0

[boost][stacktrace] stacktrace keep eating memory
by Hao Jiang 29 Mar '19

29 Mar '19

I am using stacktrace on Windows. I found stacktrace keep eating my memory. A simple test program: void foo() { auto st = boost::stacktrace::stacktrace{}; auto line = st.begin()->source_line(); std::cout << line << std::endl; } void main() { for (int i = 0; i < 0xFFFF; i++) { foo(); } } Based on MSVC memory profiling tool, memory usage keep growth: [cid:image001.png@01D4DF46.BA4E1090] And frame allocator is taking heap: [cid:image004.png@01D4DF47.6F38C310] Anyone knows why it happens? Br, Hao. Platform: Windows 7. Compiler: MSVC 2017 Boost version: 1.67 Compile and link: release, static-link, static runtime.

2 1

[dll] Notifying a plugins host that a plugin should be unloaded
by Sean Farrow 29 Mar '19

29 Mar '19

Hi all, I have an application that uses boost.dll to provide plugin functionality. I have a base class defined that all plugins derive from. I'm looking for a way to notify the host application that a particular plugin should be unloaded. This is determined by the plugin itself. Is signals/slots appropriate here or is there a better option? Has anyone else done anything like this? Any help appreciated. Kind regards Sean.

2 1

[range] Conflict with string algorithms
by Bill Buklis 29 Mar '19

29 Mar '19

I noticed there is a conflict between boost range and the string algorithm header files. There may be others, but the specific one I was dealing with was boost::find. For example, the following code results in an ambiguous warning. This is because boost::find is defined both in algorithm/string/find.hpp and range/algorithm/find.hpp. #include <vector> #include <boost/range/algorithm.hpp> #include <boost/algorithm/string.hpp> int main() { std::vector<int> vec; boost::find(vec, 3); } Is this intentional or is it is an oversight or am I just doing something wrong? -- Bill

2 1

[review][variant2] Variant2 Review Starts April 1
by Michael Caisse 24 Mar '19

24 Mar '19

The Boost formal review of Peter Dimov's Variant2 library will take place April 1 - 10, 2019. Please consider participating in this review. The success of Boost is partially a result of the quality review process which is conducted by the community. You are part of the Boost community. I will be grateful to receive a review based on whatever level of effort or time you can devote. Variant2 is a never-valueless C++11/14/17 implementation of std::variant. >From the README: The class boost::variant2::variant<T...> is an almost conforming implementation of std::variant with the following differences: * A converting constructor from, e.g. variant<int, float> to variant<float, double, int> is provided as an extension; * The reverse operation, going from variant<float, double, int> to variant<int, float> is provided as the member function subset<U...>. (This operation can throw if the current state of the variant cannot be represented.) * variant<T...> is not trivial when all contained types are trivial. To avoid going into a valueless-by-exception state, this implementation falls back to using double storage unless * one of the alternatives is the type monostate, * one of the alternatives has a nonthrowing default constructor, or * all the contained types are nothrow move constructible. If the first two bullets don't hold, but the third does, the variant uses single storage, but emplace constructs a temporary and moves it into place if the construction of the object can throw. In case this is undesirable, one can force emplace into always constructing in- place by adding monostate as one of the alternatives. You can find the source code here: <https://github.com/pdimov/variant2> and the documentation here: <https://pdimov.github.io/variant2/doc/html/variant2.html> Please take an early look at the library and ask questions now. Peter Dimov is very active on the Cpplang Slack #boost channel; however, please consider using the Boost Dev or User Mail Lists so that the entire community might benefit from your conversation. Note: The repository contains an expected implementation also; however, that is not being considered in this review. Thank you for your participation! michael -- Michael Caisse Ciere Consulting ciere.com -- Michael Caisse Ciere Consulting ciere.com

1 0

How to keep a pointer on a shared data in a boost shared memory segment
by jucin loic 24 Mar '19

24 Mar '19

Hi everyone ! How to keep a pointer on a shared data in a boost shared memory segment ? I have a function which returns shm.construct<SharedData>(_nameSeg.c_str())(innerDataAllocator); But outside of the function, the object pointed by SharedData is inaccessible My general problem is that I want to have way to get, and set data in shared memory, but without, each time, having to : -get shm -find object in shm based on its name -construct allocators. So I would like to store 1) allocators and 2)a pointer to the shared object How could I do this ? I made a SO question about my problem, can you have a look ? It should be clearer :) https://stackoverflow.com/questions/55195149/how-to-keep-a-pointer-on-a-sha…

4 5

Future of boost.compute
by Heriberto Delgado 23 Mar '19

23 Mar '19

My apologies if this has been asked before. To be honest, I'm not good doing stuff with mailing lists. However, this is something about which I would really like to know your opinion. With Apple recently deprecating OpenCL / GL technologies in their software, and the newer APIs on the market - Vulkan, Metal - and current native APIs - DX Compute, also Metal Compute - , it sure looks like boost.compute, which is essentially a wrapper around OpenCL, is on its way to become a legacy API. That is, unless the API gets modified to allow multiple APIs and platforms. So, what do you think is going to happen? Is boost.compute eventually going to "disappear" (similar to how boost pointer classes were replaced by std:: pointer classes), or is there some kind of effort to move it beyond OpenCL and into newer APIs? - Heriberto Delgado.

1 0

Re: [Boost-users] Zero-malloc memory pool for Boost Intrusive smart pointers
by Gavin Lambert 23 Mar '19

23 Mar '19

At 09:25 23/03/2019, Francesco wrote: >Yes I know about std::make_shared<> and indeed I >was using that solution before implementing the >memory pool based on intrusive pointers. >The problem is that in my workload I have >several threads that need to get a smart pointer >to a fairly-big object every time they process >input data and they will release it later. Which brings up another point; your current implementation is not thread-safe. Which is fine, but you should probably mention that explicitly in your readme. A very common worker pattern is to have all allocations on one thread and all deallocations on another thread, and that wouldn't work as-is. >Now allocating with std::make_shared<>Â a new >object on every input data was causing my >threads to do lots of mallocs/sec and that >became the performace limiting factor. >The use of a memory pool instead allows me to do >a very large memory allocation from time to time >(in blocks of e.g. 1024 items) and still have >each single item of the memory pool independently refcounted. Yes, I realise that. It still could be possible to have individual node allocations strung up into a free list rather than requiring a larger contiguous allocation. But you're correct that arena allocation and intrusive_ptr is probably more efficient in the end. >My first implementation of the memory pool >indeed was using C++11 perfect forwarding to >call the ctor/dtor of type T when the item was >pulled out the pool or was returning to it. >I later removed such feature because I realized >that calling the ctor of the items to recycle >produced issues with classes having multiple inheritance IIRC. >I don't think it's safe and sane to call the >ctor of the same instance multiple times...Â Calls must be paired -- you allocate aligned uninitialised storage (aligned_storage), then placement-new to call the constructor on that storage, then eventually call the destructor, and then later you can placement-new again. You must never call the constructor twice in a row or the destructor twice in a row (unless it's trivial), but alternating is fine. Again, this is how things like optional and variant work internally -- and since they do that part for you, it can be useful to re-use it rather than re-implementing it.

2 1

Zero-malloc memory pool for Boost Intrusive smart pointers
by Francesco 22 Mar '19

22 Mar '19

Hi all, I have developed for my needs a C++11 memory pool that can provides C++ object instances in the form of boost::intrusive_ptr<> that automatically return to the pool once their refcount goes to zero. I found the need for such memory pool to have a zero-malloc memory pool algorithm for some performance-oriented applications that were relying on std::shared_ptr<>. Here's the link in case anybody is interested: https://github.com/f18m/boost-intrusive-pool with some (initial) benchmark as well. I thought that this may be useful to anybody else already using Boost intrusive pointers as well... Any comment is welcome! Francesco Montorsi

2 2

compile error, boost_1_70_0_b1, C++17, MSVC 1916, "/Zc:noexceptTypes-" compiler flag
by Thomas Wollenzin 20 Mar '19

20 Mar '19

Hello, We came across a compiler error with Boost version 1.70.0 b1 when compiling via MSVC 1916, C++17 standard and the "/Zc:noexceptTypes-" compiler flag set. The resulting error is of type: boost\type_traits\detail\is_member_function_pointer_cxx_11.hpp(359): error C2953: 'boost::is_member_function_pointer<Ret(__cdecl C::* )(Args...)>': class template has already been defined boost\type_traits\detail\is_member_function_pointer_cxx_11.hpp(48): note: see declaration of 'boost::is_member_function_pointer<Ret(__cdecl C::* )(Args...)>' A corresponding issue was created here: https://github.com/boostorg/type_traits/issues/118 We're wondering of the chances of getting this fixed with the final 1.70 release and if possible would like to get priority on a fix. Thanks for your time! Kind regards, Thomas Wollenzin ___________ Crytek GmbH / Hugo-Junkers-Strasse 3, 60386 Frankfurt am Main / HR B 77322 Amtsgericht Frankfurt am Main / Geschäftsführer/Managing Directors: Avni Yerli, Faruk Yerli, Ahmet Sahin / VAT-ID DE20432461 / www.crytek.com

1 0

Update to problem of http::request call failing
by Osman Zakir 20 Mar '19

20 Mar '19

Hi. I still have the same exception, but I did notice something I was doing wrong: the API endpoint and the key for the request to the currency API were wrong. I fixed them, but the exception is still there. I sent an email to the OpenSSL users mailing list to ask them if I did anything wrong in the root certificate stuff. Entire source code for app is on GitHub here: https://github.com/DragonOsman/currency_converter .

1 0

Using async_pipe as named pipe in windows
by parean 20 Mar '19

20 Mar '19

I have this code: boost::asio::io_service ios; std::vector<char> buf(20); bp::async_pipe ap(ios, "\\\\.\\pipe\\SamplePipe"); boost::asio::async_read(ap, boost::asio::buffer(buf), [](const boost::system::error_code &ec, std::size_t size) {}); ios.run(); Now, I execute "echo 42 > \\.\pipe\SamplePipe" in the cmd and expect an asynchronous read to the buffer to occur. But instead I get the following error: "All pipe instances are busy." I'm sure I'm doing something wrong. Can you please tell me what should I add to my code for it to work? -- Sent from: http://boost.2283326.n4.nabble.com/Boost-Users-f2553780.html

2 1

multi_index reserve but allocate
by Olivier Tristan 20 Mar '19

20 Mar '19

Hi, Looks like that even if I call reserve on a multi_index, it stills allocate memory while I am still below the reserve size. Is this the intended behavior ? If so, what is the best way to avoid allocation in a fixed sized multi_index Thanks ! -- Olivier Tristan Research & Development www.uvi.net

2 4

Call to boost::beast::http::write() Failing with Exception "Uninitialized"
by Osman Zakir 19 Mar '19

19 Mar '19

Hi, everyone. I really need some help here. I tried looking at the Boost documentation as well, but I only saw that "http::write" from Boost.Beast throws a "system_error" exception on failure. I can't figure out why it's failing or what exactly is uninitialized. I did look in the debugger and I added the SSL stream object and the request object to the watch to check their respective values. I have this source code file: https://github.com/DragonOsman/currency_converter/blob/master/currency_conv… and this is the root_certificate.hpp file: https://github.com/DragonOsman/currency_converter/blob/master/root_certific… . Is there anything wrong in the root certificate verification code and such in the header file? And I'm trying to make a HTTPS GET request in the functions "cache_storage::query_rate" and "cache_storage::query_list" using those certificates through SSL context but my try-catch block in that second-mentioned function is catching a "system_error" from "http::write()". The "what" string is "Uninitialized", and from looking at the HTTP request object's value member, I noticed that it's just an empty string. I also tried to print out the request body before but got nothing from the request object in my app's console window at all (by "console" I of course mean the kind opened for Windows Console Applications). So could it be that the request object is uninitialized? I have this for that: " std::string host{ "bankersalgo.com" }, api_endpoint{ "/currencies_list" }, key{ currencykey }; std::string target = api_endpoint + '/' + key; std::string port{ "443" }; int version = 11; " and " // Set up an HTTP GET request message http::request<http::string_body> req{ http::verb::get, target, version }; req.set(http::field::host, host); req.set(http::field::content_type, "application/json"); req.set(http::field::accept, "application/json"); req.set(http::field::user_agent, BOOST_BEAST_VERSION_STRING); //req.set(http::field::content_encoding, "gzip"); // Send the HTTP request to the remote host http::write(stream, req); " The line setting the content encoding is commented out because I wanted to see what happens if I don't set the encoding to "gzip" (on bankersalgo.com, it shows that the content encoding for the HTTP response for each request endpoint is "gzip"). Also it seems the call to "http::write()" isn't necessarily failing since I do get a "200 OK" response. There's just an empty string both for the request object value and request body, and for the response body. But is it really the request object that's uninitialized? If so, why? I did add the code to set and I also did it exactly as shown in the example. It's also possible that the stream is what's uninitialized since there's a pending read and a pending write on it and both of them have empty data objects. How do I fix this stuff? Someone please help. Full app source code is here: https://github.com/DragonOsman/currency_converter . My entire Watch in the debugger: " Name Value Type ◢ ctx {handle_=0x0000024ea54ca760 {method=0x00007ff6a3e39640 {currency_converter.exe!ssl_method_st TLS_client_method_data} {...} ...} ...} boost::asio::ssl::context boost::asio::ssl::context_base {...} boost::asio::ssl::context_base boost::asio::detail::noncopyable {...} boost::asio::detail::noncopyable ◢ handle_ 0x0000024ea54ca760 {method=0x00007ff6a3e39640 {currency_converter.exe!ssl_method_st TLS_client_method_data} {...} ...} ssl_ctx_st * ▶ method 0x00007ff6a3e39640 {currency_converter.exe!ssl_method_st TLS_client_method_data} {version=65536 flags=...} const ssl_method_st * cipher_list 0x0000024ea54882d0 {...} stack_st_SSL_CIPHER * cipher_list_by_id 0x0000024ea5488300 {...} stack_st_SSL_CIPHER * tls13_ciphersuites 0x0000024ea5488270 {...} stack_st_SSL_CIPHER * ◢ cert_store 0x0000024ea5488bc0 {cache=1 objs=0x0000024ea5488120 {...} get_cert_methods=0x0000024ea5488180 {...} ...} x509_store_st * cache 1 int objs 0x0000024ea5488120 {...} stack_st_X509_OBJECT * get_cert_methods 0x0000024ea5488180 {...} stack_st_X509_LOOKUP * ◢ param 0x0000024ea5472420 {name=0x0000000000000000 <NULL> check_time=0 inh_flags=0 ...} X509_VERIFY_PARAM_st * ▶ name 0x0000000000000000 <NULL> char * check_time 0 __int64 inh_flags 0 unsigned int flags 0 unsigned long purpose 0 int trust 0 int depth -1 int auth_level -1 int policies 0x0000000000000000 <NULL> stack_st_ASN1_OBJECT * hosts 0x0000000000000000 <NULL> stack_st_OPENSSL_STRING * hostflags 0 unsigned int ▶ peername 0x0000000000000000 <NULL> char * ▶ email 0x0000000000000000 <NULL> char * emaillen 0 unsigned __int64 ▶ ip 0x0000000000000000 <NULL> unsigned char * iplen 0 unsigned __int64 verify 0x0000000000000000 int(*)(x509_store_ctx_st *) verify_cb 0x0000000000000000 int(*)(int, x509_store_ctx_st *) get_issuer 0x0000000000000000 int(*)(x509_st * *, x509_store_ctx_st *, x509_st *) check_issued 0x0000000000000000 int(*)(x509_store_ctx_st *, x509_st *, x509_st *) check_revocation 0x0000000000000000 int(*)(x509_store_ctx_st *) get_crl 0x0000000000000000 int(*)(x509_store_ctx_st *, X509_crl_st * *, x509_st *) check_crl 0x0000000000000000 int(*)(x509_store_ctx_st *, X509_crl_st *) cert_crl 0x0000000000000000 int(*)(x509_store_ctx_st *, X509_crl_st *, x509_st *) check_policy 0x0000000000000000 int(*)(x509_store_ctx_st *) lookup_certs 0x0000000000000000 stack_st_X509 *(*)(x509_store_ctx_st *, X509_name_st *) lookup_crls 0x0000000000000000 stack_st_X509_CRL *(*)(x509_store_ctx_st *, X509_name_st *) cleanup 0x0000000000000000 int(*)(x509_store_ctx_st *) ▶ ex_data {sk=0x0000000000000000 <NULL> } crypto_ex_data_st references 1 volatile int lock 0x0000024ea5488150 void * ▶ sessions 0x0000024ea542e350 {dummy={d1=0x0000024ea5484bf0 d2=2772978672 d3=-1521988624 } } lhash_st_SSL_SESSION * session_cache_size 20480 unsigned __int64 ▶ session_cache_head 0x0000000000000000 <NULL> ssl_session_st * ▶ session_cache_tail 0x0000000000000000 <NULL> ssl_session_st * session_cache_mode 2 unsigned int session_timeout 7200 long new_session_cb 0x0000000000000000 int(*)(ssl_st *, ssl_session_st *) remove_session_cb 0x0000000000000000 void(*)(ssl_ctx_st *, ssl_session_st *) get_session_cb 0x0000000000000000 ssl_session_st *(*)(ssl_st *, const unsigned char *, int, int *) ▶ stats {sess_connect=0 sess_connect_renegotiate=0 sess_connect_good=0 ...} <anonymous-tag> references 3 volatile int app_verify_callback 0x0000000000000000 int(*)(x509_store_ctx_st *, void *) app_verify_arg 0x0000000000000000 void * default_passwd_callback 0x0000000000000000 int(*)(char *, int, int, void *) default_passwd_callback_userdata 0x0000000000000000 void * client_cert_cb 0x0000000000000000 int(*)(ssl_st *, x509_st * *, evp_pkey_st * *) app_gen_cookie_cb 0x0000000000000000 int(*)(ssl_st *, unsigned char *, unsigned int *) app_verify_cookie_cb 0x0000000000000000 int(*)(ssl_st *, const unsigned char *, unsigned int) gen_stateless_cookie_cb 0x0000000000000000 int(*)(ssl_st *, unsigned char *, unsigned __int64 *) verify_stateless_cookie_cb 0x0000000000000000 int(*)(ssl_st *, const unsigned char *, unsigned __int64) ▶ ex_data {sk=0x0000000000000000 <NULL> } crypto_ex_data_st ▶ md5 0x00007ff6a3e65f00 {currency_converter.exe!evp_md_st md5_md} {type=4 pkey_type=8 md_size=16 ...} const evp_md_st * ▶ sha1 0x00007ff6a3e65fa0 {currency_converter.exe!evp_md_st sha1_md} {type=64 pkey_type=65 md_size=20 ...} const evp_md_st * extra_certs 0x0000000000000000 <NULL> stack_st_X509 * comp_methods 0x0000024ea542bdd0 {...} stack_st_SSL_COMP * info_callback 0x0000000000000000 void(*)(const ssl_st *, int, int) ca_names 0x0000024ea5488330 {...} stack_st_X509_NAME * client_ca_names 0x0000024ea5488360 {...} stack_st_X509_NAME * options 1179652 unsigned int mode 4 unsigned int min_proto_version 771 int max_proto_version 771 int max_cert_list 102400 unsigned __int64 ▶ cert 0x0000024ea54cab50 {key=0x0000024ea54cab70 {x509=0x0000000000000000 <NULL> privatekey=0x0000000000000000 <NULL> ...} ...} cert_st * read_ahead 0 int msg_callback 0x0000000000000000 void(*)(int, int, int, const void *, unsigned __int64, ssl_st *, void *) msg_callback_arg 0x0000000000000000 void * verify_mode 1 unsigned int sid_ctx_length 0 unsigned __int64 ▶ sid_ctx 0x0000024ea54ca8c8 "" unsigned char[32] default_verify_callback 0x0000000000000000 int(*)(int, x509_store_ctx_st *) generate_session_id 0x0000000000000000 int(*)(ssl_st *, unsigned char *, unsigned int *) ▶ param 0x0000024ea5472570 {name=0x0000000000000000 <NULL> check_time=0 inh_flags=0 ...} X509_VERIFY_PARAM_st * quiet_shutdown 0 int ▶ ctlog_store 0x0000024ea5466400 {logs=0x0000024ea54881b0 {...} } ctlog_store_st * ct_validation_callback 0x0000000000000000 int(*)(const ct_policy_eval_ctx_st *, const stack_st_SCT *, void *) ct_validation_callback_arg 0x0000000000000000 void * split_send_fragment 16384 unsigned __int64 max_send_fragment 16384 unsigned __int64 max_pipelines 0 unsigned __int64 default_read_buf_len 0 unsigned __int64 ▶ client_cert_engine 0x0000000000000000 <NULL> engine_st * client_hello_cb 0x0000000000000000 int(*)(ssl_st *, int *, void *) client_hello_cb_arg 0x0000000000000000 void * ▶ ext {servername_cb=0x0000000000000000 servername_arg=0x0000000000000000 tick_key_name=0x0000024ea54ca968 ";þ†ßO^¿\x1f^\t³‹ÉÚü... ...} <anonymous-tag> psk_client_callback 0x0000000000000000 unsigned int(*)(ssl_st *, const char *, char *, unsigned int, unsigned char *, unsigned int) psk_server_callback 0x0000000000000000 unsigned int(*)(ssl_st *, const char *, unsigned char *, unsigned int) psk_find_session_cb 0x0000000000000000 int(*)(ssl_st *, const unsigned char *, unsigned __int64, ssl_session_st * *) psk_use_session_cb 0x0000000000000000 int(*)(ssl_st *, const evp_md_st *, const unsigned char * *, unsigned __int64 *, ssl_session_st * *) ▶ srp_ctx {SRP_cb_arg=0x0000000000000000 TLS_ext_srp_username_callback=0x0000000000000000 SRP_verify_param_callback=...} srp_ctx_st ▶ dane {mdevp=0x0000000000000000 {???} mdord=0x0000000000000000 <NULL> mdmax=0 '\0' ...} dane_ctx_st srtp_profiles 0x0000000000000000 <NULL> stack_st_SRTP_PROTECTION_PROFILE * not_resumable_session_cb 0x0000000000000000 int(*)(ssl_st *, int) lock 0x0000024ea54881e0 void * keylog_callback 0x0000000000000000 void(*)(const ssl_st *, const char *) max_early_data 0 unsigned int recv_max_early_data 16384 unsigned int record_padding_cb 0x0000000000000000 unsigned __int64(*)(ssl_st *, int, unsigned __int64, void *) record_padding_arg 0x0000000000000000 void * block_padding 0 unsigned __int64 generate_ticket_cb 0x0000000000000000 int(*)(ssl_st *, void *) decrypt_ticket_cb 0x0000000000000000 int(*)(ssl_st *, ssl_session_st *, const unsigned char *, unsigned __int64, int, void *) ticket_cb_data 0x0000000000000000 void * num_tickets 2 unsigned __int64 allow_early_data_cb 0x0000000000000000 int(*)(ssl_st *, void *) allow_early_data_cb_data 0x0000000000000000 void * pha_enabled 0 int ▶ init_ {ref_=shared_ptr {...} [4 strong refs] [default] } boost::asio::ssl::detail::openssl_init<1> ▶ ec {val_=0 failed_=false cat_=0x0000024ea6dfbc70 default } boost::system::error_code ▶ results {...} boost::asio::ip::basic_resolver_results<boost::asio::ip::tcp> ◢ req allocator boost::beast::http::message<1,boost::beast::http::basic_string_body<char,std::char_traits<char>,std::allocator<char> >,boost::beast::http::basic_fields<std::allocator<char> > > ◢ [Raw View] {...} boost::beast::http::message<1,boost::beast::http::basic_string_body<char,std::char_traits<char>,std::allocator<char> >,boost::beast::http::basic_fields<std::allocator<char> > > ◢ boost::beast::http::header<1,boost::beast::http::basic_fields<std::allocator<char> > > {version_=11 method_=get (2) } boost::beast::http::header<1,boost::beast::http::basic_fields<std::allocator<char> > > ◢ boost::beast::http::basic_fields<std::allocator<char> > {set_={...} list_={data_={root_plus_size_={m_header={...} } } } method_={ptr_=0x0000000000000000 <NULL> ...} ...} boost::beast::http::basic_fields<std::allocator<char> > ◢ boost::empty_::empty_value<std::allocator<char>,0,1> {...} boost::empty_::empty_value<std::allocator<char>,0,1> std::allocator<char> {...} std::allocator<char> ◢ set_ {...} boost::intrusive::multiset_impl<boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::rbtree_node_traits<void *,0>,0,boost::intrusive::dft_tag,3>,void,boost::beast::http::basic_fields<std::allocator<char> >::key_compare,unsigned __int64,1,void> ◢ boost::intrusive::bstree_impl<boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::rbtree_node_traits<void *,0>,0,boost::intrusive::dft_tag,3>,void,boost::beast::http::basic_fields<std::allocator<char> >::key_compare,unsigned __int64,1,5,void> {...} boost::intrusive::bstree_impl<boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::rbtree_node_traits<void *,0>,0,boost::intrusive::dft_tag,3>,void,boost::beast::http::basic_fields<std::allocator<char> >::key_compare,unsigned __int64,1,5,void> ◢ boost::intrusive::bstbase<boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::rbtree_node_traits<void *,0>,0,boost::intrusive::dft_tag,3>,void,boost::beast::http::basic_fields<std::allocator<char> >::key_compare,1,unsigned __int64,5,void> {...} boost::intrusive::bstbase<boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::rbtree_node_traits<void *,0>,0,boost::intrusive::dft_tag,3>,void,boost::beast::http::basic_fields<std::allocator<char> >::key_compare,1,unsigned __int64,5,void> ◢ boost::intrusive::bstbase_hack<boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::rbtree_node_traits<void *,0>,0,boost::intrusive::dft_tag,3>,void,boost::beast::http::basic_fields<std::allocator<char> >::key_compare,1,unsigned __int64,5,void> {...} boost::intrusive::bstbase_hack<boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::rbtree_node_traits<void *,0>,0,boost::intrusive::dft_tag,3>,void,boost::beast::http::basic_fields<std::allocator<char> >::key_compare,1,unsigned __int64,5,void> ◢ boost::intrusive::detail::size_holder<1,unsigned __int64,void> {size_=4 } boost::intrusive::detail::size_holder<1,unsigned __int64,void> size_ 4 unsigned __int64 ◢ boost::intrusive::bstbase2<boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::rbtree_node_traits<void *,0>,0,boost::intrusive::dft_tag,3>,void,boost::beast::http::basic_fields<std::allocator<char> >::key_compare,5,void> {...} boost::intrusive::bstbase2<boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::rbtree_node_traits<void *,0>,0,boost::intrusive::dft_tag,3>,void,boost::beast::http::basic_fields<std::allocator<char> >::key_compare,5,void> ◢ boost::intrusive::detail::ebo_functor_holder<boost::intrusive::tree_value_compare<boost::beast::http::basic_fields<std::allocator<char> >::element *,boost::beast::http::basic_fields<std::allocator<char> >::key_compare,boost::move_detail::identity<boost::beast::http::basic_fields<std::allocator<char> >::element>,bool,1>,0> {...} boost::intrusive::detail::ebo_functor_holder<boost::intrusive::tree_value_compare<boost::beast::http::basic_fields<std::allocator<char> >::element *,boost::beast::http::basic_fields<std::allocator<char> >::key_compare,boost::move_detail::identity<boost::beast::http::basic_fields<std::allocator<char> >::element>,bool,1>,0> ◢ boost::intrusive::tree_value_compare<boost::beast::http::basic_fields<std::allocator<char> >::element *,boost::beast::http::basic_fields<std::allocator<char> >::key_compare,boost::move_detail::identity<boost::beast::http::basic_fields<std::allocator<char> >::element>,bool,1> {...} boost::intrusive::tree_value_compare<boost::beast::http::basic_fields<std::allocator<char> >::element *,boost::beast::http::basic_fields<std::allocator<char> >::key_compare,boost::move_detail::identity<boost::beast::http::basic_fields<std::allocator<char> >::element>,bool,1> ◢ boost::intrusive::detail::ebo_functor_holder<boost::beast::http::basic_fields<std::allocator<char> >::key_compare,0> {...} boost::intrusive::detail::ebo_functor_holder<boost::beast::http::basic_fields<std::allocator<char> >::key_compare,0> ◢ boost::beast::http::basic_fields<std::allocator<char> >::key_compare {...} boost::beast::http::basic_fields<std::allocator<char> >::key_compare boost::beast::iless {...} boost::beast::iless ◢ boost::intrusive::bstbase3<boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::rbtree_node_traits<void *,0>,0,boost::intrusive::dft_tag,3>,5,void> {holder={root={...} } } boost::intrusive::bstbase3<boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::rbtree_node_traits<void *,0>,0,boost::intrusive::dft_tag,3>,5,void> ◢ holder {root={...} } boost::intrusive::bstbase3<boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::rbtree_node_traits<void *,0>,0,boost::intrusive::dft_tag,3>,5,void>::holder_t ◢ boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::rbtree_node_traits<void *,0>,0,boost::intrusive::dft_tag,3> {...} boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::rbtree_node_traits<void *,0>,0,boost::intrusive::dft_tag,3> boost::intrusive::bhtraits_base<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::rbtree_node<void *> *,boost::intrusive::dft_tag,3> {...} boost::intrusive::bhtraits_base<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::rbtree_node<void *> *,boost::intrusive::dft_tag,3> ◢ root {...} boost::intrusive::detail::default_header_holder<boost::intrusive::rbtree_node_traits<void *,0> > ◢ boost::intrusive::rbtree_node<void *> {parent_=0x0000024ea6dd1d10 {parent_=0x0000005f727ff0f8 {parent_=0x0000024ea6dd1d10 {parent_=0x0000005f727ff0f8 {...} ...} ...} ...} ...} boost::intrusive::rbtree_node<void *> ▶ parent_ 0x0000024ea6dd1d10 {parent_=0x0000005f727ff0f8 {parent_=0x0000024ea6dd1d10 {parent_=0x0000005f727ff0f8 {...} ...} ...} ...} boost::intrusive::rbtree_node<void *> * ▶ left_ 0x0000024ea54f5140 {parent_=0x0000024ea6dd1d10 {parent_=0x0000005f727ff0f8 {parent_=0x0000024ea6dd1d10 {...} ...} ...} ...} boost::intrusive::rbtree_node<void *> * ▶ right_ 0x0000024ea6dd3300 {parent_=0x0000024ea6dd1d10 {parent_=0x0000005f727ff0f8 {parent_=0x0000024ea6dd1d10 {...} ...} ...} ...} boost::intrusive::rbtree_node<void *> * color_ red_t (0) boost::intrusive::rbtree_node<void *>::color ◢ list_ {data_={root_plus_size_={m_header={...} } } } boost::intrusive::list_impl<boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::list_node_traits<void *>,0,boost::intrusive::dft_tag,1>,unsigned __int64,0,void> ◢ data_ {root_plus_size_={m_header={...} } } boost::intrusive::list_impl<boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::list_node_traits<void *>,0,boost::intrusive::dft_tag,1>,unsigned __int64,0,void>::data_t ◢ boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::list_node_traits<void *>,0,boost::intrusive::dft_tag,1> {...} boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::list_node_traits<void *>,0,boost::intrusive::dft_tag,1> boost::intrusive::bhtraits_base<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::list_node<void *> *,boost::intrusive::dft_tag,1> {...} boost::intrusive::bhtraits_base<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::list_node<void *> *,boost::intrusive::dft_tag,1> ◢ root_plus_size_ {m_header={...} } boost::intrusive::list_impl<boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::list_node_traits<void *>,0,boost::intrusive::dft_tag,1>,unsigned __int64,0,void>::root_plus_size boost::intrusive::detail::size_holder<0,unsigned __int64,void> {...} boost::intrusive::detail::size_holder<0,unsigned __int64,void> ◢ m_header {...} boost::intrusive::detail::default_header_holder<boost::intrusive::list_node_traits<void *> > ◢ boost::intrusive::list_node<void *> {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {...} ...} ...} ...} ...} boost::intrusive::list_node<void *> ◢ next_ 0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ next_ 0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ next_ 0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ next_ 0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ next_ 0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ prev_ 0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ prev_ 0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ next_ 0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ prev_ 0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ prev_ 0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ next_ 0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ next_ 0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ prev_ 0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ prev_ 0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ next_ 0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ prev_ 0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ prev_ 0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ next_ 0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ next_ 0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ next_ 0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ prev_ 0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ prev_ 0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ next_ 0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ prev_ 0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ prev_ 0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ next_ 0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ next_ 0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ prev_ 0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ prev_ 0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ next_ 0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ prev_ 0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ prev_ 0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ next_ 0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ next_ 0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ next_ 0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ next_ 0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ prev_ 0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ prev_ 0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ next_ 0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ prev_ 0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ prev_ 0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ next_ 0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ next_ 0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ prev_ 0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ prev_ 0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ next_ 0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ prev_ 0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ prev_ 0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ next_ 0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ next_ 0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ next_ 0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ prev_ 0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ prev_ 0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ next_ 0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ prev_ 0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ prev_ 0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ next_ 0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ next_ 0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ prev_ 0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ prev_ 0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ next_ 0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=0x0000024ea6dd26c0 {next_=0x0000005f727ff118 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ▶ prev_ 0x0000005f727ff118 {next_=0x0000024ea54f5130 {next_=0x0000024ea6dd32f0 {next_=0x0000024ea6dd1d00 {next_=...} ...} ...} ...} boost::intrusive::list_node<void *> * ◢ method_ {ptr_=0x0000000000000000 <NULL> len_=0 } boost::basic_string_view<char,std::char_traits<char> > ◢ ptr_ 0x0000000000000000 <NULL> const char * <Unable to read memory> const char len_ 0 unsigned __int64 ◢ target_or_reason_ {ptr_=0x0000024ea6d99c50 " /currencies_list/5c8a4f26806e9/b764b53a14eff3867b09f39375f436b" len_=63 } boost::basic_string_view<char,std::char_traits<char> > ◢ ptr_ 0x0000024ea6d99c50 " /currencies_list/5c8a4f26806e9/b764b53a14eff3867b09f39375f436b" const char * 32 ' ' const char len_ 63 unsigned __int64 version_ 11 unsigned int method_ get (2) boost::beast::http::verb ◢ boost::empty_::empty_value<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,0,0> {value_="" } boost::empty_::empty_value<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,0,0> ◢ value_ "" std::basic_string<char,std::char_traits<char>,std::allocator<char> > [size] 0 unsigned __int64 [capacity] 15 unsigned __int64 ◢ [allocator] allocator std::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1> ◢ [Raw View] {_Myval2={_Bx={_Buf=0x0000005f727ff150 "" _Ptr=0x0000000000000000 <NULL> _Alias=0x0000005f727ff150 "" } ...} } std::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1> std::allocator<char> {...} std::allocator<char> ◢ _Myval2 {_Bx={_Buf=0x0000005f727ff150 "" _Ptr=0x0000000000000000 <NULL> _Alias=0x0000005f727ff150 "" } _Mysize=...} std::_String_val<std::_Simple_types<char> > std::_Container_base0 {...} std::_Container_base0 ◢ _Bx {_Buf=0x0000005f727ff150 "" _Ptr=0x0000000000000000 <NULL> _Alias=0x0000005f727ff150 "" } std::_String_val<std::_Simple_types<char> >::_Bxty ◢ _Buf 0x0000005f727ff150 "" char[16] [0] 0 '\0' char [1] 0 '\0' char [2] 0 '\0' char [3] 0 '\0' char [4] 0 '\0' char [5] 0 '\0' char [6] 0 '\0' char [7] 0 '\0' char [8] -17 'ï' char [9] 109 'm' char [10] -59 'Å' char [11] -93 '£' char [12] -10 'ö' char [13] 127 '' char [14] 0 '\0' char [15] 0 '\0' char ▶ _Ptr 0x0000000000000000 <NULL> char * ▶ _Alias 0x0000005f727ff150 "" char[16] _Mysize 0 unsigned __int64 _Myres 15 unsigned __int64 ◢ [Raw View] {...} std::basic_string<char,std::char_traits<char>,std::allocator<char> > ▶ std::_String_alloc<std::_String_base_types<char,std::allocator<char> > > {_Mypair=allocator } std::_String_alloc<std::_String_base_types<char,std::allocator<char> > > ◢ stream {next_layer_={...} core_={engine_={ssl_=0x0000024ea54cdbe0 {version=772 method=0x00007ff6a3e39640 {currency_converter.exe!ssl_method_st TLS_client_method_data} {...} ...} ...} ...} } boost::asio::ssl::stream<boost::asio::basic_stream_socket<boost::asio::ip::tcp> > boost::asio::ssl::stream_base {...} boost::asio::ssl::stream_base boost::asio::detail::noncopyable {...} boost::asio::detail::noncopyable ◢ next_layer_ {...} boost::asio::basic_stream_socket<boost::asio::ip::tcp> ◢ boost::asio::basic_socket<boost::asio::ip::tcp> {...} boost::asio::basic_socket<boost::asio::ip::tcp> ◢ boost::asio::basic_io_object<boost::asio::detail::reactive_socket_service<boost::asio::ip::tcp>,1> {service_=0x0000024ea6e05450 {...} implementation_={protocol_={family_=2 } } } boost::asio::basic_io_object<boost::asio::detail::reactive_socket_service<boost::asio::ip::tcp>,1> ◢ service_ 0x0000024ea6e05450 {...} boost::asio::detail::reactive_socket_service<boost::asio::ip::tcp> * ◢ boost::asio::detail::service_base<boost::asio::detail::reactive_socket_service<boost::asio::ip::tcp> > {...} boost::asio::detail::service_base<boost::asio::detail::reactive_socket_service<boost::asio::ip::tcp> > ◢ boost::asio::io_context::service {...} boost::asio::io_context::service ◢ boost::asio::execution_context::service {key_={type_info_=0x00007ff6a3f237c0 {currency_converter.exe!class boost::asio::detail::typeid_wrapper<class boost::asio::detail::reactive_socket_service<class boost::asio::ip::tcp> > `RTTI Type Descriptor'} {...} ...} ...} boost::asio::execution_context::service boost::asio::detail::noncopyable {...} boost::asio::detail::noncopyable ◢ __vfptr 0x00007ff6a3eb77f0 {currency_converter.exe!void(* boost::asio::detail::reactive_socket_service<boost::asio::ip::tcp>::`vftable'[6])()} {...} void * * [0] 0x00007ff6a3c5d0c0 {currency_converter.exe!boost::asio::detail::reactive_socket_service<boost::asio::ip::tcp>::`scalar deleting destructor'(unsigned int)} void * [1] 0x00007ff6a3c21360 {currency_converter.exe!boost::intrusive::list_impl<boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::list_node_traits<void *>,0,boost::intrusive::dft_tag,1>,unsigned __int64,0,void>::~list_impl<boost::intrusive::bhtraits<boost::beast::http::basic_fields<std::allocator<char> >::element,boost::intrusive::list_node_traits<void *>,0,boost::intrusive::dft_tag,1>,unsigned __int64,0,void>(void)} void * [2] 0x00007ff6a3c259d0 {currency_converter.exe!boost::asio::io_context::service::notify_fork(boost::asio::execution_context::fork_event)} void * ◢ key_ {type_info_=0x00007ff6a3f237c0 {currency_converter.exe!class boost::asio::detail::typeid_wrapper<class boost::asio::detail::reactive_socket_service<class boost::asio::ip::tcp> > `RTTI Type Descriptor'} {...} ...} boost::asio::execution_context::service::key ▶ type_info_ 0x00007ff6a3f237c0 {currency_converter.exe!class boost::asio::detail::typeid_wrapper<class boost::asio::detail::reactive_socket_service<class boost::asio::ip::tcp> > `RTTI Type Descriptor'} {...} const type_info * ▶ id_ 0x0000000000000000 <NULL> const boost::asio::execution_context::id * ▶ owner_ {service_registry_=0x0000024ea5468420 {mutex_={crit_section_={DebugInfo=0xffffffffffffffff {Type=??? ...} ...} } ...} } boost::asio::execution_context & ▶ next_ 0x0000024ea6ddbe20 {scheduler_={one_thread_=false mutex_={mutex_={crit_section_={DebugInfo=0xffffffffffffffff {...} ...} } ...} ...} ...} boost::asio::execution_context::service * {boost::asio::detail::select_reactor} ◢ boost::asio::detail::reactive_socket_service_base {io_context_={init_={...} impl_={one_thread_=false mutex_={mutex_={crit_section_={DebugInfo=0xffffffffffffffff {...} ...} } ...} ...} } ...} boost::asio::detail::reactive_socket_service_base ◢ io_context_ {init_={...} impl_={one_thread_=false mutex_={mutex_={crit_section_={DebugInfo=0xffffffffffffffff {Type=...} ...} } ...} ...} } boost::asio::io_context & ▶ boost::asio::execution_context {service_registry_=0x0000024ea5468420 {mutex_={crit_section_={DebugInfo=0xffffffffffffffff {Type=??? ...} ...} } ...} } boost::asio::execution_context ◢ init_ {...} boost::asio::detail::winsock_init<2,0> boost::asio::detail::winsock_init_base {...} boost::asio::detail::winsock_init_base ◢ impl_ {one_thread_=false mutex_={mutex_={crit_section_={DebugInfo=0xffffffffffffffff {Type=??? CreatorBackTraceIndex=...} ...} } ...} ...} boost::asio::detail::scheduler & ▶ boost::asio::detail::execution_context_service_base<boost::asio::detail::scheduler> {...} boost::asio::detail::execution_context_service_base<boost::asio::detail::scheduler> boost::asio::detail::thread_context {...} boost::asio::detail::thread_context one_thread_ false const bool ▶ mutex_ {mutex_={crit_section_={DebugInfo=0xffffffffffffffff {Type=??? CreatorBackTraceIndex=??? CriticalSection=...} ...} } ...} boost::asio::detail::conditionally_enabled_mutex ▶ wakeup_event_ {event_={events_=0x0000024ea5499b10 {0x0000000000000110, 0x0000000000000114} state_=1 } } boost::asio::detail::conditionally_enabled_event ▶ task_ 0x0000024ea6ddbe20 {scheduler_={one_thread_=false mutex_={mutex_={crit_section_={DebugInfo=0xffffffffffffffff {...} ...} } ...} ...} ...} boost::asio::detail::select_reactor * ▶ task_operation_ {...} boost::asio::detail::scheduler::task_operation task_interrupted_ true bool ▶ outstanding_work_ 0 std::atomic<long> ▶ op_queue_ {front_=0x0000024ea5499b30 {next_=0x0000000000000000 <NULL> func_=0x0000000000000000 task_result_=0 } ...} boost::asio::detail::op_queue<boost::asio::detail::scheduler_operation> stopped_ false bool shutdown_ false bool concurrency_hint_ -1 const int ◢ reactor_ {scheduler_={one_thread_=false mutex_={mutex_={crit_section_={DebugInfo=0xffffffffffffffff {Type=??? ...} ...} } ...} ...} ...} boost::asio::detail::select_reactor & ▶ boost::asio::detail::execution_context_service_base<boost::asio::detail::select_reactor> {...} boost::asio::detail::execution_context_service_base<boost::asio::detail::select_reactor> ▶ scheduler_ {one_thread_=false mutex_={mutex_={crit_section_={DebugInfo=0xffffffffffffffff {Type=??? CreatorBackTraceIndex=...} ...} } ...} ...} boost::asio::detail::scheduler & ▶ mutex_ {crit_section_={DebugInfo=0xffffffffffffffff {Type=??? CreatorBackTraceIndex=??? CriticalSection=??? ...} ...} } boost::asio::detail::win_mutex ▶ interrupter_ {read_descriptor_=364 write_descriptor_=356 } boost::asio::detail::socket_select_interrupter ▶ op_queue_ 0x0000024ea6ddbe88 {{operations_={size_=0 values_={ size=0 } spares_={ size=0 } ...} }, {operations_=...}, ...} boost::asio::detail::reactor_op_queue<unsigned __int64>[4] ▶ fd_sets_ 0x0000024ea6ddbf68 {{fd_set_=0x0000024ea6da77f0 {fd_count=0 fd_array=0x0000024ea6da77f8 {0} } capacity_=...}, ...} boost::asio::detail::win_fd_set_adapter[3] ▶ timer_queues_ {first_=0x0000024ea6d907f8 {impl_={timers_=0x0000000000000000 <NULL> heap_={ size=0 } } } } boost::asio::detail::timer_queue_set shutdown_ false bool ◢ implementation_ {protocol_={family_=2 } } boost::asio::detail::reactive_socket_service<boost::asio::ip::tcp>::implementation_type ▶ boost::asio::detail::reactive_socket_service_base::base_implementation_type {socket_=432 state_=16 '\x10' reactor_data_={...} } boost::asio::detail::reactive_socket_service_base::base_implementation_type ▶ protocol_ {family_=2 } boost::asio::ip::tcp boost::asio::socket_base {...} boost::asio::socket_base ◢ core_ {engine_={ssl_=0x0000024ea54cdbe0 {version=772 method=0x00007ff6a3e39640 {currency_converter.exe!ssl_method_st TLS_client_method_data} {...} ...} ...} ...} boost::asio::ssl::detail::stream_core ▶ engine_ {ssl_=0x0000024ea54cdbe0 {version=772 method=0x00007ff6a3e39640 {currency_converter.exe!ssl_method_st TLS_client_method_data} {...} ...} ...} boost::asio::ssl::detail::engine ▶ pending_read_ {...} boost::asio::basic_deadline_timer<boost::posix_time::ptime,boost::asio::time_traits<boost::posix_time::ptime> > ▶ pending_write_ {...} boost::asio::basic_deadline_timer<boost::posix_time::ptime,boost::asio::time_traits<boost::posix_time::ptime> > ▶ output_buffer_space_ { size=17408 } std::vector<unsigned char,std::allocator<unsigned char> > ▶ output_buffer_ {data_=0x0000024ea6e40000 size_=17408 } const boost::asio::mutable_buffer ▶ input_buffer_space_ { size=17408 } std::vector<unsigned char,std::allocator<unsigned char> > ▶ input_buffer_ {data_=0x0000024ea6e44440 size_=17408 } const boost::asio::mutable_buffer ▶ input_ {data_=0x0000000000000000 size_=0 } boost::asio::const_buffer req.body() This expression has side effects and will not be evaluated. stream.next_layer a pointer to a bound function may only be used to call the function ▶ stream.core_ {engine_={ssl_=0x0000024ea54cdbe0 {version=772 method=0x00007ff6a3e39640 {currency_converter.exe!ssl_method_st TLS_client_method_data} {...} ...} ...} ...} boost::asio::ssl::detail::stream_core ▶ stream.core_.engine_.ssl_ 0x0000024ea54cdbe0 {version=772 method=0x00007ff6a3e39640 {currency_converter.exe!ssl_method_st TLS_client_method_data} {...} ...} ssl_st * " Thanks in advance for any help (and I hope this time I won't be ignored like I've felt I've been lately).

1 0

Re: [Boost-users] [boost] [release] Boost 1.70.0 Beta 1 is now available
by Marshall Clow 19 Mar '19

19 Mar '19

On Tue, Mar 19, 2019 at 2:43 AM Rainer Deyke via Boost < boost(a)lists.boost.org> wrote: > On 13.03.19 15:49, Marshall Clow via Boost wrote: > > For details of what's in the release, see < > > https://www.boost.org/users/history/version_1_70_0.html>. > > > > Please download the beta, give it a try, and report any problems you > > encounter. > > I want to report a problem. > > Boost.Test is broken when cross-compiling for Windows on Linux using a > case-sensitive file system because it #includes <Windows.h> instead of > <windows.h> on line 32 of boost/test/utils/timer.hpp. > I did a quick grep through the boost sources, and found: * About 250 #includes of "windows.h" (all lower case) * Zero #includes of "Windows.h" (upper-case 'W') (and a reference to changing one instance in Boost.Test from "Windows.h" to "windows.h" for 1.67.0) We may or may not be correct, but we're quite consistent. -- Marshall

2 1

Networking TS + Beast, NEW Tutorials, Read this to learn std::net !!!
by Vinnie Falco 18 Mar '19

18 Mar '19

Fellow C++, Boost, and WG21 Enthusiasts, lend me your ear! I write to inform you about exciting developments in C++ networking. First, a bit of background. Networking comes in three flavors: * Networking TS <https://cplusplus.github.io/networking-ts/draft.pdf> * Boost.Asio <https://www.boost.org/doc/libs/1_69_0/doc/html/boost_asio.html> * Standalone Asio <https://github.com/chriskohlhoff/asio> These three are for the most part identical, except that Asio flavors have additional features like ssl::stream and signal_set which are not in the TS, but will very likely appear in a future update or version. We've had Asio for over a decade now, but there is a shortage of experts. Some people believe this shortage is because Asio in particular (and thus, Networking TS since they have identical interfaces) is "difficult to use." I believe it is wrong to blame Asio for this. Concurrent programs in general are hard to write. This is applicable: "Unfortunately, today's reality is that only thoughtful experts can write explicitly concurrent programs that are correct and efficient. This is because today's programming models for concurrency are subtle, intricate, and fraught with pitfalls that easily (and frequently) result in unforeseen races (i.e., program corruption) deadlocks (i.e., program lockup) and performance cliffs (e.g., priority inversion, convoying, and sometimes complete loss of parallelism and/or even worse performance than a single-threaded program). And even when a correct and efficient concurrent program is written, it takes great care to maintain — it's usually brittle and difficult to maintain correctly because current programming models set a very high bar of expertise required to reason reliably about the operation of concurrent programs, so that apparently innocuous changes to a working concurrent program can (and commonly do, in practice) render it entirely or intermittently nonworking in unintended and unexpected ways. Because getting it right and keeping it right is so difficult, at many major software companies there is a veritable priesthood of gurus who write and maintain the core concurrent code." - Herb Sutter, "The Trouble with Locks", <http://www.drdobbs.com/cpp/the-trouble-with-locks/184401930> Although this was written in 2005 it is still relevant today. It is understandable that Asio will be the first target of anger and frustration when writing concurrent programs, since it is on the "front line" so to speak. There has also been a distinct shortage of *good* tutorials and examples for Asio. Articles or blog posts which teach you step by step, explaining everything, and giving example code which demonstrates best practices. Boost.Beast is my low-level HTTP/WebSocket library which builds on Boost.Asio: <https://github.com/boostorg/beast> In the original release of Beast, the documentation stated "prior understanding of Boost.Asio is required." However, field experience has shown that users ignore that requirement and attempt to write complex, concurrent programs as their first-time introduction to both Beast and Asio. Based on feedback from committee members, and to serve users better, the scope of Beast has been enlarged to include first-time users of networking. The upcoming Boost 1.70 release reflects this new scope and I am excited to announce some very nice things which you can access today. First of all, Beast documentation and examples no longer use the "boost::asio" namespace, they the namespace alias "net::". While this is cosmetic, it reinforces the notion when inspecting code that it is equally applicable to Boost.Asio, Asio, and Networking TS (identifiers which are not in the TS, such as signal_set, are still qualified with boost::asio). A new documentation page explains the three flavors of networking: <https://www.boost.org/doc/libs/master/libs/beast/doc/html/beast/using_io.ht…> This is also explained in my 2018 CppCon presentation: <https://youtu.be/7FQwAjELMek?t=444> I have added a "Networking Refresher", a complete overview of networking from soup to nuts. No prior knowledge or understanding of networking is required, everything is explained in detail so if you want to learn this is the place to start. I also kept it short, but it is loaded with hyperlinks for further learning: <https://www.boost.org/doc/libs/master/libs/beast/doc/html/beast/using_io/as…> There was a recent paper in Kona, P1269R0 ("Three Years with the Networking TS") about difficulty of implementing timeouts. To address this, Beast now has a stream class which implements configurable timeouts for you, and callers no longer have to fiddle with timers manually anymore. Everything "Just Works." It achieves the P1269R0 author's goal of having timeouts "built-in to asynchronous operations", but in a way that fits in with the design of the TS: <https://www.boost.org/doc/libs/master/libs/beast/doc/html/beast/using_io/ti…> I feel that this `beast::basic_stream` serves as an existence proof that the current design of Networking TS is sound - the TS offers a flexible toolbox which lets you build your own framework the way that you want it, without making odd choices for you. We are still discovering ways of leveraging it to maximum use. The beast::websocket::stream also has built-in timeouts, but they are enhanced to support "idle pings" (keeping client connections alive) and everything is fully configurable: <https://www.boost.org/doc/libs/master/libs/beast/doc/html/beast/using_webso…> All you need to do to get sensible, suggested websocket timeouts is add one line of code after creating your stream: ws.set_option(websocket::stream_base::timeout::suggested( beast::role_type::server)); To address the cumbersome boilerplate of writing composed operations (specifically the need to propagate the associated allocator and associated executor, and to avoid invoking the completion handler from within the initiating function when the operation would complete immediately) Beast adds two new utility base classes, with plentiful documentation and examples throughout: <https://www.boost.org/doc/libs/master/libs/beast/doc/html/beast/using_io/wr…> There are two well-rounded examples which show you step by step how to write these things in a safe way: <https://www.boost.org/doc/libs/master/libs/beast/doc/html/beast/using_io/wr…> <https://www.boost.org/doc/libs/master/libs/beast/doc/html/beast/using_io/wr…> I have a big, new open source project which implements a server, that uses the `system_context`, taking full advantage of native Windows and Mac OS system-level execution context features. To support this use case and industry feedback, the examples in Beast now default to being always thread-safe. All examples use a "strand", and leverage P1322R0 ("Networking TS enhancement to enable custom I/O executors"). Yes, this paper which was approved in Kona, is now implemented in both Boost.Beast, and Boost.Asio, including all of the Beast examples, so if you pick up Boost 1.70 (or the master branches from github) you can start playing with this as soon as you're done reading this message!! <http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1322r0.html> We have an active #beast channel in the C++ Slack (https://slack.cpp.al) where experienced users can help, no question is too small! I hope you will join me and the rest of the Beast and Asio community in exploring what the very powerful Networking TS and Asio libraries have to offer, and build something great together! Regards P.S. Don't forget to star the repository! <https://github.com/boostorg/beast>

14 37

boost::endian::native_to_big_inplace fails with char
by Martijn Otto 18 Mar '19

18 Mar '19

I am having issues with boost::endian:native_to_big_inplace when used with a char. Whatever you try to 'reverse' comes out as 0. Looking through the code, on little endian machines it calls endian_reverse (as expected). This function has no overload for a char and it then gets promoted to an int. Since the int _is_ actually larger than 1 byte, something gets reversed. The native_to_big_inplace then returns it as a char, narrowing the int and throwing away all the relevant bits, resulting in a 0. I found an issue on github about this: https://github.com/boostorg/endi an/issues/10 about exactly this issue. The bug is easily shown if you try to compile static_assert(sizeof(boost::endian::endian_reverse('y')) == sizeof('y'))

1 0

Re: [Boost-users] [boost] Networking TS + Beast, NEW Tutorials, Read this to learn std::net !!!
by Vinnie Falco 17 Mar '19

17 Mar '19

> Somebody(tm) (ASIO or Beast) maybe should make buffer that has has member fn content() that returns a range with begin and end. Yes that is in Boost.Beast 1.70: <https://www.boost.org/doc/libs/master/libs/beast/doc/html/beast/ref/boost__…>

1 0

numeric_limits<float128_t> return incorrect values
by Gero Peterhoff 16 Mar '19

16 Mar '19

Hello, your implementation in /boost/math/cstdfloat/cstdfloat_limits.hpp return incorrect values for: - has_denorm - denorm_min - is_bounded - signaling/quiet_NaN ? Are the other values correct? See https://github.com/gcc-mirror/gcc/blob/master/libquadmath/quadmath.h thx Gero

2 1

Boost library name formats
by Damien 15 Mar '19

15 Mar '19

Hello, For several years now we've built Boost libraries on Windows with a minimal set of tags in the library and dll names. Our dlls and libs have looked like this: boost_atomic-mt-gd.dll boost_atomic-mt-gd.lib etc. We just upgraded from 1.65.1 to 1.69 and the same bjam command (with a new bootstrapped bjam) is now giving us an extra x64 tag: boost_atomic-mt-gd-x64.dll boost_atomic-mt-gd-x64.lib This is on VS2017 15.9.9. The bjam command we've used for years is: bjam.exe --toolset=msvc address-model=64 --stagedir=./stage64debug --build-dir=./build64debug --layout=tagged --without-mpi variant=debug link=shared threading=multi runtime-link=shared install --prefix=./win64debug/indep --exec-prefix=./win64debug/bin --libdir=./win64debug/lib --includedir=./win64debug/include Has a default setting in bjam been changed? What can we add to the bjam command to get back to the old minimal names? Thanks in advance. Damien

2 2

Help Needed with C++ SSL-using code
by Osman Zakir 15 Mar '19

15 Mar '19

I followed the Boost.Beast examples for the SSL, sync server and client code and loaded root certificates from the Windows root cert store (or at least tried to), but now I can't even get to my app in my browser anymore for some reason. Here's the link to the GitHub repository with all of the source code: https://github.com/DragonOsman/currency_converter . Any help would be appreciated. [https://avatars0.githubusercontent.com/u/18173932?s=400&v=4]<https://github.com/DragonOsman/currency_converter> GitHub - DragonOsman/currency_converter: Application for Computer Science course<https://github.com/DragonOsman/currency_converter> Google Maps + Currency Converter Web Application. Application for Computer Science course. This is a currency converter web application with the frontend and a backend. github.com

1 0

Re: [Boost-users] [boost] Networking TS + Beast, NEW Tutorials, Read this to learn std::net !!!
by Vinnie Falco 15 Mar '19

15 Mar '19

On Thu, Mar 14, 2019 at 5:09 PM Ivan Matek <libbooze(a)gmail.com> wrote: > Quite a weird pattern, where buffer does not have member begin, end. > Maybe a sentence or two describing the rationale and complexity would be nice. > I know it is O(1), but it is weird that begin/end are called on pointer. Yeah, well... that's a sore subject. First of all I did not invent these buffer concepts, they are part of Asio and Networking TS. And they *used* to have begin() and end(), but then the C++ Standards Committee decided that they didn't like `const_buffers_1` and `mutable_buffers_1`, so they got rid of them in the TS draft. Then they realized that having `const_buffer::begin()` would be confusing. Does it refer to the beginning of the buffer sequence, or does it refer to the first byte of that buffer? They decided to get rid of begin/end entirely for the buffer types and add buffer_sequence_begin and buffer_sequence_end in its place. And this is why we can't have nice things. > > std::size_t read_line > I am tired, but is this function O(n^2)? It starts over from the beginning of the range so there can be some overlap of the searching, yes. > cb += bytes_transferred; // adjust the pointer and size > I would maybe switch to write instead of write_some to keep the code shorter, and mention write_some as another option in text. Well the purpose of this example is to show the looping. > [](error_code ec, std::size_t bytes_transferred) > For learning purposes I would capture something in lambda by value and note that reference capture would be buggy. That is something I might consider!! Remember though I"m stuck in C++11 so no lambda capture assignment expressions. Appreciate the feedback! Regards

2 1

Coordinating Boost Releases with compiler releases
by Marshall Clow 14 Mar '19

14 Mar '19

In the thread "MSVC 2019 and 1.70 beta", there has been a discussion about what to do about support for MSVC 2019, which is due to be released right about the same time that Boost 1.70. One person suggested that we delay the boost release until after the MSVC release (I think the suggestion was "May"). This general question has been discussed before (several times), since tools get released fairly often - and so does Boost. In general, I am not in favor of delaying boost releases in order to add support for 'about to be released' development tools. There are two main reasons for this: * There's always another compiler / tool about to be released. Clang 8 is imminent - currently at RC5. GCC 9.1 is scheduled to be released in early May. * Boost releases happen every four months. August is not really that far off. People who want support for tool XXXX can use "the trunk", getting it either from git or from bintray. [ Everyone knows about the tarballs at bintray, right? https://dl.bintray.com/boostorg/master/ ] Also, if we were to delay the boost release until May, then what would happen to the August release? The release process for 1.71.0 is scheduled to start at the end of June. -- Marshall

3 3

(no subject)
by Marshall Clow 13 Mar '19

13 Mar '19

Boost release 1.70.0 beta 1 is now available at: <https://dl.bintray.com/boostorg/beta/1.70.0.beta1/source/> The SHA256 checksums are as follows: dbf89645e509acb2e53eac3c633834f1dec80bd8622e6e652a9741dcf0807f17 ./boost_1_70_0_b1.7z 957b984b58656a3ec00661ecad7ef82e3a094bad36e37b9e6624843237854679 ./boost_1_70_0_b1.tar.bz2 76d149c1fb9e8a5ceb3bc1e5587edc40fa79a43e8b990d877c2210f0382b9421 ./boost_1_70_0_b1.tar.gz 71e990b2c26880521fd98459b184ee172ce1c46dcf554b6eaab7776b8b6369a6 ./boost_1_70_0_b1.zip For details of what's in the release, see < https://www.boost.org/users/history/version_1_70_0.html>. Please download the beta, give it a try, and report any problems you encounter. Thanks, -- The Boost Release Team

2 1

Issue with boost::geometry::intersection
by Heriberto Delgado 13 Mar '19

13 Mar '19

I'm having an issue while using boost::geometry to find the intersection of two specific polygons, and looking at the evidence in front of me I can't help but think this might be a bug in the library. The two polygons in question are: POLYGON((16.8739 0.353458,8.80872e-14 5.50545e-15,0.266003 -12.6988,17.1399 -12.3454,16.8739 0.353458)) POLYGON((-4.53257e-19 2.16383e-17,9.99781 0.209424,10.1459 -6.86009,0.148086 -7.06952,-4.53257e-19 2.16383e-17)) Both of them look like two slightly rotated rectangles, first one being bigger than the other. They intersect at their upper left corner. In order to verify that these polygons CAN be intersected, I ran the following SQL sentence through SQL Server Management Studio (17.9.1): SELECT geometry::STGeomFromText('POLYGON((16.8739 0.353458,8.80872e-14 5.50545e-15,0.266003 -12.6988,17.1399 -12.3454,16.8739 0.353458))', 0) .STIntersection( geometry::STGeomFromText('POLYGON((-4.53257e-19 2.16383e-17,9.99781 0.209424,10.1459 -6.86009,0.148086 -7.06952,-4.53257e-19 2.16383e-17))', 0) ).STAsText() The resulting WKT is: POLYGON ((0.1480860710144043 -7.0695199966430664, 10.145899772644043 -6.8600900173187256, 9.997809886932373 0.20942401885986328, 0 0, 0.1480860710144043 -7.0695199966430664)) which looks about right for the requested intersection rectangle. SSMS itself displays a nice rectangle when you remove ".STAsText()" from that sentence. However, when I tried to duplicate that result using the following program using Visual Studio 2017 (15.9.8) to create an x64 console app, using boost 1.69 as a NuGet: ----------------------------------------------------------------------------------------------------------------- #include <boost/geometry.hpp> #include <vector> #include <iostream> int main(int argc, char** argv) { boost::geometry::model::polygon<boost::geometry::model::d2::point_xy<double>> first; boost::geometry::read_wkt("POLYGON((16.8739 0.353458,8.80872e-14 5.50545e-15,0.266003 -12.6988,17.1399 -12.3454,16.8739 0.353458))", first); boost::geometry::model::polygon<boost::geometry::model::d2::point_xy<double>> second; boost::geometry::read_wkt("POLYGON((-4.53257e-19 2.16383e-17,9.99781 0.209424,10.1459 -6.86009,0.148086 -7.06952,-4.53257e-19 2.16383e-17))", second); std::vector<boost::geometry::model::polygon<boost::geometry::model::d2::point_xy<double>>> results; boost::geometry::intersection(first, second, results); for (auto& result : results) { std::cout << boost::geometry::wkt(result) << std::endl; std::cout << boost::geometry::is_valid(result) << std::endl; } return 0; } ----------------------------------------------------------------------------------------------------------------- the resulting polygon is: POLYGON((0 -8.88178e-16,0.148086 -7.06952,0.148086 -7.06952,0 -8.88178e-16)) which you can easily see it's not a valid polygon, even though boost::geometry returns "1" when is_valid() is called upon it. I was planning to use boost::geometry on a large scale server application that processes quite large amounts of geometry in a similar way, and this is seriously impairing my ability to do so. Do you guys know what is going on here, and if there is a solution or workaround for it?

3 7

[release] Boost 1.70.0 Beta 1 is now available
by Marshall Clow 13 Mar '19

13 Mar '19

[ resending with a non-empty subject line ] Boost release 1.70.0 beta 1 is now available at: <https://dl.bintray.com/boostorg/beta/1.70.0.beta1/source/> The SHA256 checksums are as follows: dbf89645e509acb2e53eac3c633834f1dec80bd8622e6e652a9741dcf0807f17 ./boost_1_70_0_b1.7z 957b984b58656a3ec00661ecad7ef82e3a094bad36e37b9e6624843237854679 ./boost_1_70_0_b1.tar.bz2 76d149c1fb9e8a5ceb3bc1e5587edc40fa79a43e8b990d877c2210f0382b9421 ./boost_1_70_0_b1.tar.gz 71e990b2c26880521fd98459b184ee172ce1c46dcf554b6eaab7776b8b6369a6 ./boost_1_70_0_b1.zip For details of what's in the release, see < https://www.boost.org/users/history/version_1_70_0.html>. Please download the beta, give it a try, and report any problems you encounter. Thanks, -- The Boost Release Team

1 0

[release] Boost 1.70.0 Beta 1 Release Candidate 3
by Marshall Clow 12 Mar '19

12 Mar '19

A new release candidates for the first 1.70.0 beta release are now available at: https://dl.bintray.com/boostorg/beta/1.70.0.beta1.rc3/source/ Changes since RC2: * Relative paths for --prefix, --libdir, etc. are now bound relative to the current working directory, instead of being relative to the Jamfile. Thanks to Tom Kent for the report, and Steven and Peter for the fixes. Changes since RC1: * The Jamfile for Boost.Predef has been updated to allow running the tests from /status. Thanks to mike.dev(a)gmx.de for the report, and to Rene for the fix. The release notes are not yet available. The SHA256 checksums are as follows: dbf89645e509acb2e53eac3c633834f1dec80bd8622e6e652a9741dcf0807f17 ./boost_1_70_0_b1_rc3.7z 957b984b58656a3ec00661ecad7ef82e3a094bad36e37b9e6624843237854679 ./boost_1_70_0_b1_rc3.tar.bz2 76d149c1fb9e8a5ceb3bc1e5587edc40fa79a43e8b990d877c2210f0382b9421 ./boost_1_70_0_b1_rc3.tar.gz 71e990b2c26880521fd98459b184ee172ce1c46dcf554b6eaab7776b8b6369a6 ./boost_1_70_0_b1_rc3.zip As always, the release managers would appreciate it if you download the candidate of your choice and give building it a try. Please report both success and failure, and anything else that is noteworthy. -- The Boost Release Managers

2 3

convert separate year, month, day, hour, minute, secs, ms to milliseconds since epoch
by Victor Yankee 11 Mar '19

11 Mar '19

I am using C++14 and boost 1.64.0 (could move to newest boost), and need to convert date and time pieces to a single value for milliseconds since the epoch. This is what I have: int64_t msSinceEpoch(int year,int month,int day,int hour,int minute,int second,int ms) { struct std::tm t; t.tm_sec = second; t.tm_min = minute; t.tm_hour = hour; t.tm_mday = day; t.tm_mon = month-1; t.tm_year = year-1900; t.tm_isdst = 0; return (1000* timegm(&t))+ms; // is timegm cross-platform? } Is there a better way? Could not figure out how to use boost::chrono :( Something else? Kind Regards, Vic

5 8

SSL handshake: invalid file handle
by Osman Zakir 11 Mar '19

11 Mar '19

I have a problem with using SSL to switch from HTTP to HTTPS in a web server app I have. The code is here:https://github.com/DragonOsman/currency_converter/blob/master/currency… and my server_certificate.hpp file is herehttps://github.com/DragonOsman/currency_converter/blob/master/server_ce…. The app uses Boost 1.69.0, for Boost.Beast. I took synchronous HTTP SSL server example code and synchronous HTTP example client code from the Boost.Beast repository on here. I got the certificate from Let's Encrypt using the TXT record method, and it's a domain-specific certificate. I was told by the guys at Let's Encrypt forums that it doesn't require DH parameters, but I'd like to confirm here if it's true or not. I didn't get DH parameters. It's a certificate issued via acme.sh. The domain name is a subdomain I got for free from dynu.com; the .cer files I have are ca.cer, {DOMAIN}.cer, and fullchain.cer. I was told that I'd need fullchain.cer so I put that in as the value for the `cert` string (it consists of two certificates and I used both). The private key I have is in a .key file rather than a .pem file and I'm wondering if that's a problem. I also need to ask what I need to do with the ctx.set_options and ctx.set_password_callback methods. Could you please help me (if this is good to ask here)? When I try to visit my app in the browser while my server is running (I'm hosting it on my computer), I get this error in my console window: " handshake: The file handle supplied is not valid " And before, I also got this error: " handshake: An operation was attempted on something that is not a socket " And I also get an error page in my browser saying, "Cannot connect securely to this page". I'm using the MS Edge browser. My private key is an RSA key and the filename is {DOMAIN}.key rather than {DOMAIN}.pem. I'm sorry for repeating this. Thanks in advance for any help or replies.

1 0

Boost Log without ASIO or OpenSSL
by Macumber, Daniel 11 Mar '19

11 Mar '19

Hello, I am using Boost Log but not using any of the ASIO related functionality (that I know of). It seems that Boost ASIO depends on OpenSSL which is giving me some problems. Is there any way to either: * use Boost Log without ASIO * use Boost ASIO without OpenSSL Thanks a lot, Dan

3 6

Question on Posix timezone string
by Mats Webjörn/WIKAB 10 Mar '19

10 Mar '19

I'm using Boost 1.66 and use the following code to get a Posix string to set my uCLinux TZ environment variable to get a local time from an UTC time #include <boost/date_time/local_time/tz_database.hpp> #include <boost/date_time/local_time/local_time.hpp> tz_database tz_db; tz_db.load_from_file("./date_time_zonespec.csv"); time_zone_ptr nyc = tz_db.time_zone_from_region("Europe/Stockholm"); auto s = nyc->to_posix_string(); // "CET+01CEST+01,M3.5.0/02:00,M10.5.0/03:00" setenv("TZ", s.c_str(), 1); The odd thing is that my localtime becomes incorrect, and is actually 1 hr wrong on the opposite side of UTC. But, when I read https://www.gnu.org/software/libc/manual/html_node/TZ-Variable.html it says "The offset specifies the time value you must add to the local time to get a Coordinated Universal Time value". Not add to UTC time, which seems like the Boost Posix string assumes !!!!! Which explains why 16:00 UTC give 15:00 CET instead of 17:00 which is the correct value, when using localtime_r(). Am I missing something fundamentally, or what? Regards Mats Webjörn Webjörn IngenjörsKonsult AB Solhemsbackarna 75A SE-163 56 SPÅNGA Sweden

3 9

[Release] Boost 1.70.0 Beta 1 Release Candidate 2
by Marshall Clow 09 Mar '19

09 Mar '19

A new release candidates for the first 1.70.0 beta release are now available at: https://dl.bintray.com/boostorg/beta/1.70.0.beta1.rc2/source/ Changes since the last RC: * The Jamfile for Boost.Predef has been updated to allow running the tests from /status. Thanks to mike.dev(a)gmx.de for the report, and to Rene for the fix. The release notes are not yet available. The SHA256 checksums are as follows: 26dba8156ad08041c6da52c84a2654aefda292180afe3546a9a74dda0dfb3781 ./boost_1_70_0_b1_rc2.7z ee794d98429bc2bfae054f2fab6fde53ea95f7c5967d8b267e57c894a4d46e57 ./boost_1_70_0_b1_rc2.tar.bz2 bca5f189d87b26ab903838dee2fd4c54e9043bd35d27b8923cdef42651ae7261 ./boost_1_70_0_b1_rc2.tar.gz 6c8f3af4e64d3a04a3d3a5e98499d2f6bb460ad82c1f33ff7da800b5ab182b0b ./boost_1_70_0_b1_rc2.zip As always, the release managers would appreciate it if you download the candidate of your choice and give building it a try. Please report both success and failure, and anything else that is noteworthy. -- The Boost Release Managers

1 0

SSL handshake error "The file handle supplied is not valid"
by Osman Zakir 09 Mar '19

09 Mar '19

@chris@kohlhoff.com<mailto:chris@kohlhoff.com> I also opened an issue about this on GitHub here: https://github.com/chriskohlhoff/asio/issues/376 and I tried to make sure to provide all of the necessary information. Except I've just now updated the line numbers in my .cpp file to document the errors meaning that now the error I have reads: " Lines 576 and 577: handshake: The file handle supplied is not valid " Aside from that and the fact that I changed the datatype of "doc_root" in main and do_session to std::string, it's the same. Source code is here: https://github.com/DragonOsman/currency_converter . If I should put all of the info I have in the issue opened on GitHub here as well, please let me know and I'll do it.

1 0

[release] Boost 1.70.0 Beta 1 Release Candidate 1
by Marshall Clow 09 Mar '19

09 Mar '19

The release candidates for the first 1.70.0 beta release are now available at: https://dl.bintray.com/boostorg/beta/1.70.0.beta.1.rc1/source/ The release notes are not yet available. The SHA256 checksums are as follows: a7c570d6307d05dc8d45a3b4c69a0afdcba2b22eac0c4da4d496559f53db7b89 ./boost_1_70_0_b1_rc1.7z 4b91b9a203cf12f6001cf39de83c7cc005fbc5390e2b4b2fc29ce7b19c0537a7 ./boost_1_70_0_b1_rc1.tar.bz2 460dd6499bba9df04c6bfa219b26097bad803b8758304ba45f2fc291aa42c96e ./boost_1_70_0_b1_rc1.tar.gz f209c9a086ed2c7882a0bc8755792f436eb141eaeb8c823ed57295ca9ce25b93 ./boost_1_70_0_b1_rc1.zip As always, the release managers would appreciate it if you download the candidate of your choice and give building it a try. Please report both success and failure, and anything else that is noteworthy. -- The Boost Release Managers

3 6

[boost::filesystem::path] removing components of a path
by Sean Farrow 08 Mar '19

08 Mar '19

Hi all, I'm revisiting boost::filesystem::path after not using it for a while and wondered whether there is a way to remove parts of a path deeper than a specific directory? By way of an example, assume I have the following path declared: boost::filesystem::path path ="d:\\test1\\test2\\test3.txt" what I want to do is determine whether test2 exists as part of the path and if it does remove everything after and including the found part of the path, so in this case \\test2\\test3.txt<file://test2/test3.txt> would be removed. I could do it by converting the path to a string, but wondered whether boost::filesystem could do this natively in some way. Any help appreciated. Kind regards Sean.

3 4

[Release 1.70] Master branch is now closed for the beta
by Marshall Clow 07 Mar '19

07 Mar '19

Except with explicit permission by a release manager. Do whatever you want on develop, just don't change master. We'll re-open master after the beta. As always, check the calendar at https://www.boost.org/development 6-Mar: Boost 1.70.0 closed for all changes 13-Mar: Boost 1.70.0 beta; master branch re-opened 2-Aug: Release closed for all changes, except by permission of a release manager. 3-Apr: Boost 1.70.0 closed for all changes 10-Apr: Boost 1.70.0 release -- The release managers

1 0

Using domain-based SSL certificate with Boost.Beast
by Osman Zakir 05 Mar '19

05 Mar '19

I looked at this example server certificate in the Boost.Beast repository: https://github.com/boostorg/beast/blob/develop/example/common/server_certif… . I have a free SSL certificate that I got for my Dynamic DNS subdomain name which doesn't have DH parameters but does have a certificate chain and a private key. I don't know what to put for ctx.set_options or ctx.set_password_callback. I tried asking at Let's Encrypt as well: https://community.letsencrypt.org/t/how-to-secure-dynamic-dns/87816/19 . I decided to ask here because they said they can't advise me on how to do it with Boost. I don't want to try a reverse proxy. My current web server code can be found here: https://github.com/DragonOsman/currency_converter/blob/master/currency_conv… . [https://avatars0.githubusercontent.com/u/18173932?s=400&v=4]<https://github.com/DragonOsman/currency_converter/blob/master/currency_conv…> currency_converter/currency_converter.cpp at master · DragonOsman/currency_converter · GitHub<https://github.com/DragonOsman/currency_converter/blob/master/currency_conv…> Application for Computer Science course. Contribute to DragonOsman/currency_converter development by creating an account on GitHub. github.com [https://discourse-cdn-sjc1.com/letsencrypt/uploads/default/original/3X/c/a/…]<https://community.letsencrypt.org/t/how-to-secure-dynamic-dns/87816/19> How to secure Dynamic DNS - Help - Let's Encrypt Community Support<https://community.letsencrypt.org/t/how-to-secure-dynamic-dns/87816/19> The acme.sh certs are generally in a domain folder where the acme.sh script lives (something like ~/.acme.sh/example.com). You don’t likely need to generate a new one. community.letsencrypt.org [https://avatars3.githubusercontent.com/u/3170529?s=400&v=4]<https://github.com/boostorg/beast/blob/develop/example/common/server_certif…> boostorg/beast<https://github.com/boostorg/beast/blob/develop/example/common/server_certif…> HTTP and WebSocket built on Boost.Asio in C++11. Contribute to boostorg/beast development by creating an account on GitHub. github.com

1 0

[MPL][MP11] Return value of at_c for out of range index
by Mateusz Loskot 05 Mar '19

05 Mar '19

Hi, While porting some code from MPL to MP11, the latter helped to find some bugs in the ported code [1] I looked closer at those and found 'behavioural' differences between MPL and MP11 when accessing sequences with index value that is out of range. Could anyone help me to understand the following? 1. Why this compiles? using R = at_c<range_c<int, 0, 1>, 100>::type; Tested in C++11 using GCC, clang, MSVC from VS2017/2019 2. Why this compiles in GCC and clang, but fails with MSVC? using V = at_c<vector3_c<unsigned, 1, 2, 3>, 100>::type::type; 3. For GCC and clang, why this compiles static_assert(std::is_same<R, integral_c<int, 100>>::value, ""); but this fails? static_assert(std::is_same<V, integral_c<unsigned int, 100>>::value, ""); Don't vector_c and range_c yield equivalent sequences? By the way, MP11's mp_at_c yield void, as expected, there also no ::type or ::value member, so diagnostics is clearer. [1] https://github.com/boostorg/gil/issues/249 Best regards, -- Mateusz Loskot, http://mateusz.loskot.net

2 2

Installing multiple versions of Boost libraries on Linux: Ubuntu & Debian.
by Stephen Gray 05 Mar '19

05 Mar '19

Please could someone advise how to install multiple releases of the Boost libraries on a Linux (Ubuntu & Debian) system and set the system paths to permit switching between them; so that a compiler refers to the desired version and the relevant runtime components are available to an application; e.g. the .so file for boost serialization. Thanks.

1 0

Spatial search with boost r tree
by Bozo Vazic 01 Mar '19

01 Mar '19

Hi all, I'm trying to create a boost r tree with packing algorithm that will store 2D or 3D geometric points. This will be applied in side my peridynamic software for what we call "family search". Family search is basically a simple spatial search where each point of the peridynamic mesh (cloud of geometric points) needs to find all points inside it's horizon (horizon is for 2D a circle with a specific radius and for 3D it's a sphere with a specific radius). What I've found so far were examples for distance search using a random point (not the point that is a r-tree member). I did a distance and index check using bg::index::satisfies by passing a method that checks if the index is different and is distance smaller than radius. Also I use within(box) to constrain my search, but I'm not sure that is the correct way to use r tree spatial search for the point that is a member of the same r tree. Because as far as I understand the point in the r-tree knows has the information of boxes in which it is contained, so wouldn't there be a way to query the tree member using using only the horizon value? The reason why I'm asking this question is because I need to define most optimal spatial search so that query times don't take to long. This is important as I can have several million points that need to be constantly queried. Thnx in advance for all the help. Best Regads Bozo Here is my code for 2D search of only one point #include "stdafx.h" #include <boost/function_output_iterator.hpp> #include <boost/geometry/index/rtree.hpp> #include <boost/geometry.hpp> #include <boost/geometry/geometries/point.hpp> #include <boost/geometry/geometries/box.hpp> #include <vector> #include <iostream> namespace bg = boost::geometry; namespace bgi = bg::index; typedef bg::model::point <double, 2, bg::cs::cartesian> point; typedef std::pair<point, std::size_t> pointI; typedef bg::model::box<point> box; typedef std::pair<point, unsigned> value; bool CheckIndexAndDist(pointI i, pointI j, size_t dist); std::vector<uint64_t> res; struct StoreDataCallback { template <typename Value> void operator()(Value const& v) { res.push_back(v.second); } }; int _tmain(int argc, _TCHAR* argv[]) { std::vector<point> contourCenters; // has some value std::vector<pointI> cloud; double length = 2000; double width = 2000; double dX = length/1000.0; double horizon = 3.015*dX; for(int i = 0; i < length; i++) { for(int j = 0; j < width; j++) { point p; p.set<0>((-1.0 * length / 2.0) + dX + j * dX); p.set<1>((-1.0 * width / 2.0) + dX + i * dX); contourCenters.push_back(p); } } size_t id_gen = 0; std::transform( contourCenters.begin(), contourCenters.end(), back_inserter(cloud), [&](point const& p) { return std::make_pair(p, id_gen++); } ); bgi::rtree<pointI, bgi::quadratic<16> > rtree(cloud); // spatial search box query_box(point(cloud[10].first.get<0>() - 3.2*dX, cloud[10].first.get<1>() - 3.2*dX),point(cloud[10].first.get<0>() + 3.2*dX, cloud[10].first.get<1>() + 3.2*dX)); StoreDataCallback callback; rtree.query( bgi::within(query_box) && bgi::satisfies([&](value const& v) {return CheckIndexAndDist(v, cloud[10],3.015*dX);}), boost::make_function_output_iterator(callback)); return 0; } bool CheckIndexAndDist(pointI i, pointI j, size_t dist) { if( i.second != j.second && (bg::distance(i.first, j.first) < dist)) return true; else return false; }

2 3

Boost archive import error.
by Stephen Gray 01 Mar '19

01 Mar '19

Dear boost-users, On Debian 8 I've compiled a Python extension written in c++ using pip install against Boost_1_66_0. My source code includes: #include "boost/archive/text_iarchive.hpp" #include "boost/archive/text_oarchive.hpp" #include "boost/serialization/map.hpp" #include "boost/serialization/deque.hpp" At runtime I receive the error: ImportError: /home/stephen/envs/pyclonestream/lib/python3.4/site-packages/pyclonestream.cpython-34m.so: undefined symbol: _ZN5boost7archive18text_iarchive_implINS0_13text_iarchiveEE13load_overrideERNS0_15class_name_typeEi I don't know what's wrong here. Please, any suggestions to fix the issue?

1 0

[Concept] Understanding Boost Concept library
by Robert Jones 28 Feb '19

28 Feb '19

This is a small excerpt from the Boost Concepts library, there's various rather unusual techniques employed in it, with preprocessor tricks and various compiler specific tweeks, but this one has defeated me! What is the purpose of "*********** Model:: ***********" ? Maybe it's just to generate a distinctive diagnostic, but it's very sensitive to exact numbers of asterisks! In general what's going on here is the compiler is checking that the destructor of the Model (which is a concept instantiated with a particular type), can be instantiated, but without ever running the destructor or creating an instance of the Model. struct failed {}; template <class Model> struct requirement<failed ************ Model::************> { static void failed() { ((Model*)0)->~Model(); } }; Any insight appreciated. Kind Regards Rob.

1 0

Ambiguous symbols possibly caused by Boost 1.69.0
by tim＠raisedbar.net 28 Feb '19

28 Feb '19

Hi, I'm getting several instances of the following kind of error when I build my code, which does not use boost::thread, etc., as I use the STD versions: 1>c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.16.27023\include\condition_variable(1 24): error C2872: 'xtime': ambiguous symbol 1>c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.16.27023\include\thr\xtimec.h(18): note: could be 'xtime' 1>c:\program files\boost\boost\thread\lock_types.hpp(31): note: or 'boost::xtime' My research turned up: https://svn.boost.org/trac10/ticket/11477?cversion=0&cnum_hist=10 So I added the following value for Windows 10 to my preprocessor: _WIN32_WINNT=0x0601; Unfortunately, this makes no difference. Can anybody advise me of a way forward, please? Best wishes. Tim Burgess Raised Bar Ltd. E: <mailto:tim@raisedbar.net> tim(a)raisedbar.net M: +44 (0)7989 486976

4 10

hi i am a beginner user, there are some problem when using the library, can anyone help me with that ? plz
by ching han 25 Feb '19

25 Feb '19

i am trying to use the boost polygon function for example boost::geometry::read_wkt("multipolygon(((0 0 , 3 0 , 3 2 , 0 2)))", q); however i want to use the changing input such as "multipolygon(((A B, 0 2, 0 0, 4 0, 4 0)))" and A, B are the parameters defined by my previous array, but it ends up with showing the bad lexical cast since the parameters A and B can not be used or read if there is any solution that i can use the changing parameters as my polygon input, i kept searching for the answer but still can not find it can anyone plz help me, and i will be so grateful with that. thanks again!

2 1

[release] 1.70.0 closed for major changes
by Marshall Clow 23 Feb '19

23 Feb '19

The master branch is now closed for new libraries and breaking changes, and will be closing for the beta in one week. Also, if you're ready, you can also add your libraries' changes to the release notes at: < https://github.com/boostorg/website/blob/master/feed/history/boost_1_69_0.q… > After editing the release notes, you should get a form to create a pull request, remember to submit it, otherwise I won't see your change. As always, the calendar for the release cycle is available at: https://www.boost.org/development/ Thanks, -- The Boost Release Team

2 1

Re: [Boost-users] [boost.test] Colors
by Raffi Enficiaud 23 Feb '19

23 Feb '19

On 21.02.19 17:22, Udo Steinbach via Boost-users wrote: > Am 2019-02-20 um 22:38 schrieb Raffi Enficiaud via Boost-users: >> and this was fixed in 1.69 > > I have read it, but was so far been too lazy to compile it. > I think that colors may help with many lines of output, and only then. But > the default output of boost::test should be OK, one line. Everything else > needs attention, also no colors needed. You can set an environment variable globally if you want to avoid the default behaviour. See https://www.boost.org/doc/libs/1_69_0/libs/test/doc/html/boost_test/utf_ref… The variable BOOST_TEST_COLOR_OUTPUT is there for your need. > If you want color, you have to handle colors complete, not only 'red here, > green that'. Maybe console setup or unsuitable combinations or color > blindness (system in high contrast mode) or remote console or whatever that > you have to take into account. Right, so your problem is rather the color scheme of Boost.Test that is not playing well with your color scheme. It is true that I did not adjusted the background and I made the hypothesis of the default one. > Because color is not needed for test AND handling colors is not easy, > default should be colorless mode. I respectfully disagree with this statement. I personally like having color outputs, and combining this with log levels let me parse a big amount of information/logs significantly faster. > That are my first two general thoughts. https://en.wikipedia.org/wiki/De_gustibus_non_est_disputandum > >> open an issue next time on GitHub > > I try to avoid registration on free services. > I am fine with that. I still consult this list, although in a less regular manner. If the variable BOOST_TEST_COLOR_OUTPUT is good enough for you, or if you want an improvement, let me know. Best, Raffi

1 0

Re: [Boost-users] [boost.test] Colors
by Mateusz Loskot 21 Feb '19

21 Feb '19

On Thu, 21 Feb 2019 at 17:22, Udo Steinbach via Boost-users <boost-users(a)lists.boost.org> wrote: > Am 2019-02-20 um 22:38 schrieb Raffi Enficiaud via Boost-users: > > > open an issue next time on GitHub > > I try to avoid registration on free services. FYI, GitHub also offers paid account. Best regards, -- Mateusz Loskot, http://mateusz.loskot.net

1 0

Boost Test thread safety
by Dan Field 21 Feb '19

21 Feb '19

Hi folks: I'm trying to identify whether or not the boost Test library is thread safe in the sense that multiple threads can simultaneously interact with the library's various macros and API. I'm more interested in a single test being multi-threaded than being able to run multiple test cases simultaneously. In early documentation of the Test library (version 1.58.0 and before) , there's a section in the introduction called "Open issues" that indicates that the library is not thread-safe. However, the documentation after 1.58.0 was substantially re-written, and I don't see any discussion regarding thread safety at all. The question remains. is the Test library thread-safe or not? If there is a definitive statement regarding this issue, please let me know. Thanks in advance!

3 3

Tests: Runtime type_mismatch after upgrade to 1.69
by Florian Lindner 20 Feb '19

20 Feb '19

Crosspost from boost, haven't received any reply there, see also: https://github.com/boostorg/test/issues/199 Hello, after my distribution rolled out the upgrade to Boost 1.69 I am unable to compile my application anymore. I try to get the log_level set. Minimal compiling example: #define BOOST_TEST_DYN_LINK #include <boost/test/unit_test.hpp> #include <boost/test/unit_test_parameters.hpp> bool init_unit_test() { using namespace boost::unit_test; auto logLevel = runtime_config::get<log_level>(runtime_config::btrt_log_level); return true; } int main(int argc, char* argv[]) { int retCode = boost::unit_test::unit_test_main( &init_unit_test, argc, argv ); return retCode; } which compiles fine g++ -std=c++11 -lboost_unit_test_framework boosttesting.cpp but gives an runtime error: % ./a.out Test setup error: boost::runtime::arg_type_mismatch: Access with invalid type for argument corresponding to parameter log_level Thanks! Florian

2 1