- Boost - lists.boost.org

[type_traits] Modularization proposal
by Andrey Semashev 17 Sep '14

17 Sep '14

Hi, Boost.TypeTraits is used in lots of other Boost libraries, and it currently unnecessarily pulls MPL and TypeOf. The dependencies are introduced by just these two public headers: floating_point_promotion.hpp and common_type.hpp. I'd like to avoid these dependencies. I propose to extract common_type.hpp (and its implementation and tests) into a sublib within type_traits (e.g. type_traits/common_type). As for floating_point_promotion.hpp, it is used in promote.hpp, which is using integral_promotion.hpp. I can see two ways of tackling it: 1. Extract all promotion traits into a sublib (e.g. type_traits/promotion). This includes floating_point_promotion.hpp, integral_promotion.hpp and promote.hpp, as well as their tests. 2. Change floating_point_promotion.hpp to not use MPL. MPL is used only to workaround BOOST_NO_CV_SPECIALIZATIONS, which is defined for Borland 5.51 and older and MPW 8.90 and older. The simplest way is to drop the workaround, but at a quick glance it should be possible to retain it. I'm currently leaning towards the option 2, although we obviously don't test those compilers and there is no way of knowing if the code will still work after the change. So I'm interested to know others' opinion, both with regard to the general idea and the way of proceeding with floating_point_promotion.hpp in particular. PS: TypeTraits dependencies can be seen in the report Peter graciously uploaded: http://www.pdimov.com/tmp/report-d5ca5be/type_traits.html After the modularization efforts TypeTraits should only depend on Config, Core, Preprocessor, MPL.Core and StaticAssert. Don't mind that MPL.Core depends on MPL - the pull request fixing it has already been created.

8 23

[mpl] Modularization pull request
by Andrey Semashev 17 Sep '14

17 Sep '14

Hi, I've created this pull request: https://github.com/boostorg/mpl/pull/11 to separate core components of Boost.MPL to a sub-library. The intent of this pull request is to reduce dependencies added by MPL to its dependent libraries, when only the basic MPL components are required. In particular, it should help resolving circular dependency between MPL and TypeTraits. Please, have a look at the list of moved components and let me know if you have any comments.

4 18

[testing] mpl/core tests not visible
by Andrey Semashev 17 Sep '14

17 Sep '14

Hi, I can see a few testers have cycled since MPL.Core was extracted into a sublibrary, but there is no mpl/core page in the test matrix. The sublibs file and core/test directory are present in the mpl submodule. Is there something I should do to make the tests appear?

3 21

[TR1] Reming TR1? [was: Libraries failing across the board.]
by Beman Dawes 16 Sep '14

16 Sep '14

On Wed, Jul 9, 2014 at 8:13 AM, John Maddock <boost.regex(a)virgin.net> wrote: > > > On 08/07/2014 22:07, Beman Dawes wrote: > >> Marshall is just a few days away from being able to put out a beta release >> candidate. (And that is very good news!) >> >> But we still have too many libraries failing across the board on master: >> >> accumulators >> interprocess >> numeric/ublas >> pool >> proto >> spirit/repository >> spirit/test >> tr1 >> > > TR1 is now deprecated, and again hasn't been changed in a long time - the > main failures seem to be caused by changes to Boost.Random (or possibly > std::random) so that it is now no longer TR1 compliant. Someone would have > to rewrite it to use TR1-compatible random number classes perhaps culled > from an old version of Boost, frankly I just don't see the point. The lib > should probably be removed from Boost at some point. > We went back and forth a bit, and decided to remove TR1 after 1.56.0 shipped. What exactly needs to be done? * Remove the .gitmodules entry. * Remove the status/Jamfile.v2 entry. * Remove the libs/maintainer.txt entry. * Update http://www.boost.org/doc/libs/ Anything else? --Beman

5 4

[modularization] mplcore depends on mpl
by Stephen Kelly 16 Sep '14

16 Sep '14

Hi there, libs/mpl/core/include/boost/mpl/aux_/include_preprocessed.hpp from mplcore includes boost/mpl/aux_/config/compiler.hpp which is in mpl. mpl depends on mplcore. This is a circular dependency. I thought the point of the split was to resolve that in part. If so, then I recommend you go ahead and resolve the cycle in the obvious way. Thanks, Steve.

2 1

Re: [boost] proposal a movable_initializer_list
by 何子杰Hzj_jie 16 Sep '14

16 Sep '14

sorry, my fault of the mistake of for-range usage, you are correct, I am using iterator in my implementation. The efficiency I am taking care is the difference between copy-construction and move-construction. It will be significant if we are using lambda expression. Surely we still have something else to improve, say, provide the size of the vector at construction. The way using movable_initializer_list in the test case is not typical, indeed I am trying another not related issue. <the order of the move-constructions are not expected, i.e. line 46 will throw errors by g++, but no problem by msvc> Usually if a class A accept movable_initializer_list<T> as the parameter of a constructor, we only need A({T(), T()}), i.e. same as initializer_list. You properly would like to have a look at the event class, which is the typical scenario of movable_initializer_list, at https://github.com/Hzj-jie/osi/blob/master/delegates/event.hpp, with a test at https://github.com/Hzj-jie/osi/blob/master/utt_cases/delegates/event_test.h…. briefly it uses movable_initializer_list to avoid a copy of std::function instances, but can provide a way to call constructor with { } syntax. .Hzj_jie From: Sebastian Redl Sent: ‎Monday‎, ‎September‎ ‎15‎, ‎2014 ‎8‎:‎09‎ ‎PM To: boost(a)lists.boost.org On 15 Sep 2014, at 9:39, 何子杰Hzj_jie <hzj_jie(a)hotmail.com> wrote: > hi, all, > > So I proposal a movable_initializer_list, it accepts two ways to construct, with an initializer_list<T*> or initializer_list<T>, the prototype is, > > The implementation of T* overloads is something like > > movable_initializer_list<std::initializer_list<T*> x) > > { > > for(auto it : x) > > { > > assert((*it) != nullptr); > > v.push_back(std::move(**it)); > > delete *it; > > } > } Should be for (auto p : x) { v.push_back(std::move(*p)); delete p; } because of how for-range works. Seems an incomplete manual change from your published source. However, this is highly problematic because: - There is absolutely no way to make this exception-safe. The intended usage is obviously: SomeType st = { new Foo(123), new Foo(456), new Foo(789) }; But if any constructor here throws, a lot of memory is leaked, and destructors are not called. - If efficiency is your goal, I somehow doubt that an additional dynamic allocation per element for the initial list, then building a vector element by element, is the best way to achieve it. - The interface to this is just horrible. Looking at your test case, there is an absurd amount of boilerplate. Here’s what we really want: SomeType st{ Foo(123), Foo(456), Foo(789) }; Here’s what your thing forces me to do: auto pointers = { new Foo(123), new Foo(456), new Foo(789) }; SomeType st(pointers); // Absolute best case: no ambiguity in overload resolution - actually rather doubtful. If you do it that way, you might as well do it this way: Foo[] foos = [ Foo(123), Foo(456), Foo(789) }; // No dynamic allocation SomeType st(make_move_iterator(begin(foos)), make_move_iterator(end(foos))); More efficient, and you could make helpers that combine the make_move_iterator and begin/end calls to reduce boilerplate. > > While the implementation of T overloads is something like > > moveable_initializer_list<std::initializer_list<T> x) > { > > for(auto it : x) v.push_back(move(*it)); > } Again, that’s not how for-range works. What you want is for (auto&& e : x) v.push_back(std::move(e)); But that doesn’t actually work, because a std::initializer_list never gives you non-const access to its elements. I notice that your test case doesn’t test this constructor. Sebastian _______________________________________________ Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost

1 0

Darwin Clang Config failures.
by John Maddock 15 Sep '14

15 Sep '14

Does anyone understand why these all fail: http://www.boost.org/development/tests/develop/developer/output/marshall-ma… Is <functional> really broken on that platform? Surely not? Thanks, John.

4 3

proposal a movable_initializer_list
by 何子杰Hzj_jie 15 Sep '14

15 Sep '14

hi, all, the initializer_list in c++11 does not support the inner objects to be moved, so in some scenarios the performance will be significant impacted. say, an event class, which stores several std::function objects, and execute them later. the prototype is template <typename Args…> class event { private: std::vector<std::function<void(Args…)>> v; public: event(std::initializer_list<std::function<void(Args…)>>); void bind(std::function<void(Args…)>&&); }; When calling the constructor of event with a set of lambda expressions, the std::function objects will be copied instead of moved, and cause performance impact. Though pointer can resolve the issue, the syntax is not friendly, and the user needs to delete the instances manually. So I proposal a movable_initializer_list, it accepts two ways to construct, with an initializer_list<T*> or initializer_list<T>, the prototype is, template <typename T> class movable_initializer_list { private: std::vector<T> v; public: movable_initializer_list(std::initializer_list<T*>); movable_initializer_list(std::initializer_list<T>); // other functions same as initializer_list }; The implementation of T* overloads is something like movable_initializer_list<std::initializer_list<T*> x) { for(auto it : x) { assert((*it) != nullptr); v.push_back(std::move(**it)); delete *it; } } While the implementation of T overloads is something like moveable_initializer_list<std::initializer_list<T> x) { for(auto it : x) v.push_back(move(*it)); } Surely end-users need to aware the implementation of movable_initializer_list will move the objects instead of copy. The full implementation is at https://github.com/Hzj-jie/osi/blob/master/formation/movable_initializer_li…, and the test is at https://github.com/Hzj-jie/osi/blob/master/utt_cases/formation/movable_init…. Please feel free to give me some suggestions about this proposal. Thank you in advanced. .Hzj_jie

2 1

[vmd] Library Review
by Paul Mensonides 15 Sep '14

15 Sep '14

(apologies for the late review) -- Design -- Many of the utility components of the library have decent design. There are, however, a couple of aspects of the design that I dislike, and they touch on a large chunk of the library. These concerns all revolve around the registration, recognition, parsing, and limitations of various "v-types" and "v-sequences". I do not yet see a strong use case for the "v-key"/"v-identifier" recognition scenario, as opposed to just registering a "v-identifier". For example, #define BOOST_VMD_MAP_<v-key><v-identifier> // ... BOOST_VMD_IS_IDENTIFIER(<v-seq>, <tuple-of-v-keys>) Perhaps Edward can enlighten me about the use-cases for which this is ideal. I do see some use-cases, but in most cases it requires dispatch based on what the particular "v-identifier" it is anyway. One could do better for this low-level part with registrations such as (without a BOOST_VMD_ prefix for brevity) #define IDENTIFIER_CIRCLE (CIRCLE), #define IDENTIFIER_SQUARE (SQUARE), #define IDENTIFIER_TRIANGLE (TRIANGLE), #define IDENTIFIER_RECTANGLE (RECTANGLE), These definitions don't allow one to directly test for specific "v-identifiers", but they do allow one to extract registered "v-identifiers" from a "v-sequence". If all such registrations are required to be the same, there is no need for separate per-library prefixes. Macros can be defined multiple times if they are defined the same way. Similarly, the "v-numbers" could be pre-registered by the library as #define NUMBER_0 (0), #define NUMBER_1 (1), #define NUMBER_2 (2), // ... Tests for specific "v-identifiers" can be done via extraction from the above and using macro definitions such as #define COMPARE_CIRCLE_CIRCLE () #define COMPARE_SQUARE_SQUARE () // ... In many cases this sort of comparison is not needed, as one would directly dispatch off of the "v-identifier" itself. In any case, one could "parse" a "v-sequence" into "v-types" without many of the limitations of the current design. The following example uses Chaos, but I do not think there is anything in the design that fundamentally cannot be made to work on (e.g.) VC++. #include <chaos/preprocessor.h> #define NUMBER_1 (1), #define NUMBER_2 (2), #define NUMBER_3 (3), #define NUMBER_4 (4), #define NUMBER_5 (5), // ... // parser implementation... #define PARSE(vseq) PARSE_S(CHAOS_PP_STATE(), vseq) #define PARSE_S(s, vseq) \ CHAOS_PP_SPLIT(0, CHAOS_PP_EXPR_S(s)(CHAOS_PP_WHILE_S( \ s, PARSE_P, PARSE_O,, vseq \ ))) \ /**/ #define PARSE_P(s, seq, vseq) \ CHAOS_PP_COMPL(CHAOS_PP_IS_EMPTY_NON_FUNCTION(vseq)) \ /**/ #define PARSE_O(s, seq, vseq) \ seq CHAOS_PP_IIF(CHAOS_PP_IS_VARIADIC(vseq))( \ PARSE_O_A, PARSE_O_B \ )(vseq) \ /**/ #define PARSE_O_A(vseq) PARSE_O_A_A vseq #define PARSE_O_A_A(...) (3, (__VA_ARGS__)), #define PARSE_O_B(vseq) \ CHAOS_PP_IIF(CHAOS_PP_IS_VARIADIC(NUMBER_ ## vseq))( \ PARSE_O_B_A, \ CHAOS_PP_IIF(CHAOS_PP_IS_VARIADIC(IDENTIFIER_ ## vseq))( \ PARSE_O_B_B, PARSE_O_B_C \ ) \ )(vseq) \ /**/ #define PARSE_O_B_A(vseq) \ (1, CHAOS_PP_REM_CTOR( \ CHAOS_PP_SPLIT(0, NUMBER_ ## vseq) \ )), \ CHAOS_PP_SPLIT(1, NUMBER_ ## vseq) \ /**/ #define PARSE_O_B_B(vseq) \ (2, CHAOS_PP_REM_CTOR( \ CHAOS_PP_SPLIT(0, IDENTIFIER_ ## vseq) \ )), \ CHAOS_PP_SPLIT(1, IDENTIFIER_ ## vseq) \ /**/ #define PARSE_O_B_C(vseq) (0, vseq), // registrations... #define IDENTIFIER_CIRCLE (CIRCLE), #define IDENTIFIER_SQUARE (SQUARE), #define IDENTIFIER_TRIANGLE (TRIANGLE), #define IDENTIFIER_RECTANGLE (RECTANGLE), PARSE( CIRCLE RECTANGLE (a, b, c) TRIANGLE 3 (xyz) UNREGISTERED SQUARE ) (Apologies for any mistakes in the above. I wrote it up quickly.) This particular example results in key-value pairs of the form: (0, <unrecognized>) (1, <v-number>) (2, <registered-identifier>) (3, <tuple>) (2, CIRCLE) (2, RECTANGLE) (3, (a, b, c)) (2, TRIANGLE) (1, 3) (3, (xyz)) (0, UNREGISTERED SQUARE) There are a number of things that could be done instead of producing a binary sequence like this (which Boost.Preprocessor cannot handle). One could fold the results via a user-supplied macro, for example. Aside from the massive amount of clutter introduced by workarounds, many of the pieces of the above are already available either in Boost.Preprocessor or in other parts of the VMD library. For example, BOOST_VMD_IS_EMPTY is essentially CHAOS_PP_IS_EMPTY_NON_FUNCTION. -- Implementation -- I have not looked closely at the implementation, but I do know what a herculean effort it is to get this type of stuff working with VC++ in particular. -- Documentation -- There are few inaccuracies in the documentation related to motivations for various Boost.Preprocessor things, but those could be fixed. The documentation for BOOST_VMD_IS_EMPTY is decent except that essentially any input that ends with a function-like macro name will cause weird results or errors. So much so that the documentation should just disallow input that ends with a function-like macro name across the board. Other than that, the documentation needs some clean-up and organization (particularly of definitions), but does a reasonable job of documenting the library. I do feel that a lot of documentation complexity comes from the way that v-keys/v-identifiers (etc) are handled. -- Usefulness -- There is a definite use-case for many of the utilities in the library, and the fundamental concept v-sequence parsing. -- Testing -- I tested the library with GCC and everything functioned as advertised. -- Effort -- I did a fairly significant study of the design and interface of the library. -- Domain Familiarity -- I had my skull opened up and had "preprocessor metaprogramming" tattooed directly onto my brain. -- There are many good parts of the library--including the herculean effort to make it work on sub-par preprocessors such as VC++. However, at this point I would be hesitant to recommend acceptance based on the design of the v-type recognition and v-sequence parsing part. I am open to argument about why the current design is superior based on use-cases or technical limitations introduced by (e.g.) VC++ or, if it is not superior, a further review at a later date after a redesign because the underlying concept is sound. -- Regards, Paul Mensonides

3 14

Intel C++ Linux non-commercial software development license updated information
by Edward Diener 15 Sep '14

15 Sep '14

Just a quick note to tell anyone interested that evidently Intel has discontinued their free Intel C++ Linux compiler for developers based on their non-commerical software development license. If you look at their non-commercial software development license page at https://software.intel.com/en-us/non-commercial-software-development you will see that it only potentially offers a license for academics and the response I received on their online forum for Intel C++ is that they have discontinued their non-commercial software development license for developers, although they seem loth to make an announcement about it or publicize it. I have some recent versions of Intel C++ Linux with which I can still test but I will not be able to test the latest version(s) of Intel C++ on Linux. The isocpp Get Started page at https://isocpp.org/get-started still mentions the free Intel C++ version, but this evidently is no longer the case.

1 0