June 2017 - Boost - lists.boost.org

[sort] pdqsort mini-review
by Александр Зайцев 27 Jun '17

27 Jun '17

Hello. Try to send my thoughts from another email. 1. Are there any specific concerns you have about pdqsort vs. std::sort? 2. Does it compile for you when you try to use it as a replacement for std::sort? 3. How does the performance compare on your system vs. std::sort? 4. Do you think we should include pdqsort in Boost.Sort? 5. Do you have any concerns about switching the default/fallback sort in Boost libraries (including Boost.Sort) from std::sort to pdqsort? 1. Only that pdqsort is really better than std::sort's Introsort 2. Yes, it does. 3. Pdqsort is much faster than std::sort. 4. Yes, i do. I think that pdqsort is really good sort algorithm - it's really fast and pdqsort is already implemented sort algorithm in Rust's libcore as sort_unstable. 5. No, i have not. Best regards, Alexander Zaitsev mazahaka2009(a)list.ru

1 0

Interest in another formatting library ?
by Roberto Hinz 27 Jun '17

27 Jun '17

Hi, Is there space for another formatting library in Boost? Anyone interest in this one? doc: https://robhz786.github.io/stringify/doc/html/index.html code: https://github.com/robhz786/stringify

5 11

Cmake
by Peter Dimov 26 Jun '17

26 Jun '17

There is considerable interest in Boost supporting CMake, but it seems that everyone has different ideas as to what this support will entail. After deliberation and discussions, I have identified the following (separate) scenarios: 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). 2. The user brings several Boost libraries as git submodules into his CMake-based project and uses add_subdirectory in his CMakeLists.txt to link to them. 3. The user uses CMake to install an individual Boost library, which is then available for find_package. 4. The user uses CTest to run the tests of an individual Boost library. 5. CMake is supported as a way to build and install the entire Boost, in place of b2. 6. CTest is supported as a way to run the tests for the entire Boost, in place of b2. At the moment, I think that we should concentrate on (1) and (2) as providing most bang for the buck. 5-6 in particular require that all Jamfiles are ported at once, which is a serious undertaking for a questionable benefit as what we have already works. I've done a proof of concept for (2), which can be seen here: https://github.com/pdimov/boost-cmake-demo-2 This repository uses git submodules in ext/ to bring in Boost.System (our guinea pig) and its dependencies, then uses them via add_subdirectory in https://github.com/pdimov/boost-cmake-demo-2/blob/master/CMakeLists.txt The required CMake infrastructure is on branch feature/cmake in those six libraries (assert, config, core, predef, system, winapi.) It consists of CMakeLists.txt in the root: https://github.com/boostorg/system/blob/c306d479e8326a68d07ee7f058a415fe8b6… and supporting .cmake files in cmake/ : https://github.com/boostorg/system/tree/c306d479e8326a68d07ee7f058a415fe8b6… The goal here is for Boost library developers to be able to remain ignorant of CMake if they so choose; so of those files, only sources.cmake requires their input (it's empty for header-only, so those require nothing at all.) BoostVersion.cmake and default.cmake are common for all libraries and are copied from the superproject. dependencies.cmake is automatically generated with boostdep. There is a Jamfile in cmake/ that updates these three files: https://github.com/boostorg/system/blob/c306d479e8326a68d07ee7f058a415fe8b6… and the intent is for this to be done automatically in a superproject script that invokes "b2 cmake" for the superproject: https://github.com/pdimov/boost-cmake-demo/blob/master/cmake/Jamfile which in turn invokes "b2 cmake" in each library having "cmake/Jamfile". Copying BoostVersion.cmake and default.cmake, instead of referring to them, allows libraries to be used without a superproject, to support scenarios (2) and (3) above. (Scenario (3) is also supported by default.cmake.) What remains to be done is (a) to extend this to the rest of the Boost libraries, if we decide to do so, which would require figuring out a way to cope with the numeric/ irregular libraries, and (b) support for scenario (1) above. Scenario (1), that is, `b2 install` making the installed Boost available for CMake find_package use, is an entirely separate undertaking, completely independent of what I've done - except for possibly reusing the dependencies.cmake files. It would entail generating boost_libname-config.cmake and boost_libname-config-version.cmake files for each library, and boost_libname-config-<suffix>.cmake subconfiguration files for each build variant (toolset, variant=debug/release, link=static/shared, runtime-link=static/shared, runtime-debugging=on/off, threading=single/multi, and possibly python-debugging=on/off.) This would probably require us to define CMake variables controlling these features, such as BOOST_BUILD_TOOLSET, BOOST_BUILD_VARIANT, BOOST_LINK_TYPE, BOOST_RUNTIME_LINK, and so on, with them having appropriate default values inferred from the CMake environment. Then, boost_system-config-vc141-mt-gd-1_65.cmake will check these values and if BOOST_BUILD_TOOLSET is "vc141", BOOST_LINK_TYPE is SHARED, BOOST_RUNTIME_LINK is SHARED and BOOST_RUNTIME_DEBUGGING is ON, it will declare an imported target pointing to boost_system-vc141-mt-gd-1_65.lib/dll, otherwise it would do nothing. (Not sure how relevant is threading=single/multi today, but in principle, it should also check BOOST_THREADING == MULTI.) Generating these -config.cmake files would ideally be done as part of the `b2 install` procedure and require no changes to the individual libraries. 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. At this point, I know what needs to be done, but not how to bring it about.

16 67

Re: [boost] What's wrong with top-posting?
by Brian Wood 26 Jun '17

26 Jun '17

David Abrahams writes: > At Tue, 26 Jan 2010 10:09:43 -0800, > Robert Ramey wrote: >> > > I thought I was familiar with the guidelines and never remembered this. >> >> I top-post all the time. It seems much more natural to me when >> it's not convenient to intersperse comments into the previous >> message. Why I like top posting: >> >> a) It means that I don't have to scroll to the bottom of a message >> which is sometimes pretty long. >> b) To me it is more natural to follow the style >> of other communications (artilcle, books, etc) which make >> their point in the main text and refer to footnotes, bibliographies, >> etc at the end of the main text. > > c) You don't confuse or even *upset* (as I've discovered the hard way) > many people in the business world, where top-posting and > overquoting is the accepted standard. Every message drags along > the entire thread history with it, and you keep a record of > everything by storing the final message. (yuck) It's a cultural > thing, and Boost fits into the open-source programmer weenie > culture much more than the business culture. I was getting annoyed by some top-posting here recently, so I dug up this thread. Is an "open-source programmer weenie culture" like a nerdy culture? Anyway, please stop top posting and trim the old parts of the thread that are no longer needed. Brian Ebenezer Enterprises - In G-d we trust. http://webEbenezer.net

4 3

[outcome v2] Please comment on new result<T, EC> reference API docs
by Niall Douglas 26 Jun '17

26 Jun '17

Dear Boost, I've been hard at work refactoring Outcome to match the peer review a few weeks ago. Much comment at the time mentioned the poor experience of the reference API docs, so can I get a community check of this: https://dedi4.nedprod.com/static/result-v2/doc_result.html This was generated by the new C++ reference docs generator https://github.com/foonathan/standardese. You'll no doubt spot quite a few formatting bugs, Jonathan says he's onto them. But the usage of libclang rather than doxygen's broken C++ parser clearly shows a lot of benefit, it's just standardese still remains quite a lot short in terms of necessary features to make output fully correct. I won't give the changelog for Outcome v2 result<T> over Outcome v1 yet. Let's see how you fare with the above reference API docs first. But as you'll note, there is considerable change over before as we now slot into a niche not occupied by Expected nor EitherMonad, indeed this now looks much more like Robert's or Lawrence Crowl's slimmed down object. This result<T> is approx 0.6 CPU cycles per stack frame unwound slower which I feel is acceptable in exchange for no more variant storage, which in turn released lots of SFINAE budget for me. (FYI v2 outcome<T> isn't done yet, but it will extend v2 result<T>) Niall -- ned Productions Limited Consulting http://www.nedproductions.biz/ http://ie.linkedin.com/in/nialldouglas/

5 31

[container] includes nonexistent file
by Peter Dimov 25 Jun '17

25 Jun '17

Primary dependencies for container: (unknown): <boost/intrusive/detail/to_raw_pointer.hpp> from <boost/container/detail/to_raw_pointer.hpp> Boostdep says that <boost/intrusive/detail/to_raw_pointer.hpp> doesn't exist, and I indeed don't see it.

2 1

[program_options] behaviour change for implicit options
by Vladimir Prus 25 Jun '17

25 Jun '17

Hi, I have committed, and merged to master, a change making program_option consider subsequent tokens for values of implicit options. For example, if "foo" is implicit option and "bar" is some other option, then: 1. "--foo --bar" will be parsed as option "foo" followed by "bar", and implicit option for "foo" will be used. 2. "--foo bar" will be parsed as option "foo" with the value of "bar" This is the way things worked prior to 1.59, was changed in 1.59, continued to cause confusion, and is now reverted back. For background, see: - http://permalink.gmane.org/gmane.comp.lib.boost.devel/269832 - https://github.com/boostorg/program_options/issues/25 Just in case client code might need to check this behaviour, I've added a feature macro, BOOST_PROGRAM_OPTIONS_IMPLICIT_VALUE_NEXT_TOKEN, which will be set to 1 starting with 1.65. Thanks, Volodya

1 0

Boost MSM attribute sharing problem
by Denis Kotov 25 Jun '17

25 Jun '17

Hello everyone, I have an issue with* Boost MSM*. Using *Boost MSM eUML* I have created a state machine. Actually I created *HSM* (Hierarchical State Machine) or Composite State Machine as second name. And I faced with issue: How to share attributes between Parent State Machine and Sub-State Machines (or Child State Machine) ?? I have not found an answer on this question ... Could anyone possibly help me ? *Thanks,* *Best RegardsDenis Kotov*

1 0

Noexcept improvements
by Emil Dotchevski 25 Jun '17

25 Jun '17

I've completed a second iteration on Noexcept, incorporating valuable feedback from the previous discussions here, and I'd like to thank everyone who participated. https://zajo.github.io/boost-noexcept/ The new result<T> type has a hard value-or-error invariant and can be used to transport errors between threads or to temporarily postpone the consumption of function results, e.g. by storing result<T> objects into a queue (of course, as before, users do not need result<T> just to report a failure from a function.) There is also a new macro, BOOST_NOEXCEPT_CHECK, which makes writing error-neutral functions easier and improves error checking in general. The documentation is also much more complete, including better examples and a new section on programming techniques.

1 0

Fw: [stacktrace] [winapi] header out of place
by Peter Dimov 24 Jun '17

24 Jun '17

The header stacktrace: boost/detail/winapi/capture_stack.hpp should probably either be moved to Winapi, as the name suggests, or renamed to reside in boost/stacktrace/detail. And, as a general rule, libraries should strive to keep their headers under boost/<libname>, with the only exception being boost/<libname>.hpp. We have many legacy libraries not following this requirement, but any new ones and any new headers added to existing ones should. The reason for this requirement is that otherwise it's impossible to perform dependency analysis unless all of Boost is checked out so that the tool can tell in what module boost/random-header-name.hpp resides.

3 2

[review] Boost.Nowide is Accepted into Boost
by Frédéric Bron 24 Jun '17

24 Jun '17

Dear all, I would like to thank all the people who took part in the discussions during the review. All contributors admitted that Boost.Nowide addresses a real issue and solves it, at least partially. Moreover we received 8 official reviews with 6 “accept”, 1 “do not accept as is” and 1 “I am not against it”. So Boost.Nowide is accepted for inclusion in Boost. Congratulation and many thanks to Artyom Beilis for this contribution. However, 2 major issues arose in the discussions and they will have to be fixed before inclusion: 1. handling of ill-formed Unicode input should be improved/clarified 2. the documentation needs improvements In particular, this needs to be fixed: * Design: There was a lot of discussions on what to do with ill-formed UTF-16 strings on Windows, in particular coming from the file system while converting them to narrow UTF-8 strings. Basically, 3 options: 1. allow the roundtrip ill formed UTF-16 > UTF-8 > ill formed UTF-16, this is not possible with UTF-8 encoding, WTF-8 (not a standard) may be an option with some issues 2. issue an error (today’s nowide option, even if the author would like to move to 3.) 3. convert as much as possible to fully conformant UTF-8 with character replacement U+FFFD for invalid input. This is what the NT kernel does with functions like RtlUTF8ToUnicodeN. This would allow cout to continue to work after invalid output instead of failing. After reviewing what was chosen for std::filesystem in C++17, I think 3. is the right think to do: - std::filesystem::path::u8string does not convert strings on Posix. If a conversion is done (on Windows) the output is fully conformant UTF-8. - the roundtrip is not guaranteed in std::filesystem::path conversions (implementation defined) but the roundtrip of a converted paths is guaranteed to work which is the case with Boost.Nowide: once in fully conformant UTF-8, narrow > wide > narrow works fine. - the use of the replacement character U+FFFD is what is done by the NT kernel (question: do you have to reimplement RtlUTF8ToUnicodeN and RtlUnicodeToUTF8N, why not using them)? It should been made clear in the doc that this choice does not guarantees the roundtrip on Windows so that ill-formed filename may not be opened. * Documentation: - the main part of the doc (the non-reference part) should be more detailed - it should be clear to the reader that Windows and Posix platforms are not handled the same; on Windows, we get UTF-8 strings while on Posix platforms, the user should not expect UTF-8 encoding, just narrow strings, even if UTF-8 is today the most common encoding (addressed in Q/A but is probably too far away). It must be clear from the beginning that on Posix platforms, the library does nothing (including no checking of UTF-8 conformance), just forward to the standard library. - review the use of UTF-8 so that it do not let think that narrow strings are always UTF-8 as this is not necessary the case on Posix platform; maybe just use narrow string? - clarify what is converted to what and when: for each function, we need to know precisely what is the output for all possible input; in particular, better explain for each function what the library does with ill-formed input (either UTF-16 input or narrow input), in particular for args and getenv; say clearly what happens (failbit, error, exception, invalid character…) - clarify what is done for Windows and what is (not) done for Posix - explain better what is behind nowide::cout, cin, cerr, what is done? - clarify what does the filesystem integration on Windows vs Posix - check if basic_stackstring::swap needs to swap buffer_ when both strings are on the stack - The doc/ directory is missing a Jamfile, and there's also no meta/libraries.json. * Implementation: - The global BOOST_USE_WINDOWS_H macro should probably be respected. When windows.h is not used, the WinAPI prototypes are declared in the global namespace. This can cause issues when windows.h is also included before/after the Nowide headers, and the prototypes don't match exactly (e.g. short vs. wchar_t). Also it pollutes the global namespace. Nowide should do what other Boost libraries do, and declare the prototypes in a private detail namespace instead. Example in <boost/thread/win32/thread_primitives.hpp>. Need to add a namespace around your definitions. - MinGW gcc: fix warnings in c++03 mode and errors in c++11 and above - Cygwin gcc/clang (errors because of missing ::getenv and friends) - when this is fixed, an error remains: in file included from test\test_system.cpp:11:0: ..\../boost/nowide/cenv.hpp: In function 'int boost::nowide::putenv(char*)': ..\../boost/nowide/cenv.hpp:104:41: warning: comparison between pointer and zero character constant [-Wpointer-compare] while(*key_end!='=' && key_end!='\0') - Under MSYS, one test failed Fail: Error boost::nowide::cin.putback(c) in test_iostream.cpp:17 main - filesystem integration should return somehow the previous locale for potential undoing * Misc: - There are no .travis.yml and appveyor.yml files in the root. - a number of copy/paste references to Boost.System (test/Jamfile) and Boost.Locale (index.html), should be corrected This are just suggestions and are not mandatory for acceptance: - implement stat/opendir/readir - integration with boost::interprocess::file_lock - integration with boost::program_options (in particular for correct line breaks when showing options) Frédéric

3 4

Re: [boost] [review] Review of Nowide (Unicode)
by Groke, Paul 23 Jun '17

23 Jun '17

Hi, this is my official review of the Nowide library. I haven't had much time to look at Nowide, but I have noticed some things that might be of interest, so here we go... > - What is your evaluation of the design? Overall the design looks good. Some things I'd suggest to reconsider: * I'm a big fan of "try" names, so I'd suggest to rename the array versions of widen/narrow to try_widen/try_narrow. Makes it more clear that they can fail without throwing. Also I'm not sure about the benefit of returning the output buffer pointer or NULL. I'd simply return bool instead. * nowide_filesystem... to be honest I'm not sure what this does. If it does something related to UTF-8 on POSIX systems, then I smell a potential problem. If it's only for wide->narrow on Windows, it should be OK. * Also not sure what boost::nowide::cin/cout/cerr do. Do they call SetConsoleCP/SetConsoleOutputCP? Will they work with re-directed input/output streams? What will happen if the user uses them AND std::cin/cout/cerr or stdin/stdout/stderr in the same application? * I'm not a big fan of the basic_stackstring classes. I'd suggest to provide template function overloads for narrow/widen instead. Like: users_favorite::wstring_class wstr; if (boost::nowide::try_widen(wstr, str)) use(wstr); else too_bad(); They could write to the target-string using the usual duck-typing - e.g. via clear/push_back or clear/back_inserter. That way the user can use whatever SSO string class he likes and Nowide wouldn't have to provide string classes -- which IMO isn't its job. As a bonus, the user also gets an exception-free (except bad_alloc) function that doesn't require him to provide a raw array output buffer. * The Windows & invalid UTF-16 thing... I still think invalid UTF-16 should round-trip. > - What is your evaluation of the implementation? Haven't had much time to check the implementation. What I did notice is that when windows.h is not used, the WinAPI prototypes are declared in the global namespace. This can cause issues when windows.h is also included before/after the Nowide headers, and the prototypes don't match exactly (e.g. short vs. wchar_t). Also it pollutes the global namespace. I think Nowide should do what other Boost libraries do, and declare the prototypes in a private detail namespace instead. > - What is your evaluation of the documentation? Incomplete. Too few examples and the reference documentation leaves many things unclear. IMO the reference documentation should unequivocally define the contract of each API. Also I think the documentation should make it very clear what Nowide does and doesn't do on different platforms. Especially that it doesn't do anything Unicode-related on POSIX platforms and that using it does NOT mean the application will only have to deal with UTF-8 strings on POSIX platforms. Also parts of the documentation that suggest or even _state_ that systems like Linux internally use UTF-8 should be fixed. > - What is your evaluation of the potential usefulness of the library? I'd say it's useful. > - Did you try to use the library? With what compiler? Did you have any > problems? No. > - How much effort did you put into your evaluation? A glance? A quick > reading? In-depth study? Quick reading of the documentation + some very quick glances at parts of the implementation. > - Are you knowledgeable about the problem domain? More or less. I have never used or written a "nowide" layer myself, but I have spent plenty of time "widening" Windows-only applications. > And most importantly: > - Do you think the library should be accepted as a Boost library? Be sure to > say this explicitly so that your other comments don't obscure your overall > opinion. I certainly wouldn't vote against it. I didn't spend enough time to understand every aspect of it though, so I don't feel qualified to vote for it either. I would however suggest to require a major update of the documentation before accepting it. Regards, Paul Groke

4 12

Re: [boost] [cmake] Minimum viable cmakeification for Boost
by Thomas Heller 23 Jun '17

23 Jun '17

Am 20.06.2017 5:08 nachm. schrieb "Niall Douglas via Boost" < boost(a)lists.boost.org>: >> Niall says that using the global BUILD_SHARED_LIBS is a cmake2ism, and >> that explicit targets are preferred nowadays. > > Niall, can you point me to a reference stating this? Preferably some cmake > documentation telling me what the right(tm) thing to do is. Any cmake construct which requires you to write an if() in a non-root-level CMakeLists is a cmake2-ism. There are a very few places in cmake3 remaining where no good alternative to global variables exist. BUILD_SHARED_LIBS is definitely not one of those. I'll ask again: do you have any reference to those statements? The official cmake docs seem to disagree about this specific case. I would even call it non sensical alltogether. Why should the root cmake be responsible for configuring a specific sub module. This is asking for cluttering everything into one single entity in a (almost) totally unrelated place. Why not keep it local to where it should be used. One concrete example: I have networking layer which supports different transports, say tcp, libfabric, MPI and infiniband verbs. The user of my library doesn't really care about which one is used, so ideally, I would give him a compiled version of my library with the internal settings I believe are best for him. In that case, my network layer module would be configured with one of those options. Naturally, I would think, those options are defined within this very sub project. The root project really doesn't care, nor do I want that this implementation detail leaks into the users CMakeLists.txt. Would you consider that bad practice to begin with? How would you solve this? There are tons of other use cases very similar to that. Having everything clobbering up in the root Cmakelists.txt doesn't sound appealing to me. Shared libraries usually have different settings to static libs and again to header only libs. They have different relationships to their dependencies, different usage requirements for consumers. You can use generator expressions to encode those differences, but then you've hard coded them so external cmake no longer can easily override them. You have just made your non-root CMakeLists hard to reuse by cmake you didn't write nor design. Generator expressions are also hard to write and debug, are overwhelmingly confusing to read, and randomly don't work in some places depending on which build system generator you are using. So best avoid all of that complexity - place no complexity at all outside the rootlevel CMakeLists. Declaration only. Place all custom logic solely in rootlevel CMakeLists only. > Any definite source on what a cmake2ism is or is not would be highly > appreciated. > > > As a general observation, I see a lot of statements along the lines of "I > state that XYZ is preferable over UVW", it would be nice to have to have > background information (pros and cons anyone? what do the cmake > authors/docs have to say about this?) on those statements so that everyone > can form their own opinion instead of having to choose whom to trust about > what's "standard" cmake. I believe Stephen Kelly is negotiating a book deal on this. It'll be some time before that book lands though. Niall -- ned Productions Limited Consulting http://www.nedproductions.biz/ http://ie.linkedin.com/in/nialldouglas/ _______________________________________________ Unsubscribe & other changes: http://lists.boost.org/ mailman/listinfo.cgi/boost

13 42

[build] Use address-model in library filenames
by Vinnie Falco 23 Jun '17

23 Jun '17

Please add the address-model (32 or 64) into the encoded name which describes a library, so that 32-bit and 64-bit libraries may reside in the same dir. I'd like to avoid a lengthy debate, and if no one wants to do it just provide me with working code for accomplishing it and I'll submit a pull request. -- Follow me on Github: https://github.com/vinniefalco

5 4

Outcome/expected/etc/etc/etc
by Gottlob Frege 22 Jun '17

22 Jun '17

I've now read ALL the emails. Here's some thoughts, in no particular order. - I wonder, Niall, if your uses of the empty state could/should be compared to how people sometimes use -1 or 0, etc - ie "special values as errors". I typically don't like that pattern (yet I've done it anyhow - performance/laziness/etc - but typically only in localized cases, not in "APIs"). So I'm wary about this empty state thing. If we do have an empty state, I like it as a separate type - code needs to deal with it separately. I like the idea of taking a possibly-empty type, checking for empty, and creating a never-empty type, and passing that along so future code need not worry. - I think the narrow and wide contracts should be in the same type, not separate types. This is C++. I suggest "access" if you want long names. ie T & val = oc.access_value(); // possible UB (I almost also suggested "deref" but "deref_value" is wrong - you are deref'ing the outcome, not the value) - I agree with Vicente's concern that functions that behave differently need to be named differently. I haven't looked at the new (or old) API carefully enough, but as a (possibly hypothetical) example: wide_type::value() // returns value, or throw if no value narrow_type::value() // returns value, or UB if no value These functions are not the same, and should not be named the same. Since you thus need different names anyhow (ie value and access_value), why not put them both on the same API? I'm not yet sure if you end up with similar examples with possibly_empty_type::something() and never_empty_type::something(). - I see value in the idea that the narrow contract takes more typing, but I actually *like* using * and -> for the narrow contract because I have 30+ years of training in looking at * and -> and recognizing it as "this may be unsafe, examine the code to see how it is guaranteed". Boost.Optional specifically chose * for that very reason. (on the other hand, I have 0 training on spotting access_value(), but on the third hand, it is easy to grep for) - exception() returns error, error() doesn't return exception, etc: would it be better/easier/clearer if we introduced another name, such as "failure" or whatever? ie exception() only returns the stored exception, error() only returns the stored error(), and then has_failure() would return true in either case, failure_exception() returns exception, generates an exception from error if necessary, etc? - I dislike "exceptions are for exceptional circumstances". Yes it is a common thing, but it is usually wrong. Using Outcome to enable the pattern of "handle errors, but totally cancel the operation on exceptions" might actually turn out to be a useful pattern, but I think this is actually slightly different from the "exceptions are for exceptional cases" camp, as they typically use that chant to choose whether their API will use exceptions or errors, not both in a single API. So I agree with Emil - for most APIs, error-codes vs exceptions" is basically trying to handle the same thing - failure (or "disappointment"). Using both error-codes and exceptions in a single API is somewhat new. And interesting. (There is lots of code that almost-unknowingly uses error-codes and exceptions in the same API, but that is because they don't realize push_back throws or they pretend it doesn't, etc - it isn't really an API design choice) - this ring buffer thing sounds interesting. I haven't looked at it at all, so maybe this makes no sense: should it use thread-local? - I think std::expected should always throw something deriving from std::exception. So if E derives from std::exception, we can throw it. If E is exception_ptr we can (re)throw it. If E is error_code/system_error/etc we can figure out what to throw. If E is user-type, then we wrap it in bad_expected or whatever. (And/or allow user E-to-exception customization somehow). This sounds complicated, but it is easily summarized/taught as "the standard always throws std::exceptions" - I HATE the dual interface of std::filesystem. Worse, there is a chance it is setting a precedent for future std APIs (dual APIs have been proposed elsewhere). Let's please kill it before a dual API strikes again. However, the other problem with trying to "single-fy" the std::filesystem (or any other) API is that users who want error codes sometimes don't want the cost of the extra data (paths, etc). The only way to handle that may be with customizable callback functions that capture the error-info however you like, or something similar to callbacks. - I really look forward to Peter's never-empty variant - and have been hoping for one ever since std::variant was finalized. Not because I dislike std::variant, but just because I think the option should be there for those who need/want it. Regardless, std::variant, in my world, is never empty, since it is only empty when a move operator throws, which should be never and/or when I can't allocate 64 bytes, in which case I'm screwed anyhow. Some days I'm like "man just accept empty, it would be a simple API", but then I think "it is stupid for variant<int, double> to be empty". Other days I think "just double buffer when necessary" (I assume that's your direction Peter?), but then I think "I don't want double-buffering variant<list, vector> to go on/off based on whether I use MS std vs libc++ etc" and also "I don't want double buffering for cases that only happen in theory, not in practice". I like the trade-offs of std::variant. I do agree that Boost should have a variant2 with different choices than std::variant - I think that actually helps the standard - we can choose a direction and instead of telling people "tough luck" when they disagree, we can say "use boost variant2 when you want those properties". - Andrzej: > Actually, now I am thinking not about Boost.Outcome but specifying these > preconditions in the Standard. If you want to std::terminate upon some > condition rather than let the program do random things, you could say. > > *Requires:* `!r` with rescue action `std::terminate()`. This sounds a bit like the contracts proposal - where you get to define what happens when contracts are broken. I'm cautiously hopeful that contracts could help with LEWG's constant struggles with wide vs narrow. - I agree with those who were saying (or thinking) that Boost was - and should again be - the place where APIs go before going into the standard. APIs (mostly) shouldn't bypass boost and go to the standard directly. Or at least an API needs a similar user-base (both in scale and diversity - ie an internal google API has scale, but not necessarily diversity). Since I know a number of LEWG members agree with me on this, don't be surprised to see some push-back from the committee for proposals without that kind of backing, and also don't be surprised if Boost gets flooded with "the committee told me to come here first". Of course I don't speak for LEWG, so maybe none of that happens, we haven't had that discussion yet. I actually probably had more to say - I should have made notes as I was reading all... those... emails. Tony

10 75

[review] Review of Nowide (Unicode) starts today
by Frédéric Bron 22 Jun '17

22 Jun '17

Hi Everyone, The formal review of Artyom Beilis' Nowide library starts today and will last until Wed. 21st of June. Your participation is encouraged, as the proposed library is uncoupled, focused and rather small. Nowadays, everyone needs to handle Unicode but this is very difficult using only the standard library in a platform independant way. Nowide offers a very simple way to handle Unicode the same way on Windows/MacOS/Linux. Key features: * work with UTF-8 in your code, Nowide converts to OS encoding * Easy to use functions for converting UTF-8 to/from UTF-16 * A class to fixing argc, argc and env main parameters to use UTF-8 * UTF-8 aware functions: - stdio.h functions (fopen, freopen, remove, rename) - stdlib.h functions (system, getenv, setenv, unsetenv, putenv) - fstream (filebuf, fstream/ofstream/ifstream) - iostream (cout, cerr, clog, cin) Documentation: http://cppcms.com/files/nowide/html GitHub: https://github.com/artyom-beilis/nowide git clone https://github.com/artyom-beilis/nowide.git Latest tarballs: - to be unzipped in boost source: https://github.com/artyom-beilis/nowide/archive/master.zip - as a standalone library: http://cppcms.com/files/nowide/nowide_standalone.zip Nowide has standard boost layout. So, just put it into the boost source tree under libs/nowide directory for building and running tests. Or alternatively - for header only part of the library add the nowide/include path to the include path of your projects. Please post your comments and review to the boost mailing list (preferably), or privately to the Review Manager (to me ;-). Here are some questions you might want to answer in your review: - 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 what compiler? 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? And most importantly: - Do you think the library should be accepted as a Boost library? Be sure to say this explicitly so that your other comments don't obscure your overall opinion. For more information about Boost Formal Review Process, see: http://www.boost.org/community/reviews.html Thank you very much for your time and efforts. Frédéric

11 70

[cmake] Minimum viable cmakeification for Boost
by Niall Douglas 22 Jun '17

22 Jun '17

I've finished the mockup which can be studied at: https://github.com/ned14/boost-bmv-cmake Just Boost.System was cmakeified. Extensive comments are throughout to explain every single line of cmake and why it's there. A small sample program is in the root of the repo to show how this cmake would be used by end user programs. Readme.md follows for those who don't like clicking on links: --- cut --- This is a mock up of a **bare minimum viable** cmakeification of the Boost C++ libraries for the community to study and evaluate. It only cmakeifies Boost.System alone, its upstream dependencies are stubbed/faked. A demo program which shows how one would link against Boost.System is in this directory (`example_client_program`) and it demos linking against boost::system as a header only library, as a static library and as a shared library. # Specific design goals of this mock up: - Modern, **highly reusable by unknown third party cmake** cmake3 only throughout. - Minimum possible cmake complexity, no cmake innovating, even at the cost of extra boilerplate. - No custom macros, functions, nor custom build logic. Only vanilla cmake3. Keep the learning curve for the build system as gentle as is possible. - **Strict** separation of non-fixed configuration and build. Child CMakeLists must only EVER define build and *fixed* configuration like "I need C++ 11 minimum". *Variable* configuration like naming, directory layout for outputs, optimisation flags etc is ALWAYS defined in the **rootmost** CMakeLists. NEVER in child CMakeLists. - All custom build logic should always be placed in rootlevel cmake scripts (command line programs written in cmake, runnable using `cmake -V`, these can take args etc) or rootlevel CMakeLists, or combinations thereof. # Stuff in there we might yet remove: - This cmake mockup explicitly documents dependencies between Boost libraries in cmake, and so when I link against say Boost.System, cmake will also link in the things Boost.System depends against. Moreover this is minimal, so ONLY the stuff minimally necessary to fulfil the need for Boost.System is built. - We allow those Boost libraries support it to present header only, static and dynamic linkage editions of themselves. This does complicate the CMakeLists however. # What we don't do: - Test the boundaries of cmake or push any limits of what's possible. - Bespoke libraries of common functions dragged in wherever. - Complex custom build logic which needs to be documented and learned off by library developers. - Do anything which gets in the way of CMakeLists reuse by any arbitrary third party cmake written by any Boost user. --- cut --- The code should be fairly self explanatory. Yes there are no tests support. We are limiting the scope of discussion to build only for now. Technical questions are welcome. Niall -- ned Productions Limited Consulting http://www.nedproductions.biz/ http://ie.linkedin.com/in/nialldouglas/

8 50

[review] Beast review coming up!
by Michael Caisse 22 Jun '17

22 Jun '17

The Boost formal review of Vinnie Falco’s Beast library will take place July 1 - 10, 2017. 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 protocol vocabulary types and algorithms using the consistent asynchronous model of Boost.Asio. This library will be familiar to programmers that have used Boost.Asio or the Networking TS. Users who wish to use asynchronous interfaces should already know how to create concurrent network programs using callbacks or coroutines. Beast is designed for: * Symmetry: Algorithms are role-agnostic; build clients, servers, or both. * Ease of Use: Boost.Asio users will immediately understand Beast. * Flexibility: Users make the important decisions such as buffer or thread management. * Performance: Build applications handling thousands of connections or more. * Basis for Further Abstraction. Components are well-suited for building upon. Beast can be found here: * Documentation : <http://vinniefalco.github.io/beast/> * Source code : <https://github.com/vinniefalco/Beast> * The FAQ answers real questions that come up : <http://vinniefalco.github.io/beast/beast/design_choices/faq.html> A lightning talk from CppCon 2016 introducing Beast can be found here: <https://www.youtube.com/watch?v=uJZgRcvPFwI> If you find an obvious bug or problem with the library, please open a GitHub Issue <https://github.com/vinniefalco/Beast/issues>. Vinnie has a track record of resolving issues quickly. Please feel free to take an early look at the library and ask questions. Maybe even click that github Star button! The actual review will be against a non-mutating branch starting July 1st. -- Michael Caisse Ciere Consulting ciere.com

2 1

[build] Use full compiler-version in library filenames
by Deniz Bahadir 22 Jun '17

22 Jun '17

Hi list, While reading Vinnie's mail (regarding the Boost library filenames which should additionally contain the address-model) I remembered another problem existing with library filenames. That is, that Boost libraries built with newer GCC versions (since GCC 5) never add the compiler-version into the library filenames. Building with GCC 5 and newer only adds "gcc" into the filename to determine the toolset, while building with earlier versions of GCC (e.g. GCC 4.9 or GCC 4.8) additionally adds the compiler's version (e.g. "gcc49" or "gcc48"). I assume this might be due to the fact that the version-scheme of GCC changed since GCC 5 and somehow the logic in Boost.Build no longer works because of this. But in order to install boost-libraries built by different GCC versions side-by-side in the same directory the version-number is really required in the filename. Maybe someone can fix this again? A bug-report on Github which addresses this issue already exists: https://github.com/boostorg/build/issues/191 Thanks in advance, Deniz -- BENOCS GmbH Dipl.-Inform. Deniz Bahadir Winterfeldtstr. 21 10781 Berlin Germany Phone: +49 - 30 / 577 0004-22 Email: deniz.bahadir(a)benocs.com www.benocs.com Advisory Board (Chairman): Stephan Schröder Board of Management: Dr.-Ing. Oliver Holschke, Dr.-Ing. Ingmar Poese Commercial Register: Amtsgericht Bonn HRB 19378

2 1

[review] Review of Nowide has finished
by Frédéric Bron 22 Jun '17

22 Jun '17

Thanks for you interest and the discussion. Please be patient, it will take a few days for me to compile all the discussions and give the result of the review. Kind regards, Frédéric

1 0

1.65 closes for new libraries and breaking changes this Friday
by Marshall Clow 22 Jun '17

22 Jun '17

[ The calendar says today, but I forgot to send this out, so we're pushing the deadline back two days. ] Upcoming release dates: 28-Jun: Boost 1.65.0 closed for major changes 5-Jul: Boost 1.65.0 closed for all changes, except by permission of a release manager. 8-Jul: Boost 1.65.0 closed for all changes 12-Jul: Boost 1.65.0 beta; master branch re-opened 2-Aug: Release closed for all changes, except by permission of a release manager. 5-Aug: Boost 1.65.0 closed for all changes 9-Aug: Boost 1.65.0 release -- Marshall

1 0

Re: [boost] [review] Review of Nowide (Unicode)
by Yakov Galka 21 Jun '17

21 Jun '17

Dear all, Here is my review of the library. - What is your evaluation of the design? > I welcome the UTF-8 approach on Window. However, the fact that Nowide does not handle invalid UTF-16 transparently is an issue that has to be addressed. - What is your evaluation of the implementation? > Going through the code I can't spot any implementation issues. > - What is your evaluation of the documentation? > It's clear. No issues found. > - What is your evaluation of the potential usefulness of the library? > I already use this approach through a different implementation. Even though I wouldn't bring Boost just for that single library, for projects that already use Boost it might be a valuable addition. I do think that Nowide offers a superior solution to encoding issues compared to Boost.Filesystem. > - Did you try to use the library? With what compiler? Did you have any > problems? > I did try it years ago when it was first submitted to Boost. I didn't try the recent version, so NO. > - How much effort did you put into your evaluation? A glance? A quick > reading? In-depth study? > 30 minutes reading the code + mailing list discussions. > - Are you knowledgeable about the problem domain? > I rate myself as an expert. I'm a co-author of utf8everywhere.org. DISCLAIMER: I met Artyom a couple times IRL. > - Do you think the library should be accepted as a Boost library? Be > sure to say this explicitly so that your other comments don't obscure > your overall opinion. > Conditional acceptance, subject to transparent invalid UTF-16 resolution. -- Yakov Galka http://stannum.co.il/

4 3

[review] Last day to send your review of Nowide (Unicode)
by Frédéric Bron 21 Jun '17

21 Jun '17

Dear all, This is the last day to submit your review of Artyom Beilis' Nowide library. So far, 12 people participated to the review (not counting the author and the review manager): - Andrzej Krzemienski - Chris Glover - Degski - Edward Diener - Gavin Lambert - Niall Douglas - Norbert Wenzel - Paul Groke - Peter Dimov - Vadim Zeitlin - Yakov Galka - Zach Laine 8 reviews where received including * 6 reviews said nowide should be accepted (with conditions): - Degski, - Peter Dimov - Andrzej Krzemienski - Chris Glover - Norbert Wenzel - Yakov Galka * 1 review did not choose between accept/do not accept: - Paul Groke * 1 review said nowide should not be accepted as is: - Zach Laine Your participation is encouraged, as the proposed library is uncoupled, focused and rather small. Nowadays, everyone needs to handle Unicode but this is very difficult using only the standard library in a platform independant way. Nowide offers a very simple way to handle Unicode the same way on Windows/MacOS/Linux. Key features: * work with UTF-8 in your code, Nowide converts to OS encoding * Easy to use functions for converting UTF-8 to/from UTF-16 * A class to fixing argc, argc and env main parameters to use UTF-8 * UTF-8 aware functions: - stdio.h functions (fopen, freopen, remove, rename) - stdlib.h functions (system, getenv, setenv, unsetenv, putenv) - fstream (filebuf, fstream/ofstream/ifstream) - iostream (cout, cerr, clog, cin) Documentation: http://cppcms.com/files/nowide/html GitHub: https://github.com/artyom-beilis/nowide git clone https://github.com/artyom-beilis/nowide.git Latest tarballs: - to be unzipped in boost source: https://github.com/artyom-beilis/nowide/archive/master.zip - as a standalone library: http://cppcms.com/files/nowide/nowide_standalone.zip Nowide has standard boost layout. So, just put it into the boost source tree under libs/nowide directory for building and running tests. Or alternatively - for header only part of the library add the nowide/include path to the include path of your projects. Please post your comments and review to the boost mailing list (preferably), or privately to the Review Manager (to me ;-). Here are some questions you might want to answer in your review: - 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 what compiler? 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? And most importantly: - Do you think the library should be accepted as a Boost library? Be sure to say this explicitly so that your other comments don't obscure your overall opinion. For more information about Boost Formal Review Process, see: http://www.boost.org/community/reviews.html Thank you very much for your time and efforts. Frédéric

1 0

[sort] Timsort review result
by Steven Ross 21 Jun '17

21 Jun '17

After reviewing the responses, I have rejected Timsort. Here are the reasons: 1. No author/maintainer responses to the questions on boost (except for forwarding some documentation links). We need a maintainer for all our source, and I'm not volunteering to maintain new functions as complex as Timsort. 2. There was no response on the Timsort bug reported during the review, nor any tests for it. 3. We need better tests. 4. Francisco is including a more efficient stable sort as part of his additions to the library, including handling special cases like Timsort handles better than stable_sort does. Francisco will maintain his code. I'd like to note that many people THINK they are experts on sorting because they covered it in class or may have read about it in a textbook, but most do not understand hybrid sorts well. As a specific example, I saw O(N*log(N)) mentioned as the worst-case speed limit of general-case sorts, when in fact Spreadsort beats that as described in its docs: http://www.boost.org/doc/libs/1_61_0/libs/sort/doc/html/index.html#sort.ove… Many people also don't carefully analyze for worst-case performance, which can be tricky. With regards to future sorting library reviews, I'll get at least a one-page doc describing the algorithm for the review in advance, but the boost documentation formatting is an unreasonable request for a simple sorting function, and I don't see the value it adds for these simple reviews. It is useful for a full library, but we'll be integrating the documentation into our full library after a new function is accepted. It isn't accurate to call it a mini-review (as described here: http://www.boost.org/community/reviews.html#Fast-Track) because it's reviewing completely new source we're talking about adding to the library. That said, do you still want me to a call the upcoming one for pdqsort a "mini-review"?

3 3

Re: [boost] [cmake] Minimum viable cmakeification for Boost
by Thomas Heller 20 Jun '17

20 Jun '17

Am 20.06.2017 2:17 nachm. schrieb "Niall Douglas via Boost" < boost(a)lists.boost.org>: On 20/06/2017 07:27, P F wrote: > >> On Jun 19, 2017, at 6:42 PM, Niall Douglas via Boost >> <boost(a)lists.boost.org> wrote: >> >> I've finished the mockup which can be studied at: >> >> https://github.com/ned14/boost-bmv-cmake >> >> Just Boost.System was cmakeified. Extensive comments are throughout >> to explain every single line of cmake and why it's there. A small >> sample program is in the root of the repo to show how this cmake >> would be used by end user programs. > > Here some feedback, I have: > > - Having things like `::hl` or `::sl` is quite strange. In cmake, I > set `BUILD_SHARED_LIBS=On` when I want a shared library or I set it > to `BUILD_SHARED_LIBS=Off` when I want a static library. There should > only be one target `boost::config` or `boost::system` that I use. BUILD_SHARED_LIBS is a cmake2-ism and should not be present in modern cmake. Moreover, cmake now supports header only libraries, and BUILD_SHARED_LIBS causes problems with eventual C++ Modules support. The ::hl suffix means "link against the header only library edition", the ::sl suffix means "link against the static library edition" and the ::dl suffix means "link against the dynamic library edition". Err, I tend to highly disagree here. As a library author, I can not know if my users need a static or shared library. For a header only library, this hardly matters. Having those different conventions greatly increases the complexity for consuming your library (which do I need again in which circumstances?) so we need to depend on variables to link against the right target (so much for cmake2isms). Some bikeshedding over those names occurred off list. They don't hugely matter, they could be boost::system::header, boost::system::static and boost::system::shared if you wanted. Some bikeshedding also occurred over what boost::system with no suffix should mean. I recommend "whatever library edition the maintainer recommends as the best one" which is NOT necessarily the header only edition. For example, in the future with C++ Modules support the additional suffixs ::hlm, ::slm and ::dlm will be needed. Or longer named, boost::system::header_module, boost::system::static_module and boost::system::shared_module. So if C++ Modules were available, the maintainer might recommend the ::dlm variety, but recommend the ::hl variety if they weren't available. I think that will hugely vary per library as C++ Modules won't necessarily be always a win. Also, end users may wish to assemble all of Boost into a single C++ Module. We don't want to get in the way. > - Each project do things like > `include("${CMAKE_CURRENT_SOURCE_DIR}/../../cmake/BoostVersion.cmake”)` > which is broken when built on its own. That was intentional. Some bikeshedding occurred over that too with respect to which Boost library guaranteed to be a dependency for all other libraries ought to host the version setting script. Boost.Config is most likely. So the above is a placeholder. > - Doing `if(NOT TARGET boost::assert::hl)` is wrong. A target does > not have to exists to be able to link against it. Plus, it should > call `find_package(boost_assert)` to bring in the target for when its > not built in the superproject. That part is there solely to enable modular build. If you don't want to bother with modular build as this is a bare minimum viable cmakeification, you can eliminate it. > - There is no installation of the targets Not necessary right now, so out of scope. > - Doing `target_include_directories(boost_core-hl INTERFACE > "include”)` is wrong as this will only add the include directories > for the build. The include directories should be added for the build > and for the installation. As I've repeatedly explained now, installation logic is best implemented by a rootmost CMakeLists. Not in the per-library CMakeLists. We do tell cmake what targets are used by installation via install(TARGETS ...). That's the bare minimum needed for other cmake to implement the remaining installation logic. (On wider picture stuff, install paths need to be absolute I've found, whereas build paths can usually be relative. Relative paths are much nicer during build. In a rootmost CMakeLists which implements some installation logic, you'd iterate the targets for the Boost libraries and configure each programmatically for the appropriate install for that library and that type of library. All the metadata you need to make decisions is available) Niall -- ned Productions Limited Consulting http://www.nedproductions.biz/ http://ie.linkedin.com/in/nialldouglas/ _______________________________________________ Unsubscribe & other changes: http://lists.boost.org/ mailman/listinfo.cgi/boost

2 5