- Boost - lists.preview.boost.org

[build] header-only lib need dir 'build'?
by Oliver Kowalke 05 Jul '17

05 Jul '17

Hi, does a header-only library require sub-directory 'build' (especially if the lib depends on another, non-header-only library)? In other words; is it safe to remove sub-directory 'build' from boost.coroutine2? thx, Oliver

2 2

[beast] write_some EWOULDBLOCK/EAGAIN error recovery non-blocking operations
by Artyom Beilis 04 Jul '17

04 Jul '17

Have been Beast tested with non blocking sockets? I hadn't found a single reference to asio's non_blocking_io? One of the common use cases is when I want to push a small message to stream (chunk). In 99% of cases the operation will not block so I want to handle this as an optimization for not returning to even loop and creating a callback. According to the reference I didn't find how write_some will behave? I expect to get EWOULDBLOCK kind of error and start asynchronous operation. However I didn't find any reference to the code to non_blocking_io so I wonder if it is supported at all. On same note - how do I run unit tests using b2 - Beast ins't fully Boostified which BTW is also bothering me. Artyom

4 6

[xpressive] Merge PR for fixing MSVC 14.1
by Andrey Semashev 04 Jul '17

04 Jul '17

Hi, There is this PR from Daniela Engert to fix Boost.Xpressive compilation failure with MSVC 14.1: https://github.com/boostorg/xpressive/pull/4 It replaces the removed std::unary_function with the equivalent typedefs. The change looks rather harmless. Could this PR be merged before 1.65 is out? Thanks.

1 1

[iterator][range] BoostIteratorTraversalConcepts-aware boost::advance/distance
by Michel Morin 04 Jul '17

04 Jul '17

Hi, The Boost iterator traversal concepts have not been adopted by the C++ Standard. Because of this, some of RandomAccessTraversalIterators (Boost's concepts) are treated as InputIterators (Standard's concepts) by the stdlib. IMHO, Boost.Iterator should provide BoostIteratorTraversalConcepts-aware `boost::advance` and `boost::distance` to avoid the inefficiencies. However, neither of them are implemented. (Boost.Range has `boost::distance` for ranges, but it just calls `std::distance`.) I'm attaching files that implement `boost::advance` and `boost::distance`. Would these functions be useful additions? Regards, Michel

4 13

[beast] Review
by Peter Dimov 04 Jul '17

04 Jul '17

This is my review of the Beast library. I. DESIGN --------- The design of the library is very good and appears mature. The concepts are well specified, well documented, well thought out. The use of concept checks is a nice touch and a mark of professionalism. I think that basing the library on ASIO (resp. the Networking TS) is a fine decision. This does mean that if one finds an ASIO/NetTS concept less than ideal, one has to live with it, but that's an acceptable tradeoff. Severing the ties with ASIO based on the yet-hypothetical "structured blobs in, structured blobs out" model may sound good in theory, but in practice, a supermajority of the potential users of Beast need to produce a working HTTP or Websocket server, and the library as it stands addresses this need. The design is not perfect; at times the library makes it much too easy for asymptomatic mistakes to be introduced by the omission of a required member function call. For example, if one forgets to set the Content-Length, everything will still appear to work; or if one forgets to initialize the .result of the response, it remains uninitialized. (Note that these, and subsequent, observations appertain to the library as submitted for review; they may no longer be relevant since the author is very quick with the fixes.) There is, at times, unnecessary verbosity, even in the two storefront examples in http://vinniefalco.github.io/stage/beast/review/beast/quick_start.html that are supposed to show the library in the best possible light. For instance, // Set up an HTTP GET request message http::request<http::string_body> req; req.method(http::verb::get); req.target("/"); req.version = 11; Every request will need a method and a target, so having to call members to set them feels unnecessary. A constructor ought to have been provided. Similarly, in the next example, // WebSocket says that to close a connection you have // to keep reading messages until you receive a close frame. // Beast delivers the close frame as an error from read. // beast::drain_buffer drain; // Throws everything away efficiently for(;;) { // Keep reading messages... ws.read(drain, ec); // ...until we get the special error code if(ec == websocket::error::closed) break; // Some other error occurred, report it and exit. if(ec) return fail("close", ec); } the drain loop is basically a requirement for every correct program, so it should have been encapsulated into a helper function. (Even though the example as written does illustrate the use of a drain_buffer.) I'm not particularly fond of the design decision to declare parts that in practice every user of the library will need as "out of scope". People should not be made to reinvent these wheels. I understand the aim of producing a standard library proposal, and that some of these wheels would not be suitable for standardization, but there's nothing easier than just including the suitable wheels in the formal proposal and omitting the unsuitable ones. In practice, these necessary parts end up as examples, so one has to #include "../example/wheel.hpp" instead of "beast/wheel.hpp". It would be better, in my opinion, if one includes, say, "beast/ext/wheel.hpp", with it being known that ext/ is where "out of scope" things go. The ASIO coupling did leave me with one question, whether it would be possible for the library to accommodate OS-specific file to socket transfers such as the one provided by TransmitFile: https://msdn.microsoft.com/en-us/library/windows/desktop/ms740565(v=vs.85).… The idea here is that the OS kernel can dump the file to the socket without involving user mode, which has the potential of much increased performance. For the median user, this would not make much of a difference, but it's an interesting design question, and perhaps an argument that the example file_body class ought to be part of the library proper. ("Is in scope", to use the preferred terminology.) II. IMPLEMENTATION ------------------ I did not pay close attention to the implementation. A random sampling reveals that it's professionally written, and it appears to work, which is good enough for me. The tests run when `b2` is invoked in `test`, have good coverage, and pass with MSVC 14.0 and 14.1. Travis/Appveyor are put to good use. The library provides a doc/Jamfile, which is a plus, but this Jamfile fails, which is a minus. The file reference.qbk has its own separate build script, and this would need to be fixed one way or another when the library is integrated into the Boost documentation build. III. DOCUMENTATION ------------------ The documentation is good. The non-reference parts are very good, the examples are informative. The reference is very good at times, and not so much at others. This is caused by the fact that to get to the good parts one needs to drill down a level or two. For instance, looking at http://vinniefalco.github.io/stage/beast/review/beast/quickref.html I noticed the "async_teardown" function in the WebSocket section, so I clicked on it to see if I need to call that to tear down a WebSocket connection. This lead me to http://vinniefalco.github.io/stage/beast/review/beast/ref/beast__websocket_… which only says "Start tearing down a boost::asio::ssl::stream/connection/boost::asio::ip::tcp::socket." Googling told me that I'm not the only one left not entirely satisfied with these descriptions: https://github.com/vinniefalco/Beast/issues/274 The confusion here stems from the fact that would I, and the issue submitter, have clicked on one of the async_teardowns in that page, we would have reached f.ex. http://vinniefalco.github.io/stage/beast/review/beast/ref/beast__websocket_… which is indeed fine, and mentions that the implementation calls this function, not the user. This is a general pattern with the reference. The leaves are perfectly fine, but the upper levels are often uninformative. IV. PRACTICAL USE ----------------- As part of conducting this review, I ported two existing servers of mine to Beast, one HTTP, one WebSocket. The HTTP server can be seen at https://github.com/pdimov/beast_tpc_server and the WebSocket one is at https://github.com/pdimov/beast_ws_async_server The experience was pleasant and things went more or less as expected, with virtually no nasty surprises. The author was very helpful. The library proper worked exactly as advertised, and the servers were both easier to write than the originals, and became more robust. I only wish that more out of scope things (target parser, basic authorization handling) become in-scope, because their absence is being felt. V. VERDICT ---------- Beast should be ACCEPTED. It's useful, it works, it serves a legitimate need, and I see no design or implementation problems that would preclude acceptance.

2 1

[gil::io] Compilation issue
by Christian Henning 04 Jul '17

04 Jul '17

Hi all, my metaprogramming zen is failing me and I like to ask for some help. Using gil's updated develop branch the following code creates a compilation error with Visual Studio 2015 Update 3. #include <boost/gil/extension/io/tiff_all.hpp> using namespace std; using namespace boost; using namespace gil; int main() { gray1_image_t img; write_view( "", view( img ), tiff_tag() ); return 0; } The compiler output is here: https://pastebin.com/raw/d1AB9QMz I think the error is in https://github.com/boostorg/gil/blob/develop/include/boost/gil/premultiply.… but I'm not sure what to do. Any help would be very helpful! Thanks, Christian

1 1

[Beast] Review
by Artyom Beilis 03 Jul '17

03 Jul '17

Hello, This is my formal review of Boost Beast. > What is your evaluation of the design? Also the general design is solid provides generic API that does the job it defined. The most problematic issue with Beast is it total reliance on static polymorphism. This comes to sometimes very painful issues like: Having the object code duplicated for different variants HTTP/HTTPS code Having all the implementation in headers increasing compilation time Adding complexity to end user since he needs to propagate the templates to various places. Virtually all concepts could be done with classic interfaces and virtual functions. Using of static polymorphism does not provide there performance advantage but reduces code maintainability and adds lots of headache to end user. Note: it does not contradict of using ASIO but lots of stuff could be pimpled or hidden having only few forward declarations of the relevant classes. > What is your evaluation of the implementation? >From what I seen didn't find may flows besides thous mentioned before (content-length - that was fixed) and non-blocking sockets aren't covered by tests. However I didn't look too much since the code is quite hard to read being too template heavy. Second major issue is that it puts all the heavy work on end user providing tiny parsing messaging layer that to be honest is the simple part of HTTP handing. It significantly limits its usability to virtually void. > What is your evaluation of the documentation? Documentation is OK - similar to ASIO - I think more examples should be needed and tutorials regarding how to do common tasks. > What is your evaluation of the potential usefulness of the library? VERY limited. The library does too little to be useful for real development. I don't really see a real need for a library that could potentially be used to create CURL or could potentially be used to write web framework that users will work over them. As a user of this library you need to deal with: - User has to have deep knowledge of HTTP protocol itself and be highly aware of various security related problems on WWW. - Protocol itself and know it up to the small details, timeouts and much more. - Being able to parse all parameters passed from getting query string, parsing multipart/form-data (a.k.a. file upload format) parse percent encoding, cookies. I suggest to drawing the line at some point when library becomes useful for somebody who for examples needs to implement RESTful service or send some post data to a form. The separation line that was drawn does not suite the needs of too many of potential users. I understand it is huge task to do but if first lines in your FAQ and many other talk about what the library doesn't do than probably something goes wrong. And please note I don't talk about sessions, url mapping, but much more basic stuff like multipart parsing, url-encoding. URL parsing, > Did you try to use the library? With which compiler(s)? Did you have any problems? Tried to compile several examples no problem. > How much effort did you put into your evaluation? A glance? A quick > reading? In-depth study? At least 10-12 hours of reading documentation, code, running some examples. Notifying potential problems. > Are you knowledgeable about the problem domain? Yes, I'm myself an author of CppCMS C++ Web Framework - fully featured web development platform for C++ that works in both synchronous and asynchronous modes, I implemented HTTP and FastCGI protocols, networking engines myself. Designed high performance services and more. > Should the library be included to Boost? Unfortunately NO. Two major reasons: - Abuse of static polymorphism where classing object oriented design with virtual functions can do better job. - The scope of the library is way too limited that it brings the question of its usability for real users. I fully acknowledge the huge high quality work the author did - something that kept me reviewing the library and providing the comments, but the library as it is today IMHO doesn't suit Boost Best Regards and Good Luck, Artyom Beilis

1 0

[Beast] HTTP/1.0 Protocol compatibility
by Artyom Beilis 03 Jul '17

03 Jul '17

I can't find there an (sami)automatic way to manage HTTP/1.0 vs HTTP/1.1 compatibility? Example I have a client that supports HTTP/1.0 only and I need to transfer an unknown amount of data. Now as one who writes the server I need to check the clients protocol and choose chucked transfer encoding with possibility to keep connection keep alive or close one after data transfer using socket shutdown. Shouldn't this kind of stuff should be handled automatically or sami-automatically? Keep alive semantics between HTTP/1.0 and HTTP/1.1 is tricky and it is very easy to make a mistake. Also note I tested some of your examples and found that they responding with HTTP/1.1 on HTTP/1.0 requests. Artyom

2 1

[property_tree] Is Boost.Property_tree maintaner active?
by Александр Зайцев 03 Jul '17

03 Jul '17

Hello. I see on Boost.Property_tree's Github repo a lot of PR. And I want to know, is maintainer active or not.

1 0

[beast] Asynchronous examples
by Phil Endecott 03 Jul '17

03 Jul '17

Hi, Do any of the Beast examples show its use in asynchronous mode? I'm wondering how difficult it is to achieve this: future< vector< byte > > data = download(url); Regards, Phil.

2 2

[beast] thread per connection example?
by Peter Dimov 02 Jul '17

02 Jul '17

Suppose that I want to implement an HTTP server that uses the thread per connection model. What example should I use as a starting point?

2 2

[beast] Wy does message<> store Body::value_type?
by Peter Dimov 02 Jul '17

02 Jul '17

Why does message<isRequest, Body, Fields> store Body::value_type, using Body::reader and Body::writer to manipulate it, instead of the more straightforward approach of storing Body, which would have allowed making `get` and `put` members of the Body directly, instead of using intermediate classes?

3 3

[beast] Automatic content-length?
by Peter Dimov 02 Jul '17

02 Jul '17

In this code, extracted from one of the examples in the documentation, // Set up the response, starting with the common fields response<string_body> res; res.version = 11; res.set(field::server, "test"); /*...*/ // We return responses indicating an error if // we do not recognize the request method. res.result(status::bad_request); res.set(field::content_type, "text/plain"); res.body = "Invalid request-method '" + req.method_string().to_string() + "'"; // Send the response write(stream, res, ec); field::content_length isn't set. Will Beast insert Content-Length based on the body size, or will it send the response with the field missing? The reason I ask is that I foresee forgetting the content_length to be a common mistake, and an asymptomatic one.

2 7

[beast] socket versus stream
by Bjorn Reese 02 Jul '17

02 Jul '17

The HTTP API provides a set of free function for all operations, so all interaction follows this pattern: operation(socket, args); The WebSocket API wraps an Asio socket in a stream, so all operations are like this: stream.operation(args); I realize that the latter choice is a consequence of using SSL, but I am wondering why there is no socket.operation(args) style for the former?

2 1

[gil::io] Dependent Name issue with VS2015 Update3
by Christian Henning 01 Jul '17

01 Jul '17

Hi all, using the new gil::io on gil's develop branch I get a compilation error with Visual Studio 2015 Update 3. When trying to read a tiff image: #include <string> #include <boost\gil\gil_all.hpp> #include <boost\gil\extension\io\tiff_all.hpp> using namespace std; using namespace boost::gil; int main() { rgba8_image_t img; read_image( string(), img, tiff_tag() ); return 0; } I get an error: error C2951: template declarations are only permitted at global, namespace, or class scope The problem seems to be with https://github.com/boostorg/gil/blob/develop/include/boost/gil/extension/io… Can someone please tell me if my issue is a compiler issue or simply a syntax error. Thanks, Christian

3 3

Re: [boost] [Beast] Questions Before Review
by Artyom Beilis 01 Jul '17

01 Jul '17

http vs WebSocket -------------------------- I noticed some strange difference in these requests : // Wrap the now-connected socket in a websocket stream websocket::stream<tcp::socket&> ws{sock}; // Perform the websocket handhskae ws.handshake(host, "/", ec); if(ec) return fail("handshake", ec); This one is fast and easy to use does all it needed Now HTTP is very different story http::request<http::string_body> req; req.method(http::verb::get); req.target("/"); req.version = 11; req.set(http::field::host, host + ":" + std::to_string(sock.remote_endpoint().port())); req.set(http::field::user_agent, BEAST_VERSION_STRING); req.prepare_payload(); Most of stuff can be defined there by default: version 1.1, Host header - required by http/1.1 why should I bother? User agent put one by default unless user wants - you do all this stuff for WS handshake so why not there? Why so complicated? ----------------- Protocol Premier HTTP/1.1 example without host. Your example isn't valid HTTP /1.1 request. HTTP /1.1 unlike 1.0 requires host header Artyom

2 4

[Beast] Security issue note
by Artyom Beilis 01 Jul '17

01 Jul '17

Looking into parser/body code I noticed: parser: void on_body(boost::optional< std::uint64_t> const& content_length, error_code& ec) { wr_.emplace(m_); wr_->init(content_length, ec); } string_body: void init(boost::optional< std::uint64_t> content_length, error_code& ec) { if(content_length) { if(*content_length > (std::numeric_limits< std::size_t>::max)()) { ec = make_error_code( errc::not_enough_memory); return; } ec.assign(0, ec.category()); body_.reserve(static_cast< std::size_t>(*content_length)); } } Basically I can exhaust the memory of the server and kill it by providing huge content length from several connections and lead to its crash. Reasonable and configurable limit should be provided for content length. Artyom Beilis

2 6

[Beast] Questions Before Review
by Artyom Beilis 01 Jul '17

01 Jul '17

Hello Vinnie Falco, I have several design questions regarding this library before the review. DISCLIMER: My name is Artyom Beilis. I'm the author of CppCMS C++ Web Framework: http://cppcms.com It may seems like it can be in some competition with Beast but I don't see it this way as Beast is too low level library that does not addresses typical problems of developers needing Web API/Site running using C++. CppCMS addresses totally different problems in different way. So there are my design related questions: Header Only Design --------------------------- As somebody who worked with guys who do web development, it was very clear that compilation time is an issue. A simple build of http_server_small.cpp example requires about 6s(!) of compilation time g++ 5.4 http_server_fast.cpp takes 7s In comparison entire message board containing templates code flow SQL and more leads to only 4s - non paralel build. (https://github.com/artyom-beilis/cppcms/tree/master/examples/message_board ) I understand that you work on base of Boost.Asio - which itself has unacceptable compilation times but having for web application development may be serious deal breaker for big projects. Which Leads me to another design Choice Template Meta-programming Based Design instead of classic Object Oriented Design ---------------------------------------------------------------------------------------------------------------- I see that almost every object there is some kind of template object. It almost mimics the API of Boost.Asio which on its way has its limitations. I remember I needed to implement FastCGI over TCP and Unix domain sockets virtually leading to same code besides some initial bind - and it required to create the entire parser using template programming because the socket itself was template object different for UNIX and TCP. I have strong feeling that lots of stuff can actually be done using classic OOP. Example Question: > Can I implement same server code for both SSL and non SSL HTTP protocol > without use of templates in the class itself? And my current final question Who are the potential users of the library? ------------------------------------------------------- If I need to send a simple http request to server it does not seem to do simple enough job (see your FAQ) so I'll probably be better with feature rich libcurl. If I need to implement complex web server/service I don't have cookies, sessions, forms, html? If I need to implement RESTful API do I have all stuff like URL mapping of different paths to callbacks, protocol abstraction http/https (basic stuff - I don't see it there correct me if I wrong) Is it for web server developers? Maybe I'd be happier with simple HTTP protocol parser that I can integrate to any socket API? Can you please give more accurate description of who is this library intended for? Best Regards, Artyom Beilis

5 21

Follow-up to the CMake follow-up
by Peter Dimov 01 Jul '17

01 Jul '17

Due to the strong interest in my previous follow-up, I'm following it up with a more complete implementation of the support required for CMake scenario #1, installing configuration files during "b2 install" such that subsequent "find_package" calls work (assuming a suitably set CMAKE_PREFIX_PATH). You can find it in branch "feature/install-cmake-config" in the superproject (boostorg/boost). In other words, git clone --recursive --depth 64 -b feature/install-cmake-config https://githib.com/boostorg/boost bootstrap b2 headers b2 install cmake//install variant=debug,release link=static,shared runtime-link=static,shared This doesn't yet support installation with more than one toolset, and I'm sure that some libraries don't work, but a simple test using Filesystem and ProgramOptions does. /// CMakeLists.txt: /// cmake_minimum_required(VERSION 3.5) project(cmake_demo CXX) list(APPEND CMAKE_PREFIX_PATH C:/Boost) find_package(boost_filesystem 1.63.0) find_package(boost_program_options 1.63.0) # disable autolink globally # could also do it per-target add_definitions(-DBOOST_ALL_NO_LIB=1) # sample program add_executable(cmake_demo cmake_demo.cpp) target_link_libraries(cmake_demo boost::filesystem boost::program_options) /// cmake_demo.cpp: /// #include <boost/filesystem.hpp> #include <boost/program_options.hpp> #include <cerrno> #include <iostream> namespace fs = boost::filesystem; namespace po = boost::program_options; int main( int argc, char const* argv[] ) { po::options_description desc( "Allowed options" ); desc.add_options() ( "help,h", "produce help message" ) ( "path,p", po::value<std::string>(), "set initial path" ) ; po::variables_map vm; try { po::store( po::parse_command_line( argc, argv, desc ), vm ); po::notify( vm ); } catch( std::exception const & x ) { std::cerr << "Error: " << x.what() << std::endl; return 1; } if( vm.count( "help" ) ) { std::cout << desc << std::endl; return 1; } fs::path p = fs::current_path(); if( vm.count( "path" ) ) { p = vm[ "path" ].as<std::string>(); } std::cout << p << std::endl; }

2 1

Does Boost 1.64 support HP-UX?
by 장윤진 30 Jun '17

30 Jun '17

I read about the platform that boost supports on the boost homepage. However, I do not know if it supports HP-UX. http://www.boost.org/doc/libs/1_64_0/libs/log/doc/html/log/installation.htm… Supported compilers and platforms. The library should build and work with a reasonably compliant compiler. The library was successfully built and tested on the following platforms: Windows XP, Windows Vista, Windows 7. MSVC 8.0 SP1, MSVC 9.0 and newer. Linux. GCC 4.5 and newer. Older versions may work too, but it was not tested. Linux. Intel C++ 13.1.0.146 Build 20130121. Linux. Clang 3.2. Does that mean it supports HP-UX?

3 2

Noexcept
by Emil Dotchevski 30 Jun '17

30 Jun '17

The lively debates during the Outcome review show that there is a great deal of interest in solving the problem of error handling in environments where C++ exception handling is unavailable. Noexcept is a new C++11 library that implements a different approach to solving the same problem. Any feedback is welcome. https://zajo.github.io/boost-noexcept/ Emil

12 81

[review] Mp11 review starts in two weeks
by Bjorn Reese 29 Jun '17

29 Jun '17

The formal review of Peter Dimov's Mp11 library is scheduled for July 15 - July 24, 2017 [1]. Mp11 is a C++11 metaprogramming library for compile-time manipulation of data structures that contain types. It’s based on template aliases and variadic templates and implements the approach outlined in the article "Simple C++ metaprogramming" [2] and its sequel [3]. These articles are useful background information for the review. * Mp11 aims to make simple usage simple, and to support complex usage without complicating the simple use cases. * Mp11 works on any type-list, whether its own type-list mp_list, or standard type-lists such as std::tuple and std::variant, or user-defined type-lists. * Mp11 works with any meta-function, such as C++11 or Boost type-traits, or user-defined type-traits. Mp11 can be found here: * Documentation: https://rawgit.com/pdimov/mp11/master/doc/html/mp11.html * Source code: https://github.com/pdimov/mp11 [1] http://www.boost.org/community/review_schedule.html [2] http://pdimov.com/cpp2/simple_cxx11_metaprogramming.html [3] http://pdimov.com/cpp2/simple_cxx11_metaprogramming_2.html

1 0

CMake followup
by Peter Dimov 29 Jun '17

29 Jun '17

In a previous post I identified several scenarios for CMake support, where number one was 1. The user installs a Boost release as usual with `b2 install`, which makes the installation visible to CMake and usable via find_package(boost_libname). For this, I said "The changes to the `b2 install` procedure significantly exceed my bjam-fu however, so if we decide to proceed with this - and I don't see how we could claim CMake support in a meaningful way without it - the interested parties would need to figure out a way to make that happen." but I lied. (Well, not entirely, I had a lot of help.) Here https://github.com/pdimov/boost-cmake-demo is a proof-of-concept implementation that more or less works for our beloved test case of Boost.System. To test (the instructions are for Windows, where I tested), clone the repo, do b2 headers b2 --build-type=complete install as usual, then b2 cmake//install variant=debug,release link=static,shared runtime-link=shared (or whatever combination of options you prefer.) This should install -config.cmake files into $prefix/libs/cmake. Then, in a CMakeLists.txt, cmake_minimum_required(VERSION 3.5) project(cmake_demo CXX) #set(BOOST_BUILD_VARIANT RELEASE) #set(BOOST_LINK_TYPE SHARED) #set(BOOST_RUNTIME_LINK STATIC) find_package(boost_core 1.63.0) find_package(boost_system 1.63.0) # disable autolink globally # could also do it per-target add_definitions(-DBOOST_ALL_NO_LIB=1) # sample program add_executable(cmake_demo cmake_demo.cpp) target_link_libraries(cmake_demo boost::core boost::system) or similar. Ideally, cmake//install would be integrated into the install target (and cmake//stage into stage, respectively.)

1 0

[iterator][utility] Move utility/next_prior.hpp to Iterator module?
by Michel Morin 29 Jun '17

29 Jun '17

Andrzej Krzemienski wrote: >> Do you mean coupling of Boost.Iterator and Boost.Range? I think that would >> be fine, since Boost.Range already couples with Boost.Iterator. >> Boost.Range's `boost::distance` should call Boost.Iterator's >> `boost::distance`. >> > > I meant `next()` and `prior()` that are located in Utility: > http://www.boost.org/doc/libs/1_64_0/libs/utility/utility.htm Ah ok, got it. I think it would be better to move utility/next_prior.hpp to the Boost.Iterator module. After the move, the Boost.Iterator module will have: - include/boost/iterator/next_prior.hpp * Contains the actual code for `next` and `prior`. (Personally, I'd like to add `boost::prev` as a synonym of `boost::prior`.) - include/boost/utility/next_prior.hpp * Just includes <boost/iterator/next_prior.hpp>. This is how utility/declval.hpp was moved to the Boost.TypeTraits module. Regards, Michel

1 0

[beast] Formal "review" branch frozen
by Vinnie Falco 29 Jun '17

29 Jun '17

The "review" branch of Beast is now available and frozen for modifications. It contains the snapshot of the repository which will undergo the Boost formal review starting on July 1 and lasting for 10 days. Currently the review branch is even with the master branch, at version 70. The review branch repository is here: https://github.com/vinniefalco/Beast/tree/review The review documentation snapshot: http://vinniefalco.github.io/stage/beast/review/ Autobahn WebSocket Implementation Test Report: http://vinniefalco.github.io/autobahn/index.html Beast is a C++ header-only library serving as a foundation for writing interoperable networking libraries by providing low-level HTTP/1, WebSocket, and networking protocolvocabulary types and algorithms using the consistent asynchronous model of Boost.Asio. Beast empowers users to create their own libraries, clients, and servers using HTTP/1 and WebSocket. Code will be easier and faster to implement, understand, and maintain, because Beast takes care of the low-level protocol details. Please don't forget to "star" the repository on GitHub, the increased exposure will vitalize Beast and Boost with the new generation of programmers! Thanks! -- Follow me on Github: https://github.com/vinniefalco

1 0