March 2018 - Boost - lists.boost.org

VS 2017 15.6 released, _MSC_VER=1913...
by Peter Dimov 07 Mar '18

07 Mar '18

... and Boost.Config once again warns: 1>c:\boost-git\develop\boost\config\compiler\visualc.hpp(349): note: Info: Boost.Config is older than your compiler version - probably nothing bad will happen - but you may wish to look for an updated Boost version. Define BOOST_CONFIG_SUPPRESS_OUTDATED_MESSAGE to suppress this message. Maybe we should display this only on 1920 and above, as I suggested last time? :-)

5 5

[gsoc18] [Boost.Intrusive] Mini version of project
by Rishija Mangla 07 Mar '18

07 Mar '18

Hello, My name is Rishija Mangla. I’m a mathematics graduate and pursuing my MCA (2nd year) from University of Delhi, India. I want to contribute in enhancing Boost.Intrusive library and have implemented a mini library for the same ( as asked for competency test ). Library includes: - Generic segment tree ( support range queries where operation is given by the user over any general class ) - Expression templates for lazy evaluation - Written test programs to check the accuracy ( using Boost.test unit test framework ) - Test cases are generated randomly Link to library implemented https://github.com/Rishija/boost_competency_test <https://github.com/Rishija/boost_competency_test> I plan to implement more complex data structures that have been mentioned in the list. I have already implemented prefix tree, both dynamic and via filesystem ( will provide link to the project in case you want to have a look ). So I’ll be pretty comfortable in developing other similar data structures and algorithms for them. Thanks

1 0

[Boost.Yap] Review results
by Louis Dionne 06 Mar '18

06 Mar '18

Dear Boost, I am pleased to announce that the Yap library is CONDITIONALLY ACCEPTED into Boost. I counted the following formal reviews: - Alex Hagen-Zanker: REJECT / CONDITIONAL ACCEPT - Barrett Adair: ACCEPT - Brook Milligan: CONDITIONAL ACCEPT - John Fletcher: ACCEPT - Paul Fultz II: ACCEPT - Steven Watanabe: ACCEPT I'd like to thank everyone who participated to the review for their feedback, and also Zach Laine for his submission. The following is a summary of the main issues that were raised during the review: - Contextual evaluation of terminals The concern was that there was no way of evaluating an expression tree with a custom context other than to first transform it with a custom transform, and then evaluate it. This, however, requires encoding the recursion into the transform even when we only want to modify terminals. After a lot of discussion, everybody seemed to agree that the following would be desirable (paraphrasing Steven): `transform_evaluate` would behave exactly like `transform`, except that the default behavior for nodes that are not handled by the context is to evaluate the operators instead of building a new expression. Zach fixed that in https://github.com/tzlaine/yap/issues/63 by introducing a new transform called `evaluation()` which evaluates terminals, and the ability to pass multiple transforms `t1`, ..., `tN` to `transform`. The first matching transform is executed, and `transform` will copy-and-recurse if no transforms match. `transform_evaluate(expr, tform)` can then be implemented as `yap::transform(expr, tform, yap::evaluation())`. - Auto-unwrapping of terminals in transform and automatic application of terminal transforms before unwrapping There was a concern that automatically unwrapping terminals in transforms and applying terminal transforms before unwrapping would result in counter intuitive behavior. After some discussion, it was determined that automatic application of transforms before unwrapping could indeed lead to surprising results and was removed. However, unwrapping of terminals is necessary to keep the matching of terminals reasonable, so it was kept. I am comfortable with that decision, as the unwrapping of terminals, which leads to a very intuitive way of matching terminals, was one of the features that sprung to me as being a great usability boost when I first looked at the library. - Positional placeholders should stay or go? Some of the reviewers felt like it was not desirable to provide positional placeholders as part of Yap, because those aren't the primary purpose of the library and C++14 obsoletes them with lambdas. Other reviewers felt like they were in fact very useful and shouldn't be removed. Since no clear consensus could be reached, no acceptance condition is attached to this issue. However, I personally favor the removal of placeholders from the core API on the basis of minimality. I would like to encourage Zach to check whether their removal would result in API simplifications; if so, I would encourage (but not require) their removal, at Zach's discretion. - Documentation The documentation is not sufficiently extensive, and takes too much for granted from the reader. This was raised by a couple of reviewers and it has been my largest problem with the library so far. More on this below. - The eval_xxx customization points. Nobody liked them, and they are already gone. - BOOST_YAP_CONVERSION_OPERATOR_TEMPLATE Nobody liked it, and it is already gone. - Short-circuiting of && and || in evaluate Steven brought up the fact that `yap::evaluate` would not short-circuit the evaluation of && and ||. This issue was mooted when customization points were removed. Also, the new `evaluation()` transform, which could suffer from the same short-circuiting problems, doesn't because it was implemented properly. - Support for Boost.Build is missing. - Hana vs not Hana Full disclosure: I am the author of Boost.Hana. A couple of reviewers raised concerns with Hana being part of the public interface. The main concern seemed to be about MSVC not being able to compile Hana, and hence Yap being unusable on MSVC. While I agree that MSVC is a big player, I believe that should not dictate what all Boost libraries do. Some libraries are meant to bridge gaps with older compilers, some libraries are cutting edge. Yap is the latter, and that's fine. The MSVC folks are working hard on their C++ conformance, and they will eventually get there. Also, it is likely that Hana wouldn't be the barrier anyway: Yap relies a lot on SFINAE and MSVC is known to be poor at it. Many of the features that one would likely want to use when using Yap are also not too well supported by MSVC, so users would probably hit limitations there anyway. Plus, as soon as MSVC is close enough, I'll start working on Hana's side to support it. Taking my review manager hat off for a second, I'd also like to point out that Yap is exactly the kind of use case that Hana was built for. Just like MPL was (and is) used in many libraries' implementation and APIs, I don't see a problem with using Hana in Yap's API, since that is the right tool for the job. That being said, if Zach wishes to explore using Hana's concepts (like hana::Sequence) to conceptify his API, I encourage him to do so. This may make it possible to use any tuple-like sequence for the children of an expression, thereby reducing the coupling between the two libraries. If Zach wants to explore using Fusion instead of Hana, that is also an option that would make MSVC support achievable. - A single macro for symmetric binary operators It was brought up that there's no macro to define both `arg <op> expr` and `expr <op> arg` at once. I believe this was initially done to avoid potential conflicts with the member variants, which already provide `expr <op> arg`. I believe it should still be possible to do it, since, as Steven said, most of the time a user will need symmetric behavior anyway. - External dependencies checked-into the repository The library includes internal copies of some of its dependencies, which is unusual for a Boost library. Zach said it wasn't his intent to put the library into Boost that way if it were accepted. To see all the issues that were raised during the review, you can search for tickets labeled with `Boost Review` on GitHub: https://github.com/tzlaine/yap/issues?q=label%3A%22Boost+Review%22 Based on the concerns above, the following lists the conditions for acceptance: - Documentation In my opinion, this was the biggest concern to be addressed. A lot of progress was made during and after the review, but I still think the documentation can be improved and made more complete. I especially believe that integrating more examples inside the "tutorial" (not just at the end) and introducing new concepts more gradually would help readers that are not already expression template gurus. It is very difficult to set a clear action item for "improving the documentation". For this reason, Brook Milligan and I will work with Zach to define what it means for the documentation to meet this acceptance condition. Brook was kind enough to agree to this when I asked him in a private communication. - A single macro for symmetric binary operators The library must provide a way to define symmetric binary operators in one go. Exactly how this can be achieved and whether we should be able to SFINAE-constrain the arguments is left to Zach's discretion. - External dependencies The external dependencies must not be packaged with the library itself. Another mechanism should be used; I leave that mechanism unspecified, but it should be possible to test the library using the usual Boost.Build workflow (e.g. an ExternalPackage download that would only work in CMake is not acceptable). - Boost.Build Yap needs to support Boost.Build like all the other Boost libraries. I will post an update to this list when the conditions of the review are met. If they wish to do so, reviewers can then verify that the conditions are met in a satisfactory fashion and the library will automatically be accepted unless someone objects. I would like to thank everyone who participated in the review, and congratulations to Zach for his library. Regards, Louis Dionne

5 7

[graph] r_c_shortest_paths writes/reads outside allocated memory
by Mateusz Polnik 06 Mar '18

06 Mar '18

Dear Colleagues, The algorithm for computing resource constrained shortest path writes/reads outside allocated memory which may result in segmentation faults. The finding is confirmed using Valgrind. I fixed the bug and opened a pull request. Could you review the pull request and give feedback if there is something more that should be done to meet quality requirements for the merge? The pull request https://github.com/boostorg/graph/pull/93 explains the issue, fixes it and contains a test for preventing regressions. Thank you in advance for your help. Regards, Mateusz Polnik

1 0

GSoc - Request for guidance
by Fady Saeed 06 Mar '18

06 Mar '18

Hello, I’m Fady Saeed. I’m Studying Computer & System Engineering at Faculty of Engineering (3rd year) at Ain Shams University in Egypt I read GSoc projects idea list and it was really interesting and I want to contribute I’m interested in contributing to Boost Geometry, Boost SafeFloat Project 1 So If it’s possible I’d like to connect to a mentor and know what should I do next and If there’s anything I need to read about so I can contribute Thanks in advance

3 2

[filesystem] Boost 1.66 fails to compile under Android NDK r16b
by Robert Dailey 06 Mar '18

06 Mar '18

I'm following a bug reported against boost filesystem here on github: https://github.com/boostorg/filesystem/issues/65 This issue has gone dead. Early on they asserted it was an NDK issue. However, the NDK developers say it's a filesystem issue. I'm not able to build Boost 1.66 with the following configuration: Android NDK Version: r16b Architecture: armeabi-v7a API: 15 Toolchain: Clang STL: libc++ (LLVM) This is blocking my migration away from GNUSTL. Can anyone confirm that this issue is being looked at? Either I'm the only one seeing this, or my toolchain combination exposes the bug but not many people build boost this way.

3 4

Proposed SG14 <system_error2> ready for feedback
by Niall Douglas 05 Mar '18

05 Mar '18

Back after the Outcome discussion died down, I started a thread discussing making breaking changes to Boost.System to test the feasibility of fixing some of the unfortunate design choices now apparent through hindsight in `<system_error>`. I won one argument - constexprification - the others I lost. I said at the time that I'd go off and make a better mousetrap i.e. a proposed `<system_error2>`. That proposed `<system_error2>` is now ready for feedback: Single file include: https://github.com/ned14/status-code/raw/develop/single-header/system_error… Github: https://github.com/ned14/status-code Docs: https://ned14.github.io/status-code/ Lots of detail about the differences between proposed `<system_error2>` and `<system_error>` is in the front page of the docs and pasted after this email, but essentially it fixes all the problems listed in https://wg21.link/P0824, and a few other problems I considered important as well. It works well in C++ 11, is believed to be freestanding C++ (https://wg21.link/P0829) friendly, and generates really lovely and tight codegen. If SG14 smile upon it in the April meeting, it'll be heading to Rapperswil for standardisation. Boost members should be aware that there will be shortly a push by the WG21 leadership to improve the current state of exception and error handling in the C++ standard as it is becoming increasingly obvious that the current design is no longer sufficient. You may see a paper on that from the leadership at Jacksonville, if not then fairly definitely you will at Rapperswil. This proposed `<system_error2>` *may* have a part to play in the reform proposals, if it is felt that this approach is a wise one by SG14, you guys here, and then WG21. So, as a quick introduction given that there is no documentation, instead of `error_code` we have a `status_code<D>` where `D` is the type of the code's *domain*. The domain provides all of the heavy lifting so status code itself can be trivial. Status codes can be type erased of their domain, you can always erase to `status_code<void>` but at the cost that it cannot be copied, moved nor deleted. If your domain's value type is trivially copyable, it can also be type erased into any `status_code<erased<U>>` where `U` is an integer type, and the size of the erased status code is bigger or equal to its unerased form. There is a special status_code called `generic_code`, which is a typedef for `status_code<_generic_code_domain_impl>`. Its value type is `errc`, which is a slight superset of `std::errc`. The reason it is special is because it is the baseline error code, all other codes must be semantically comparable to it, if that is possible. In current STL speak, `generic_code` is what `std::error_condition` with a `std::generic_category` is. On all POSIX platforms, we provide a `posix_code`. Its value type is `int`, as from `errno`. This maps the local POSIX implementation's error coding. It is *not* necessarily equal to `generic_code`, but usually is a superset, so all codes in `generic_code` can exist in `posix_code`, but not the other way round. On Windows, we have three main system error coding systems, so we have `win32_code`, `nt_code` and `com_code`. Their value types are `DWORD` from GetLastError(), `LONG` from `NTSTATUS`, and `HRESULT` from Microsoft COM. On all systems, there is a typedef `system_code` which is to the erased status code sufficiently large that you are guaranteed that all possible system error coding schemes can be safely erased into it. For POSIX, this is `status_code<erased<int>>`, as `int` can hold all possible error codings. For Windows, this is `status_code<erased<intptr_t>>`, as `intptr_t` can hold any of a `DWORD`, a `LONG` and a `HRESULT`. All comparisons between status codes are *semantic*. As in, `operator==()` returns true if the two types are semantically equal e.g. `win32_code(ERROR_SUCCESS) == generic_code(errc::success) == com_code(S_OK)`. Semantic comparison is the only form of comparison, if you want literal comparison, it can be done by hand by comparing value and domain by hand. There is no boolean testing at all, as it is ambiguous as we learned with `std::error_code`. One always writes: `if(sc.failure()) ...` etc. `status_code` can represent success codes, failure codes, and empty. Empty is there to say "no code was set". Empty is neither a success, nor a failure. It is there for code where a virtual function call to determine success/failure is too expensive and where the domain is known for a fact to only ever represent failure. You should only ever use empty as a local optimisation, and never ever expose empty status codes to code that you don't 100% control. And that's basically it. Idiomatic usage is for extern functions to return type erased status codes or to take one by lvalue reference. Code local to the translation unit uses typed status codes, and lets any implicit conversion into the erased form occur as needed. I've copy and pasted relevant excerpts from the Readme.txt below for those not willing to click on a link. If you have any questions, please do shout. My next step is to start work on preparing Outcome for entry into Boost now a month of settling time has passed since the review. Once the Jacksonville meeting has finished and I've done any post-meeting correspondence, I'll be starting on my (currently five!) papers for Rapperswil where I'll hopefully be attending my very first WG21 meeting! Niall --- Readme.md (excerpt) -- Solves the problems for low latency/large code base users with `<system_error>` as listed by [WG21 P0824](https://wg21.link/P0824). This proposed `<system_error2>` library is EXPERIMENTAL and is subject to change as the committee evolves the design. To fetch a drop-in standalone single file implementation: ``` wget https://github.com/ned14/status-code/raw/develop/single-header/system_error… ``` ## Features: - Portable to any C++ 11 compiler. These are known to work: - >= GCC 5 (due to requiring libstdc++ 5 for sufficient C++ 11 type traits) - >= clang 3.3 with a new enough libstdc++ (previous clangs don't implement inheriting constructors) - >= Visual Studio 2015 (previous MSVC's don't implement inheriting constructors) - Aims to cause zero code generated by the compiler most of the time. - Never calls `malloc()`. - Header-only library friendly. - Type safe yet with type erasure in public interfaces so it can scale across huge codebases. - Minimum compile time load, making it suitable for use in the global headers of multi-million line codebases. ## Problems with `<system_error>` solved: 1. Does not cause `#include <string>`, and thus including the entire STL allocator and algorithm machinery, thus preventing use in freestanding C++ as well as substantially impacting compile times which can be a showstopper for very large C++ projects. Only includes the following headers: - `<atomic>` to reference count localised strings retrieved from the OS. - `<cassert>` to trap when misuse occurs. - `<cerrno>` for the generic POSIX error codes (`errno`) which is required to define `errc`. - `<cstddef>` for the definition of `size_t` and other types. - `<cstring>` for the system call to fetch a localised string and C string functions. - `<exception>` for the basic `std::exception` type so we can optionally throw STL exceptions. - `<initializer_list>` so we can permit in-place construction. - `<new>` so we can perform placement new. - `<type_traits>` as we need to do some very limited metaprogramming. - `<utility>` if on C++ 17 or later for `std::in_place`. These may look like a lot, but in fact just including `<atomic>` on libstdc++ actually brings in most of the others in any case, and a total of 200Kb (8,000 lines) of text is including by `system_error2.hpp` on libstdc++ 7. Compiling a file including `status_code.hpp` takes less than 150 ms with clang 3.3 as according to the `-ftime-report` diagnostic (a completely empty file takes 5 ms). 2. Unlike `std::error_code` which was designed before `constexpr`, this proposed implementation has all-`constexpr` construction and destruction with as many operations as possible being trivial or literal, with only those exact minimum operations which require runtime code generation being non-trivial (note: requires C++ 14 for a complete implementation of this). 3. This in turn means that we solve a long standing problem with `std::error_category` in that it is not possible to define a safe custom C++ 11 error category in a header only library where semantic comparisons would randomly break depending on the direction of wind blowing when the linker ran. This proposed design is 100% safe to use in header only libraries. 4. `std::error_code`'s boolean conversion operator i.e. `if(ec) ...` has become unfortunately ambiguous in real world C++ out there. Its correct meaning is "if `ec` has a non-zero value". Unfortunately, much code out in the wild uses it as if "if `ec` is errored". This is incorrect, though safe most of the time where `ec`'s category is well known i.e. non-zero values are always an error. For unknown categories supplied by third party code however, it is dangerous and leads to unpleasant, hard-to-debug, surprise. The `status_code` proposed here suffers from no such ambiguity. It can be one of exactly three meanings: (i) success (ii) failure (iii) empty (uninitialised). There is no boolean conversion operator, so users must write out exactly what they mean e.g. `if(sc.success()) ...`, `if(sc.failure()) ...`, `if(sc.empty()) ...`. 5. Relatedly, `status_code` can now represent successful (informational) codes as well as failure codes. Unlike `std::error_code` where zero is given special meaning, we impose no requirements at all on the choice of coding. This permits safe usage of more complex C status coding such as the NT kernel's `NTSTATUS`, which is a `LONG` whereby bits 31 and 30 determine which of four categories the status is (success, informational, warning, error), or the very commone case where negative numbers mean failure and positive numbers mean success-with-information. 6. The relationship between `std::error_code` and `std::error_condition` is confusing to many users reading code based on `<system_error>`, specifically when is a comparison between codes *semantic* or *literal*? `status_code` makes all comparisons *semantic*, **always**. If you want a literal comparison, you can do one by hand by comparing domains and values directly. 7. `std::error_code` enforced its value to always be an `int`. This is problematic for coding systems which might use a `long` and implement coding namespaces within the extended number of bits, or for end users wishing to combine a code with a `void *` in order to transmit payload or additional context. As a result, `status_code` is templated to its domain, and the domain sets its type. A type erased edition of `status_code<D>` is available as `status_code<void>`, this is for obvious reasons non-copyable, non-movable and non-destructible. A more useful type erased edition is `status_code<erased<T>>` which is available if `D::value_type` is trivially copyable, `T` is an integral type, and `sizeof(T) >= sizeof(D::value_type)`. This lets you use `status_code<erased<T>>` in all your public interfaces without restrictions. As a pointer to the original category is retained, and trivially copyable types may be legally copied by `memcpy()`, type erased status codes work exactly as normal, except that publicly it does not advertise its type. 8. `std::system_category` assumes that there is only one "system" error coding, something mostly true on POSIX, but not elsewhere. This library defines `system_code` to a type erased status code sufficiently large enough to carry any of the system error codings on the current platform. This allows code to construct the precise error code for the system failure in question, and return it type erased from the function. Depending on the system call which failed, a function may therefore return any one of many system code domains. 9. Too much `<system_error>` code written for POSIX uses `std::generic_category` when they really meant `std::system_category` because the two are interchangeable on POSIX. Further confusion stems from `std::error_condition` also sharing the same coding and type. This causes portability problems. This library's `generic_code` has a value type of `errc` which is a strong enum. This prevents implicit confusion with `posix_code`, whose value type is an `int` same as `errno` returns. There is no distinction between codes and conditions in this library, rather we treat `generic_code` as something special, because it represents `errc`. The cleanup of these ambiguities in `<system_error>` should result in users writing clearer code with fewer unintended portability problems. -- ned Productions Limited Consulting http://www.nedproductions.biz/ http://ie.linkedin.com/in/nialldouglas/

5 13

Trouble getting feedback on a program_option feature PR
by Eyal Rozenberg 05 Mar '18

05 Mar '18

Hello Boosters, Following a (much) earlier suggestion on this list, I've implemented one of the features I'd like to see in program_option, and created Pull Request for initial review/feedback on GitHub: https://github.com/boostorg/program_options/pull/40 I've noticed, however, that there are 4 other unattended PRs, the earliest being from 2016. Some of them have comments such as "Can you please merge or decline?" urging a response. Also, there have been no commits for the past 4 months. I've also emailed Vladimir (Prus) last month - a short message, merely to ensure he's noticed my PR, not to demand anything; but I've gotten no reply. Now, I don't want to sound accusatory - I'm sure there are perfectly good reasons for the lack of responsiveness, and I'm very appreciate of the work of writing the library and maintaining it over the years. Still, given the situation I thought I'd bring this up here on the list. What would you suggest I do? Eyal

1 0

Gsoc2018/mentor required
by nivyatheresa 05 Mar '18

05 Mar '18

Hello, I am Nivya and I am a btech student from IIT Roorkee. I would like to contribute to the Boost.Real project. I need a mentor to help me to proceed further. Thanks in advance, Sincerely, Nivya. -- Sent from: http://boost.2283326.n4.nabble.com/Boost-Dev-f2600599.html

2 1

[serialization] RTTI issue with non-polymorphic types
by Jorge Lodos 05 Mar '18

05 Mar '18

Hi I am trying to use the serialization library for non-polymorphic types without RTTI. In release mode everything works fine, but in debug mode there are problems because dynamic_cast is used for debugging purposes. The code is in smart_cast.hpp, starting in line 87: #if ! defined(NDEBUG) \ || defined(__MWERKS__) // do a checked dynamic cast return cross::cast(u); #else I believe the first line could be replaced with: #if (! defined(NDEBUG) && ! defined(BOOST_NO_RTTI) ) \ Is this something you are willing to consider? I decided to ask before creating any ticket or pull request because there is a number of previous attempts to make serialization work without RTTI for the general case. But this is specific for non-polymorphic types. Thanks. Jorge

3 3