- Boost - lists.boost.org

Interest in a C++20 Unit Testing Framework?
by Krzysztof Jusiak 10 Dec '19

10 Dec '19

Hi, I was wondering whether there is any interest in exploring a C++20 single header/single module, macro-free Unit Testing Framework with no dependencies? Github: https://github.com/boost-experimental/ut Additional links: - Try it online: https://godbolt.org/z/uVDxkW - Benchmarks: https://github.com/boost-experimental/ut#benchmarks - How it works?: https://github.com/boost-experimental/ut#how-it-works Thanks, Kris

8 30

Re: [boost] [STLInterfaces] only three operations?
by Zach Laine 09 Dec '19

09 Dec '19

On Mon, Dec 9, 2019 at 12:55 PM Andrzej Krzemienski <akrzemi1(a)gmail.com> wrote: > > > pon., 9 gru 2019 o 17:32 Zach Laine <whatwasthataddress(a)gmail.com> > napisał(a): > >> >> >> >>> Same with the iterator in the flight map: >>> >>> >>>> https://github.com/tzlaine/flat_map/blob/master/implementation/flat_map#L266 >>>> >>> >>> According to C++17 requirements this shouldn't have been a >>> random_access_iterator. >>> >>> Also, std::ranges::sort() will not work with it. But this is not >>> directly related to `iterator_interface` >>> >> >> I don't know why you think that. ranges::sort() is designed to work with >> std::random_access_iterator, which is designed explicitly to support proxy >> iterators. Casey and Eric have assured me that this "just works". Do you >> know of a reason why it does not? If so, you've spotted a defect, and we >> should file an LWG issue immediately. >> > > Not sure if it is a defect. An iterator that returns a proxy as > ::reference can be a valid random_access_iterator. However, > std::ranges::sort(), apart from a random_access_iterator requirement, has > one more requirement: sortable<>: (http://eel.is/c++draft/sort) which > boils down to indirectly_writable ( > http://eel.is/c++draft/iterator.concept.writable) This last concepts > puts severe restrictions on proxy types. For instance you should be able to > assign to them when they are const-qualified. So a type like std::tuple<> > of references will not work. But you will be able to design a sufficiently > bizarre proxy type that will work with std::ranges::sort(), So in a way it > will work with *some* reference proxies. > Ok, I just realized this somehow drifted off-list. Re-adding the list... This is the definition of indirectly_writable: template<class Out, class T> concept indirectly_writable = requires(Out&& o, T&& t) { *o = std::forward<T>(t); // not required to be equality-preserving *std::forward<Out>(o) = std::forward<T>(t); // not required to be equality-preserving const_cast<const iter_reference_t<Out>&&>(*o) = std::forward<T>(t); // not required to be equality-preserving const_cast<const iter_reference_t<Out>&&>(*std::forward<Out>(o)) = std::forward<T>(t); // not required to be equality-preserving }; All you need to make this work is a reference type for which all those are well-formed. If you pick std::tuple, it all just works. If you pick std::pair, only the first two expressions in the requires expression work. You can easily define UDTs for which this concept works too, of course. Zach

1 0

Interest in an audio filtering / algorithm Library?
by Vinnie Falco 09 Dec '19

09 Dec '19

Is there any interest in having a new libraries for Boost that is focused on the audio domain (but with portions applicable generically)? I'm thinking about a library that does stuff like: * finite impulse response filtering * infinite impulse response filtering * time stretching, resampling * audio synthesis * audio algorithms * mixing * plenty of ready-to-run filters: - low pass, high pass, band pass - echo, reverb, flanger, phaser and the like This is a pure math library, no actual audio. To get an idea of the algorithms and use-cases check out my DSPFiltersDemo program (press Download Now): <https://github.com/vinniefalco/DSPFiltersDemo> Please note, my library is not what is being proposed, this would be a new library from a domain expert (not me). Thanks

7 8

[review][fixed_string] review period finishes today Dec 8
by Joaquin M López Muñoz 08 Dec '19

08 Dec '19

The review period of candidate Boost.FixedString finishes today, Dec 8. Many interesting subjects have been discussed about during these two weeks and I have quite a bit of material to digest before publishing the final review result plus further action points. I expect to be able to do so during the following week. Thank you to all the people who have contributed their reviews and comments and to Krystian and Vinnie for submitting their work and enduring the famously severe review ordeal. Best regards, Joaquín M López Muñoz Review manager for candidate Boost.FixedString

2 1

Re: [boost] Boost GIL
by Siddhartha Sen 08 Dec '19

08 Dec '19

Thanks a lot for forwarding my email to the boost GIL list. I will check it out. What I meant by conversion, however was primarily converting an image to negative and greyscale. As you may already know, the two pf them are pretty similar and OpenMP has shown how incredibly fast the process can be using more threads. I just feel GIL would benefit a lot from using parallel programming. On Sun, 8 Dec, 2019, 5:30 PM , <boost-request(a)lists.boost.org> wrote: > Send Boost mailing list submissions to > boost(a)lists.boost.org > > To subscribe or unsubscribe via the World Wide Web, visit > https://lists.boost.org/mailman/listinfo.cgi/boost > or, via email, send a message with subject or body 'help' to > boost-request(a)lists.boost.org > > You can reach the person managing the list at > boost-owner(a)lists.boost.org > > When replying, please edit your Subject line so it is more specific > than "Re: Contents of Boost digest..." > > > The boost archives may be found at: http://lists.boost.org/Archives/boost/ > > > Today's Topics: > > 1. Re: [fixed_string][review] Review of fixed_string (Rob Stewart) > 2. Re: Extending GIL (Mateusz Loskot) > > > ---------------------------------------------------------------------- > > Message: 1 > Date: Sat, 07 Dec 2019 13:23:51 -0500 > From: Rob Stewart <rstewart(a)ptd.net> > To: boost(a)lists.boost.org,Phil Endecott via Boost > <boost(a)lists.boost.org> > Cc: Phil Endecott <spam_from_boost_dev(a)chezphil.org> > Subject: Re: [boost] [fixed_string][review] Review of fixed_string > Message-ID: <142EED34-B802-4381-9FF9-C9FE999BA0F9(a)ptd.net> > Content-Type: text/plain; charset=utf-8 > > > > On December 5, 2019 9:35:35 AM EST, Phil Endecott via Boost < > boost(a)lists.boost.org> wrote: > > Peter Dimov wrote: > > > - a function that checks whether the remaining capacity is at least > > n should > > > be added. I suggest the name > > > > > > bool can_fit( std::size_t n ) const noexcept; > > > > > > although my previous choice of "has_capacity_for" has merit too. > > I suggest the simpler "fits". > > > Make this a free function template and you can use it with other > > containers: > > > > template <typename CONTAINER> > > bool can_fit( const CONTAINER& C, typename CONTAINER::size_type n ) > > noexcept > > { > > return C.capacity() - C.size() >= n; > > } > > That's a nice idea, especially with the name "fits". :) However, if you > reverse the parameters, "fits_in" would be a better name as it indicates > the argument order. > -- > Rob > > (Sent from my portable computation device.) > > > ------------------------------ > > Message: 2 > Date: Sun, 8 Dec 2019 01:25:04 +0100 > From: Mateusz Loskot <mateusz(a)loskot.net> > To: boost(a)lists.boost.org > Subject: Re: [boost] Extending GIL > Message-ID: > < > CABUeae_cupOMOhCNvvHaeruX2ksycHhVKkHJbtCSCLr-kW-XkA(a)mail.gmail.com> > Content-Type: text/plain; charset="UTF-8" > > On Sat, 7 Dec 2019 at 01:12, Siddhartha Sen via Boost > <boost(a)lists.boost.org> wrote: > > > > Having looked up this repository : > https://github.com/boost-gil/gil_threaded, > > I feel the idea was the same, but a lot of improvement can be made. > > Good, sounds like you may have a plan in mind > > > Also, there was no provision for image conversion, which I feel > > Please, you need to be more specific here. > What kind of conversion do you mean: color, channel/pixel type, format,...? > > p.s. I forwarded your post to the GIL mailing list > https://lists.boost.org/boost-gil/2019/12/0362.php > > Best regards, > -- > Mateusz Loskot, http://mateusz.loskot.net > > > ------------------------------ > > Subject: Digest Footer > > _______________________________________________ > Unsubscribe & other changes: > http://lists.boost.org/mailman/listinfo.cgi/boost > > > ------------------------------ > > End of Boost Digest, Vol 6271, Issue 1 > ************************************** >

2 1

[release] 1.72.0 post-beta merges
by Michael Caisse 08 Dec '19

08 Dec '19

The master branch is is now open for post-beta merges, but only as described in the Post-Beta Merge Policy. See <https://github.com/boostorg/boost/wiki/Releases%3A-Beta-Merge-Policy>

11 31

[range] Trying to extend boost::range::combine to std::tuples
by Andres Llopis 08 Dec '19

08 Dec '19

Hi everyone, I am trying to make my own version of combine so that it works also with std::tuples. Someone on slack suggested that the zip iterator should be able to handle it properly. My attempt however fails when trying to use the metafunction tuple_of_references::type for the std::tuple of iterators. This is what I tried (https://godbolt.org/z/Ymjtvn) (Please excuse any style problems, this is my first post) namespace myns { using boost::iterators::zip_iterator; using boost::iterator_range; template<typename IterTuple> class combined_range : public iterator_range<zip_iterator<IterTuple> > { typedef iterator_range<zip_iterator<IterTuple> > base; public: combined_range(IterTuple first, IterTuple last) : base(first, last) { } }; template<typename... Ranges> auto combine(Ranges&&... rngs) -> combined_range<decltype(std::make_tuple(std::begin(rngs)...))> { return combined_range<decltype(std::make_tuple(std::begin(rngs)...))>( std::make_tuple(std::begin(rngs)...), std::make_tuple(std::end(rngs)...)); } }

3 5

Extending GIL
by Siddhartha Sen 08 Dec '19

08 Dec '19

Having looked up this repository : https://github.com/boost-gil/gil_threaded, I feel the idea was the same, but a lot of improvement can be made. For example, by using OpenMP, I feel the computational performance can be massively improved and that too, not requiring any extremely sophisticated hardware. Also, there was no provision for image conversion, which I feel is a very good extension. What do you all think?

2 1

[fixed_string][review] Review of fixed_string
by Peter Dimov 07 Dec '19

07 Dec '19

This is my review of FixedString. * Summary The library should be ACCEPTED. It's useful, for more than one domain, and specifically where compile-time string manipulation is concerned, everyone needs to reinvent it. The name fixed_string is fine as is. Alternatives exist, but I don't see any of them as unquestionably better, and one becomes accustomed to "fixed_string" after a very brief period. Throwing on exceeding capacity is fine as is. A function should be provided to check the remaining capacity, because writing this check by hand is very easy to get wrong, and in fact the library throughout its implementation consistently gets it wrong. * Documentation The documentation is adequate, but I don't find the reference convenient. I would prefer a synopsis that contains the entire class definition of `fixed_string`, so that I can see the various overloads at a glance. Instead, the synopsis only gives me the declaration of `fixed_string`, without even telling me what namespace it's in. (It also gives me `basic_string_view`, also without mentioning the namespace.) The current layout is fine if I want to look up a specific function by name. The format should ideally follow the standard library, with Throws and Expects clauses (the latter instead of "undefined behavior unless".) It's not documented when constructors and assignment operators throw. * Design - static_capacity should be removed; capacity() and max_size() should be static constexpr. - all nonthrowing functions should be marked `noexcept`. - initializer_list<CharT> overloads are of dubious utility. I know that the design copies std::string here, but I think that we should deviate and not provide them. - substr() should return a fixed_string, subview() a string_view (as already implemented.) - operator+ should be provided, only for arguments with capacity known at compile time (fixed_string<N>, CharT and CharT const (&)[ N ]), with the capacity of the result being the sum of the capacities of the arguments. This is not very useful for long strings, but it's fine for short strings, useful for compile-time manipulation, and useful in simple cases such as to_fixed_string( n ) + " bytes written". - a function that checks whether the remaining capacity is at least n should be added. I suggest the name bool can_fit( std::size_t n ) const noexcept; although my previous choice of "has_capacity_for" has merit too. This is, in my opinion, an absolutely necessary addition, because of my already-stated observation that the check is almost always gotten wrong. Here for instance is an example: if(size() + count > max_size()) BOOST_FIXED_STRING_THROW(std::length_error{ "size() + count > max_size()"}); The correct way to write it is max_size() - size() > count, which avoids the integer overflow in size() + count. In this case, passing count = (size_t)-1 will pass the check (when size() > 0) and then lead to undefined behavior. This makes the utility of reserve() dubious, because it basically invites one to get it wrong, but I think we should retain it for consistency. - everything should ideally be constexpr. The problem here is that constexpr requires initializing all elements, and this will heavily penalize runtime uses of f.ex. fixed_string<512>. On compilers with __builtin_is_constant_evaluated (gcc 9, clang 9) we should use that; otherwise, it might be worth it to create a specialization for N < some suitable upper limit. Again, any nontrivial string manipulation at compile time basically requires a fixed_string. * Implementation The physical separation of the library into three headers is inconvenient. A single header would make it possible to include the library directly on Godbolt via https, which is useful for both demonstrations and analysis of the generated code. In addition, hunting down the definitions is irritating for people reading the code. The reverse is true for the tests; they should be split into files each testing a logical group, such as constructors, assignment, append, and so on. The helper functions "testAS", "testI" and so on make reading the tests unnecessarily cryptic (and is quite annoying for reviewers.) They should have been named "test_assign", "test_insert". It's generally better to use `BOOST_TEST_EQ(s.size(), 0);` instead of `BOOST_TEST(s.size() == 0);` because the former prints the values on failure, which often gives clues as to where the error is. The test functions shouldn't be in the boost::fixed_string namespace. Users don't write their code in this namespace, so the tests don't test what users use. All capacity checks should be either audited for correctness and fixed, or use the proposed can_fit addition. Instead of repeating BOOST_FIXED_STRING_THROW(std::length_error{ "n > max_size()"}); in every function, which leads to it being inlined there repeatedly, this could use a helper function void throw_length_error( char const * msg, boost::source_location const& loc ) { boost::throw_exception( std::length_error( msg ), loc ); } taking advantage of the new boost::throw_exception overload that takes a source location as documented in https://www.boost.org/doc/libs/develop/libs/throw_exception/doc/html/throw_…. A variation could take `n` as an argument and compose a message containing it, f.ex. void throw_length_error_fmt( boost::source_location const& loc, char const * fmt, ... ); #define BOOST_FIXED_STRING_USE_BOOST should go, as already mentioned. Since the library requires C++11, there's no need to use BOOST_STATIC_ASSERT. static_assert is fine. Unless of course we backport it to C++03, which might be doable, although of questionable utility. Checking for overlap and using Traits::copy instead of Traits::move isn't needed. Traits::move does the same check anyway, so there's no gain, just an opportunity to get the check wrong and introduce undefined behavior. "The behavior is undefined if `count >= npos`" doesn't seem necessary. In this case, count will be bigger than max_size() and the constructor will throw std::legth_error. There's no reason to gratuitously introduce undefined behavior. All "undefined behavior" cases should consistently BOOST_ASSERT.

4 4

[nowide] Future
by Artyom Beilis 07 Dec '19

07 Dec '19

The nowide library was reviewed and accepted into Boost almost 3 years ago. I implemented most of fixes required under Review Fixed branch https://github.com/artyom-beilis/nowide/tree/reviewfixes Unfortunately I don't have any capacity to do maintenance for it on all various platforms: MSVC, mingw. cygwin etc mostly because virtually I don't develop on Windows and any time I need to go there I need to figure it out from the beginning (installations, environment, msvc) and I don't even have windows machine in my hands (all done in VM) I realized that I'm not windows developer any more and it would be impossible for me to complete the mission of maintaining the code mostly due to personal reasons and lack of development resources. I deeply regret wasting the time and effort of so many boost developers who invested to review. I understand that it is highly desired library but I just can get the job done I seek for your advice. Do I need to seek for an another maintainer or withdraw the library entirely? Once again sorry for disappointing the community and people who were invested in this library. Artyom Beilis

6 10