- Boost-users - lists.preview.boost.org

[stacktrace] Getting a stacktrace from unhandled exception in windows
by Don 11 Sep '17

11 Sep '17

I am trying use boost stacktrace to get a stack dump when my program encounters an unhandled exception under windows. I have installed a signal handler as described in the stacktrace documentation, and it gets called. However, the resulting stack trace is after everything has been unwound. For example, when I force a failure by dereferenceing a null pointer many levels down in my function hierarchy, the stack trace shows: 0# boost::stacktrace::detail::this_thread_frames::safe_dump_to_impl<char const *> at f:\home\tools\boost\boost\stacktrace\safe_dump_to.hpp:68 1# boost::stacktrace::safe_dump_to at f:\home\tools\boost\boost\stacktrace\safe_dump_to.hpp:120 2# my_signal_handler at f:\home\test\main.cpp:233 3# 0x5171407B 4# my_signal_handler at f:\home\test\main.cpp:235 5# 0x51713883 6# __tmainCRTStartup at f:\dd\vctools\crt_bld\self_x86\crt\src\crtexe.c:603 7# WinMainCRTStartup at f:\dd\vctools\crt_bld\self_x86\crt\src\crtexe.c:403 8# BaseThreadInitThunk in kernel32 9# RtlInitializeExceptionChain in ntdll 10# RtlInitializeExceptionChain in ntdll This is not particularly helpful, of course -- I want to know the call stack at the point of the failure. Is there any way to get that? What am I missing? Thanks, Don

2 2

Re: [Boost-users] [boost] Fit review - viboes
by P F 10 Sep '17

10 Sep '17

> On Sep 10, 2017, at 4:53 AM, Vicente J. Botet Escriba <vicente.botet(a)wanadoo.fr> wrote: > > > First sorry for the formatting of my original post. > > Le 09/09/2017 à 22:22, P F a écrit : >> >>> On Sep 9, 2017, at 6:27 AM, Vicente J. Botet Escriba via Boost <boost(a)lists.boost.org <mailto:boost@lists.boost.org>> wrote: >>> >>> Wondering if some parts should be moved to Boost.TypeTraits or reused from there (is_callable). >> >> But would that imply a C++98 compatible trait? Of course, I don’t see a reason to dump every trait used in boost into Boost.TypeTraits. > > I'm not talking about any traits. is_callable is special in the sense there is an equivalent in the C++ standard (is_invocable). > I don't think we should require that all the traits in Boost.Traits should be compatible C++98 when we are already in C++17. Ah yes, but I don't see why they need to be in Boost.TypeTraits. >> >>> >>> I'm missing the std::invoke function. >> >> What do you mean? std::invoke is provided by C++17. There is fit::apply, which will work like std::invoke except fit::apply also uses constexpr and is defined as a function object(so it can be passed to other functions). > > Why not call it invoke? I was trying to stay consistent with boost libraries. >>> If the user can use those classes the documentaion must document them. I guess they are useful to build other adaptors. It is not clear whether the defined functions would use SFINAE or just fail when used with types that don't respect the requirements. While I'm generally for SFINAE, I understand that it will not be the case in order to improve the compile time. >> >> The goal is to be as transparent as possible. So if `foo(f)(x)` is equivalent to `f(x)`, then if `f(x)` causes substitution failure, then `foo(f)(x)` causes substitution failure. The same is true for constexpr and noexcept on compilers that support those well enough. > > E.g. > > assert(compose(f, g)(xs...) == f(g(xs...))); > > If f and g don't compose, would compose(f, g) SFINAE the operator() or just compile fail. If `f(g(xs…))` is a substitution failure then `compose(f, g)(xs…)` is a substitution failure. > > If it SFINAE, I could use compose(f, g) to check if f and g are composable. You need to check `compose(f, g)(xs…)`. >> >>> It is not clear if the functions can be final function objects or not. >> >> They can be. There is no such restriction mentioned for the `Callable` or `ConstCallable` concept. > > Oh, I see it now. > > I believe there is however an issue when you have more than one final function objet. Do you have a test with two function objects? > If I remember the issue was because we can not inherit from two wrapper classes doing perfect forwarding. > If you don't have the issue, I will base my implementation of the proposed overload on your implementation ;-) I added tests with two final objects and see no problem. I am not sure the issue you were seeing. >>> >>> Possible files contains details that could be shared in Boost or used from other Boost libraries >>> >>> https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/move.hpp <https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/move.hpp> - I believe Hana use something like this also to reduce the dependencies (compile footprint) >>> https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/forward.… <https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/forward.…> >> >> Well hana uses a static_cast. Here, I use a macro which uses a static_cast if possible, and then I fallback to a function on compilers that can’t handle the static_cast. > > What I mean is that IMHO Boost should solve these issues in a single way. If we don't want to use directly e.g. <utility> because it is heavy, we should provide the lighter components in Boost. I don't believe it is a good approach to redefine them in each library that needs such basic facilities.. Yes, I agree there should be a library for this. However, this doesn’t exists yet. In the future, I can factor this out and put it in a separate library, but right now, I am proposing the Fit library. >> >>> https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/noexcept… <https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/noexcept…> >>> https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/and.hpp <https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/and.hpp> - I believe Hana use something like this also to reduce the dependencies (compile footprint) >> >> Well, I dont know of a library in boost that implements the fast_and algorithm that works on gcc 4.6+ and msvc. > > We have std::conditional. If we have a better option (for some compiler version) this should go to the Core library as any library could profit from it. It should not go into Core, there should be a separate library for this. If we just dump random stuff into Core, it will become like Utility. > This is a basic feature. >> >>> https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/compress… <https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/compress…> >> >> I dont know of a library that implements this. There is Boost.CompressedPair, but that implementation wouldn’t work at all for the Fit library. > > My comment included shared. If your compressed pair is better, we should improve Boost.CompressedPair. Perhaps, but this class is to solve very specific cases for the Fit library, so its built and tested around that. Some compilers have problems dealing with complex inheritance when using constexpr, so it is not as aggressive about empty optimization as Boost.CompressedPair. >>> >>> Quite good butthe description of the semantic of the provided functions would need some extra wording. Maybe a section that states that the semantic expression is part of the constraints on the types. >> >> What do you mean is part of the constraints on the type? > > Usually we describe the expressions that the types must support on the requirements. You use a semantic clause as requirement. What I mean is that the semantic clause implies the expression must be well formed and so is a requirement on the concerned types. The expression is not required to be well-formed. > That is the semantic expression is used to define what the function does and is also contains constraints of a not named Concept. What I would like is split the requirements and what the function does. It doesn’t describe requirements on the types as those are listed in the documentation already. Rather it is showing the semantically equivalent behavior. So when you write `compose(f, g)(xs…)` you could paste `f(g(xs…))` and the program should be practically equivalent even when the replacement happens in a decltype, noexcept, constexpr, or substitution failure. >> >>> >>> *Documentation:* >>> >>> In general: >>> >>> * Navigation only from the top of the page >>> >>> * Hyper links missing. >>> >>> * There is no link to real code from the examples. >> >> Most of the examples are a full running program that can be pasted in. > > Humm, I don't see the include on the code fragments, the needed using namespace, … Those don’t, I will try to setup a more fuller example. >> >>> >>> >>> In particular: >>> >>> *http://pfultz2.github.io/Fit/doc/html/doc/src/gettingstarted.html* <http://pfultz2.github.io/Fit/doc/html/doc/src/gettingstarted.html*> >>> >>> An explanation of the BOOST_FIT_LIFT limitations would be more than welcome. >> >> Good point. > Could you tell us here what they are? in detail? The limitation is in constexpr, but this only applies to c++14. This is because `BOOST_FIT_LIFT` uses a generic lambda. >> >>> >>> Typo: last right parenthesis in >>> >>> // Pipable sum >>> BOOST_FIT_STATIC_LAMBDA_FUNCTION(sum) = pipable([](auto x, auto y) >>> { >>> return x + y; >>> }); >>> >>> It is not clear if the following is correct in the body of a function >>> >>> auto sum = pipable([](auto x, auto y) >>> { >>> return x + y; >>> }; >> >> That needs to be corrected. > > Could you confirm that the previous code without using the BOOST_FIT_STATIC_FUNCTION is valid? Which one? You can’t write `BOOST_FIT_STATIC_FUNCTION(sum)` in c++14, however, in c++17 that is possible. > If yes I believe that the documentation could use this form as far as it is inside the body of a function. I was trying to demonstrate how to write functions other people can use. >>> >>> >>> *http://pfultz2.github.io/Fit/doc/html/doc/src/example_overloading.html* <http://pfultz2.github.io/Fit/doc/html/doc/src/example_overloading.html*> >>> >>> Typo: >>> >>> Before >>> // Check that T has member function for operator* and ope > >>> After // Check that T has member function for operator* and operator-> > > Note the typo above. Yea got it. >> *http://pfultz2.github.io/Fit/doc/html/doc/src/more_examples.html* <http://pfultz2.github.io/Fit/doc/html/doc/src/more_examples.html*> >>> >> >>> >>> My question is how both pipe operator overloads interact. >> >> How so? > > My bad. Each overload applies to different types, so that there shouldn't be no conflict. > > BTW, is operator|() defined only for pipable_adaptor<F>? Essentially yes. > > Could the user define a function object that is a pipable_adaptor for your library and it is also a pipable_xxx for the range library? What do you mean? > >> >>> >>> >>> >> >>> >>> Static Function Adaptor >>> >>> I would say "It has an additional requirement that the *class****function* is |DefaultConstructible|:" > > Don't forget this one. got it. >>> >>> >>> >>> *http://pfultz2.github.io/Fit/doc/html/doc/src/concepts.html* <http://pfultz2.github.io/Fit/doc/html/doc/src/concepts.html*> >>> ConstFunctionObject >>> >>> I would like to note that this concept is not representable using the Concept TS as it is quantifying universally on the Ts (args) parameters. >>> >>> The same applies to UnaryFunctionObject, BinaryFunctionObject >>> >>> Wondering if the documentation should use the term Concepts then. >> >> The purpose of the Concepts section is to document the type requirements. The current standard may not be able to check those type requirements in its current form, but there could be future versions of C++ that can check these type requirements. > > No, they couldn't if they are based on the Concept TS. The Concept TS doesn't have universal quantification, and I believe it wouldn't never had it from what the authors think about this feature. I agree, but it doesn’t mean we won’t have a future sematic-based concepts added that actually will help simplify generic programming. >> >>> >>> >>> The use of expresion "Is an object with ..." is confusing. What are we qualifying the type or the instance? >> >> This means the type is an object(ie scalar, array, union, or class). Of course, an array or union cannot have a call operator, so this only applies to classes and scalars that are pointers. > I believe it is better to use the term "type" here. It is a “type” but fulfills the requirements of `std::is_object`. >> >>> >>> EvaluatableFunctionObject >>> >>> It is not clear why this kind of FunctionObjects is useful >> >> This mainly used by the `fit::eval` and `fit::apply_eval` functions. > > I mean, it is not clear in this section, and some clarification is needed here. >> >>> >>> >>> Callable >>> >>> I believe we have moved to call this Invocable in the standard. But again, I believe that you want to quantify universally the arguments, isn't it? >> >> That is possible to check with the current C++(hence `is_callable`). This should be renamed to `Invocalbe` and `is_invocable`. > > Well is_invocable requires to know the type of the arguments. I believe that your Callable doesn't require to know with with types the function can be called. Could you confirm? Callable needs the type of the arguments, that is how `is_callable` is written. >>> >>> UnaryCallable >>> The name doesn't convey that it is *Const*Callable > > Any concern here? Since there is no standard UnaryCallable, I thought maybe I could sneak const in. I guess not. I will rename them to UnaryConstCallable. >>> >>> *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/compose.html <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/compose.html> *The requirements don't state clearly the constraints on the input parameters of f and the result of g, except by the semantic expression. This is a general remark. I suspect that you mean the semantic expression must be well formed. But, is this SFINAE friendly or is this a requirement? >> >> It is sfinae-friendly. > Could you add it to the reference documentation. This is an important feature. > In the standard they use "This function should not participate in overload resolution until ... or something like that. Is this really necessary? I think I would need to document when I change the semantic equivalence of the expression, not when I preserve it. I think it would be better in the definitions section to discuss the transparency aspect of the adaptors. >>> >>> Typo "Proposal for C++ Proposal for" >>> P0051 original proposal uses overload_linearly/overload (as Boost.Hana) instead of conditional/match. Wondering if those names aren't more clear. >> >> I really hate the name overload_linearly. Its long and doesn’t describe what it does. > > I don't find that conditional/match describe what they do. This is the eternal naming issue :) Its called `match` so it picks the best match using C++ overload resolution. Its also used for a form of pattern matching in visitors. I could use the name `overload`, but there a different ways of overloading. This is why I chose `match`. Its called `conditional` because it takes functions with conditions, and picks the first one. Perhaps the name `select` or `prefer` could be used. I am not sure. >>> >>> *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/implicit.html* <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/implicit.html*> >>> >>> Is implicit a StaticFunctionAdaptor? >> >> Yes. >> >>> Shouldn't StaticFunctionAdaptors have Functions as parameters? >> >> What do you mean? > That implicit has a template, not a class :( I should make the definition more flexible then. >> >>> Why this pattern respect the DRY principle (we don't repeat S), I believe it abuses of implicit conversions. >> >> Well, there is a caveat when someone uses ``auto`, like in your example: >> >> auto ptr = create_msg(); > yes, this is the caveat of returning a proxy that is convertible to anything. Could you warm the user in the documentation of this possible bad usage? >> >> There is a guard to prevent this, but it doesn’t work in C++17. > Could you elaborate? The guaranteed elision is in C++17 prevents this. As the class returned can only be copied by implicit conversion, by the copy elision makes this possible. >> >>> http://pfultz2.github.io/Fit/doc/html/include/boost/fit/indirect.html <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/indirect.html> >>> Wondering if it could be worth adding some preconditions as I guess that the function call >>> >>> indirect(f)(xs...) >>> >>> will be undefined if f is null >> >> That is true if `f` is a pointer, but is not true for all dereference operators. > > For example? http://pfultz2.github.io/Fit/doc/html/doc/src/faq.html#q-is-the-reinterpret… >>> *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/mutable.html <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/mutable.html> *Example of bad usage would be welcome.**Why Fit uses always const? **Why not use a reference to the function object instead? >> >> There is no way to safely manage the lifetime with a reference. > I was talking of reference_wrapper. > > IIUC, mutable should be used *only* to wrap existing functions that where no const but that don't modify the object (but it is a3rd party code and cannot be changed). I'm wrong? I believe, or if the mutations dont matter(perhaps it is just a cache). >>> Is there a safe way to use MutableFunctionObjects with Fit? >> >> Yes, you can use `std::ref. > > But reference_wrapper is a ConstFunctionObject. > I mean when mutable_ is safe? The 3rd party use case? Yes pretty much. > Do you have a good example of MutableFunctionObject that is safe? Well if the mutations don’t matter. Perhaps there is a cache, and so if the value isn’t there it just recomputes it. > After all I wonder if Mutable is the correct name. In C++ mutable means modifiable by a const function. I'll suggest NonConst as the function applicable to non-const objects. Well mutable is an actual keyword in the language, that is why I chose that. >>> http://pfultz2.github.io/Fit/doc/html/include/boost/fit/protect.html <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/protect.html> It is not clear to me what this useful for. Could you elaborate? >> >> When you want `bind` or `lazy` to capture a bind expression instead of evaluating it. > > and ... could you elaborate? Could you show how we can do it without fit::protect and with? You can’t do it without fit::protect, unless you use boost::protect. >> >>> Is there a typo here >>> assert(lazy(f)(protect(lazy(g)(_1)))() == f(lazy(g)(_1))) ^ Shouldn't it be assert(lazy(f)(protect(lazy(g)),_1)() == f(lazy(g)(_1))) >> >> Nope, that is correct. > > It is incoherent with the example. So maybe the example is wrong > > auto lazy_apply = lazy(apply)(protect(lazy_id), _1);` > > Or I'm missing something In the semantic requirements it assumes only a unary function. I could add a binary version in the semantic requirements. >> >>> >>> *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/result.html*** <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/result.html***> >>> This adaptor converts explicitly the result of the call to the type. Have you considered `convert_to`? >> >> It also adds a `result_type` to the function. Its mainly used to annotate function with the result type, which can be useful for fit::fix or Boost.Variant visitors. The documentation could make this clearer. > > Yes, I know that knowing the result type allows to optimize visitors. What is the main intent? to force the conversion or to have a way to retrieve the result type of a function object? Both actually. > The name should convey the main intent. > We have std::result_of until C++14 and invoke_result since C++17 to get the result type. Those aren’t the same as they try to deduce the type. The result adaptor provides a way to know the result type without deduction. >> >>> >>> *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/reveal.html* <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/reveal.html*> >>> >>> as_failures, with_failures, .... /adaptors/ don't appear on the index. >> >> You mean the table of contents? Yea, for them to appear there they need to be moved to a different section, with a header for each section. > You have items in the index that don't have his own file, e.g. http://pfultz2.github.io/Fit/doc/html/include/boost/fit/placeholders.html#u… <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/placeholders.html#u…>, so you should be able to add to it anything without needed a file, isn't it? Yes, but these would go under the adaptors section, which they don’t belong. >>> *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/static.html*** <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/static.html***> >>> >>> What are the differences of this adaptor and the macro STATIC_FUNCTION? >> >> STATIC_FUNCTION just declares a function objects at namespace or global scope, which requires the function to be constexpr constructible. The `static_` adaptor is to declare an adaptor that does not have a constexpr constructor. > > It is weird the example don't show the specific case as it uses static_ at global global scope. Could you show another example that is not at the namesapce o global scope. The purpose is to use at global or namespace scope, but the example should be update to use `BOOST_FIT_STATIC_FUNCTION`. > > Why static_ couldn't declare its default constructor constexpr? > I believe the description is on the other sense, which is why it is confusing. static_ requires a default constructor but don't requires the constructor to be constexpr and don't provides one constexpr default constructor It does provide constexpr constructor. Which is why it is useful because you can constepxr initialize a function object without a constexpr constructor. > , but I suspect that if the default constructor is constexpr it should work also. IIUC, you are saying that if it is the case then it is better to use the macro BOOST_FIT_STATIC_FUNCTION. They both can be used together. Although `static_` can be used at class scope. >>> *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/unpack.html* <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/unpack.html*> >>> >>> Why name it unpack instead of apply like in C++17? >> >> First, it doesn’t have the same signature as std::apply. > > Because you curry the function? Kind of. It is an adaptor. It also can take multiple sequences. >> Secondly, its very confusing, as ‘apply' generally means function applications especially in boost. So I would like to avoid this confusion. > > We are doing a function application here, isn't it? Eventually yes, but so does all the other adaptors. It doesn’t mean the other adaptors should be named apply either. >> >>> Need to introduce the Sequence concept and how it is customized? >> >> Hmm that is probably a better way to define it. >> >>> unpack_sequence? How unpack_sequence is used by unpack? >>> >>> *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/unpack_sequence.html*** <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/unpack_sequence.htm…> >>> Why unpack_sequence, and not the tuple-like traits? >> >> Not every sequence could be defined with indices. > For example? fit::pack has no index-based access, or if the sequence is defined as: auto seq = [](auto f) { reuturn f(1, 2, 3); }; >> >>> Is unpack_sequence defined if the class defines the tuple-like traits? >> >> No because they are not sfinae-friendly. > Why? Could you elaborate? The standard mandates that they are not sfinae-friendly. See: https://stackoverflow.com/a/41708982/375343 <https://stackoverflow.com/a/41708982/375343> As such there is no way to know if a type implements the std tuple-like traits. >> >>> Aside the example, it is not defined what the user must define. >> >> That could probably use more explanation. >> >>> What the member function apply must return? >> >> The result of calling `f`. > > These things need to be defined in the documentation. > > When a user specialize unpack_sequence, what are the constraints of the parameter F. Should it be ConstCallable? It will always be a FunctionObject. >> >>> How the unpack_sequence parameter and the Sequence parameter of member function apply are related? >>> I don't understand >>> >>> template<class F, class Sequence> >>> constexpr static auto apply(F&& f, Sequence&& s) BOOST_FIT_RETURNS >>> ( >>> s(std::forward<F>(f)) >>> ); Is a Sequence a callable taking a Callable or there is a type here? Is there a missing return? >>> >>> I suspect it should be >>> >>> template<class F, class Sequence> >>> constexpr static auto apply(F&& f, Sequence&& s) BOOST_FIT_RETURNS >>> ( >>> std::forward<F>(f)(s0, ,, sk); >>> ); >>> If this is correct, does it means that unpack just forwards to unpack_sequence? >> >> That example, I guess is a little confusing. As the `Sequence` is a function like fit::pack, but yes unpack calls unpack_sequence to do the unpacking for a single sequence. > Please, fix it. >> >>> Does the default specialization make use of INVOKE? >> >> Its not needed, as the function passed to `unpack_sequence` will always have a call operator. > I was talking of what the *default* specialization for tuple does. For any specialization, INVOKE is not necessary. >>> *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/repeat.html* <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/repeat.html*> >>> >>> Add requirement on the function parameter that must be a Unary function such that f(f(x)) is well formed. >> >> True, but the first call to repeat doesn’t need to be unary. > And what it could be? You lost me. Its the parameters passed by the user. That is `repeat(n)(f)(1, 2)` will call `f(1, 2)` the first time, and every time after that it will call `f` with the result of `f`. >>> *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/arg.html*** <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/arg.html***> >>> What is the rational for the choice of been 1-based? >> >> This is to match how placeholders work. So arg<1> and _1 are the same number. > I was sure that you had a good reason:) I went back and forth on this, but hana uses the convention. >>> *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/decay.html* <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/decay.html*> >>> >>> Why not decay_copy? >> >> It doesn’t always copy, like when passing reference_wrapper. > > It copies the reference_wrapper, isn't it? Nope, it returns a reference to the object being wrapped. >> >>> >>> >>> *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/placeholders.html*** <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/placeholders.html***> >>> Wondering if it is not better to locate them in a placeholders namespace, so that we can avoid possible collisions with other placeholders. >>> >>> *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/placeholders.html#unamed-placeholder* <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/placeholders.html#u…> >>> >>> The same here >> >> Ah, it could cause collision if users do `using boost::fit`. > Would you move to a nested placeholders namespace? Yes, I added a issue. >>> *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/apply.html*** <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/apply.html***> >>> Confusion with std::apply. is this related to std::invoke? >> >> Its not like std::apply, its like hana::apply. > > I know that it is not like std::apply, hence the possible confusion. >> Of course, maybe I could rename this to fit::invoke, and then add a fit::apply, that only calls the call operator. > > I don't see any reason to use a different name when the function are curried. fit::apply is not curried. >>> *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/tap.html* <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/tap.html*> >>> >>> How this is related to the tee unix command? >> >> I am not that familiar with unix tee. > https://en.wikipedia.org/wiki/Tee_(command) <https://en.wikipedia.org/wiki/Tee_(command)> It is kind of similar, but its not saving a file. >>> *http://pfultz2.github.io/Fit/doc/html/doc/src/configurations.html***Which <http://pfultz2.github.io/Fit/doc/html/doc/src/configurations.html***Which> ones? >>> > There are none now. Are there some or should this section be removed? Yea, for some reason they dont show. I dont know if something happened with the boost conversion. You can see the pre-boost version of this page here: http://fit.readthedocs.io/en/latest/doc/src/configurations.html <http://fit.readthedocs.io/en/latest/doc/src/configurations.html> Also, I added issues for a lot of the points raised in the email here: https://github.com/pfultz2/Fit/issues <https://github.com/pfultz2/Fit/issues> Let me know if I missed anything. Thanks, Paul

1 0

Re: [Boost-users] Fit review
by Andrea Bocci 09 Sep '17

09 Sep '17

Hi, maybe it's too late, but I hadn't seen this library before on the boost-users list. Would you consider a different name ? In the context of mathematical and statistical analysis, a "fit" is something else entirely - still related to "functions". Reading that "Fit is a header-only ... library that provides utilities for functions..." I was expecting something quite different ;-) Anyway, good job with library itself. Regards, .Andrea

2 1

Re: [Boost-users] [boost] Fit review - viboes
by P F 09 Sep '17

09 Sep '17

> On Sep 9, 2017, at 6:27 AM, Vicente J. Botet Escriba via Boost <boost(a)lists.boost.org> wrote: > > Hi, > > here it is my review. > > I believe that Boost.Fit should be*accepted*. Thanks for the review. > > > > *Design* > > The design is sound and clean. > > I have some concerns respect the the ConstFunctionObjects that I believe should merit an explanation on a rationale section. Why the library support only Const function objects? This is described in the FAQ, but maybe it should be moved to a rationale section. The main reasons are they are error prone, and in C++11 can’t be supported with constexpr. > > Wondering if some parts should be moved to Boost.TypeTraits or reused from there (is_callable). But would that imply a C++98 compatible trait? Of course, I don’t see a reason to dump every trait used in boost into Boost.TypeTraits. > > I'm missing the std::invoke function. What do you mean? std::invoke is provided by C++17. There is fit::apply, which will work like std::invoke except fit::apply also uses constexpr and is defined as a function object(so it can be passed to other functions). > > The_adaptor<> are not documented. Maybe in the definitions section I can go over how `foo(f)` is the same as `foo_adaptor<F>{f}`. > The utility of those classes is not documented. The are mainly useful for when you want to type-based transformations to functions. This is common when you need to pass a function as a template parameter(like with the comparator in std::map, the deleter in std::unique_ptr, or when using Boost.MultiIndex). > If the user can use those classes the documentaion must document them. I guess they are useful to build other adaptors. It is not clear whether the defined functions would use SFINAE or just fail when used with types that don't respect the requirements. While I'm generally for SFINAE, I understand that it will not be the case in order to improve the compile time. The goal is to be as transparent as possible. So if `foo(f)(x)` is equivalent to `f(x)`, then if `f(x)` causes substitution failure, then `foo(f)(x)` causes substitution failure. The same is true for constexpr and noexcept on compilers that support those well enough. > It is not clear if the functions can be final function objects or not. They can be. There is no such restriction mentioned for the `Callable` or `ConstCallable` concept. > *Implementation* > > Not seen in depth. > > It should use as much as possible Boost.Config and/or Boost.Predef Right now it uses sd-6 macros, but it could move to use Boost.Config(probably not Boost.Predef). > > Possible files contains details that could be shared in Boost or used from other Boost libraries > > https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/move.hpp - I believe Hana use something like this also to reduce the dependencies (compile footprint) > https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/forward.… <https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/forward.…> Well hana uses a static_cast. Here, I use a macro which uses a static_cast if possible, and then I fallback to a function on compilers that can’t handle the static_cast. > https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/noexcept… > https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/and.hpp - I believe Hana use something like this also to reduce the dependencies (compile footprint) Well, I dont know of a library in boost that implements the fast_and algorithm that works on gcc 4.6+ and msvc. > https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/compress… <https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/compress…> I dont know of a library that implements this. There is Boost.CompressedPair, but that implementation wouldn’t work at all for the Fit library. > https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/constexp… > https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/intrinsi… <https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/intrinsi…> This probably could be factored out in a separate boost library, which might be useful for other heavy metaprogramming libraries. > https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/pp.hpp > https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/remove_r… > https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/result_o… > https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/static_c… > https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/using.hpp > > It uses a lot of macros that make complex the understanding of what is behind. On the same file https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/compose.hpp and only on 169 lines > BOOST_FIT_INHERIT_CONSTRUCTOR, BOOST_FIT_RETURNS_CLASS, > BOOST_FIT_SFINAE_RESULT, BOOST_FIT_MANGLE_CAST, BOOST_FIT_DECLARE_STATIC_VAR, BOOST_FIT_NOEXCEPT_CONSTRUCTIBLE, > BOOST_FIT_ENABLE_IF_CONSTRUCTIBLE, BOOST_FIT_JOIN *Documentation* Some of those are documented. The others I could add some more comments in the code to what those do exactly. > > Quite good butthe description of the semantic of the provided functions would need some extra wording. Maybe a section that states that the semantic expression is part of the constraints on the types. What do you mean is part of the constraints on the type? > It takes too much pages to see what the library proposes. > For some functions we would need more information, examples. See below the detailed > > *Potential usefulness of the library* > > Very useful. > > *Did you try to use the library? With which compiler(s)? Did you have any problems?*** > Not tried yet. > > *How much effort did you put into your evaluation? A glance? A quick reading? In-depth study?*** > In-depth study of the documentation (about 5 h for this revision). > > *Are you knowledgeable about the problem domain?* > > In general, yes. > > *Were the concerns from the March 2016 review of Fit addressed?*** > I believe ;-) > > Best, > Vicente > > *Documentation:* > > In general: > > * Navigation only from the top of the page > > * Hyper links missing. > > * There is no link to real code from the examples. Most of the examples are a full running program that can be pasted in. > > > In particular: > > *http://pfultz2.github.io/Fit/doc/html/doc/src/gettingstarted.html* > > An explanation of the BOOST_FIT_LIFT limitations would be more than welcome. Good point. > > Typo: last right parenthesis in > > // Pipable sum > BOOST_FIT_STATIC_LAMBDA_FUNCTION(sum) = pipable([](auto x, auto y) > { > return x + y; > }); > > It is not clear if the following is correct in the body of a function > > autosum = pipable([](auto x, auto y) > { > return x + y; > }; That needs to be corrected. > > *http://pfultz2.github.io/Fit/doc/html/doc/src/example_print.html* > > I would suggest to use an heterogeneous tuple in the for_each_tupleexample. > > In addition use some kind of brackets to print the sequences and the tuples would help to identify what is been printed. I was trying to keep the example simple. However, with the print out its a little more confusing. > > > *http://pfultz2.github.io/Fit/doc/html/doc/src/example_overloading.html* > > Typo: > > Before > // Check that T has member function for operator* and ope After // Check that T has member function for operator* and opeerator-> > > I'm not sure the example is_derreferenceable is fair. Using is_detected, might be a little simpler, but it don’t think it would help overall. > > > *http://pfultz2.github.io/Fit/doc/html/doc/src/example_polymorphic_constructors.html* > > Maybe it is worth adding references to the proposals (P0318R0 and P0338R2) > > > *http://pfultz2.github.io/Fit/doc/html/doc/src/more_examples.html* > > Extension Methods > > It is not clear what numbers, filter and transform are in the example. I should add an implementation of those. > > I believe that the range proposal woul include the pipe operator. Although, there are some who don’t see the usefulness of it. > > My question is how both pipe operator overloads interact. How so? > > http://pfultz2.github.io/Fit/doc/html/doc/src/point_free.html > > typo > > Before > > |b(f)(x, y)| > > |after| > > > ||by(f)(x, y)|| > > > *http://pfultz2.github.io/Fit/doc/html/doc/src/definitions.html* > > It woul dbe great to have an example associated to each definition That is a good idea. > > Static Function Adaptor > > I would say "It has an additional requirement that the *class****function* is |DefaultConstructible|:" > > Decorator > I would say "The *resulting* Function Adaptor <http://pfultz2.github.io/Fit/doc/html/doc/src/definitions.html#function-ada…> may be an unspecified or private type.” Ok. > > Typo? > Some parts of the documentation provides > > > > *http://pfultz2.github.io/Fit/doc/html/doc/src/concepts.html* > ConstFunctionObject > > I would like to note that this concept is not representable using the Concept TS as it is quantifying universally on the Ts (args) parameters. > > The same applies to UnaryFunctionObject, BinaryFunctionObject > > Wondering if the documentation should use the term Concepts then. The purpose of the Concepts section is to document the type requirements. The current standard may not be able to check those type requirements in its current form, but there could be future versions of C++ that can check these type requirements. > > > The use of expresion "Is an object with ..." is confusing. What are we qualifying the type or the instance? This means the type is an object(ie scalar, array, union, or class). Of course, an array or union cannot have a call operator, so this only applies to classes and scalars that are pointers. > > Maybe it is worth defining FunctionObject. Trye, although I never use that concept, it would make sense for completeness sake. > > EvaluatableFunctionObject > > It is not clear why this kind of FunctionObjects is useful This mainly used by the `fit::eval` and `fit::apply_eval` functions. > > > Callable > > I believe we have moved to call this Invocable in the standard. But again, I believe that you want to quantify universally the arguments, isn't it? That is possible to check with the current C++(hence `is_callable`). This should be renamed to `Invocalbe` and `is_invocable`. > > Does your definition of INVOKE differs from the one on the standard? No, it shouldn’t, unless the standard doesn’t allow constexpr. > If yes, the differences should be mentioned. If not, the definition on the standard should be referenced. Would cppreference be acceptable? > > You use type T twice with different meaning > > "The type |T| satisfies |Callable| if" > > "if |f| is a pointer to member function of class |T|:" > > I believe that here the T are not the same. True, let me fix that. > > Are final function objects Callable, ConstCallable? Yes, why wouldn’t they be? > > > ConstCallable > The brief description is the same as the one for Callable > Is the definition of the second INVOKE different from the first one? No, it isn’t. The only difference is the f is of type `const T`. > > UnaryCallable > The name doesn't convey that it is *Const*Callable > > Metafunction and MetafunctionClass > it is not clear what those are, there is no brief description. I guess that this applies to f. > What do you mean by a type or a template? I see, that is a little confusing. These should follow the same definitions as in Boost.MPL. > > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/by.html* > > > It is not clear to me what > > by(p)(xs...) == p(xs)... mean > > > An example of `fit::by` without a function argument will be welcome. Good point. > > It is not clear how by_adaptor<Projection, F> and by_adaptor<Projection> can be used by the user? I could add an example using std::map. > Shouldn't those be hidden? No they shouldn’t be hidden. > > This is a genral remak, why F must be ConstCallable? For the same reason everything is ConstCallable. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/compose.html *The requirements don't state clearly the constraints on the input parameters of f and the result of g, except by the semantic expression. This is a general remark. I suspect that you mean the semantic expression must be well formed. But, is this SFINAE friendly or is this a requirement? It is sfinae-friendly. > Can both function be final function objects? **** In compose? Any of the functions can be final. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/conditional.html* > It is not clear what king of parameters this function could have (in particular in comparison with P0051). Does it accept function/data members pointers, final classes, references_wrappers, …? Yes, it takes any `ConstCallable` > > Typo "Proposal for C++ Proposal for" > P0051 original proposal uses overload_linearly/overload (as Boost.Hana) instead of conditional/match. Wondering if those names aren't more clear. I really hate the name overload_linearly. Its long and doesn’t describe what it does. > Why do we need to change the Boost.Hana names? Those names were chose before Boost.Hana. I use `conditional` because it was like a conditional block, especially when used with fit::if_. Perhaps, there is a better name. > There is also std::conditional :( Which really should’ve been called std::if_. > > Can more than 2 parameters be final function objects? Yes, of course. > > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/flip.html** > * > IIUC, F must not be BinaryCallable, but Callable with at least two arguments. True, let me update the documentation. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/implicit.html* > > Is implicit a StaticFunctionAdaptor? Yes. > Shouldn't StaticFunctionAdaptors have Functions as parameters? What do you mean? > I named the `auto_cast` function `explicitly` to do a explicit conversion. > > Other uses of this pattern I've see are to create a buffer able to store a specific struct > > struct S; > S* ptr = create_msg(); > > create_msg returns an class that is convertible to a T* and that allocates sizeof(T) bytes of memory. Ah yes, for that too. > > Why this pattern respect the DRY principle (we don't repeat S), I believe it abuses of implicit conversions. Well, there is a caveat when someone uses ``auto`, like in your example: auto ptr = create_msg(); There is a guard to prevent this, but it doesn’t work in C++17. > Anyway, I wanted just to share another use case for implicit. > > http://pfultz2.github.io/Fit/doc/html/include/boost/fit/indirect.html > Wondering if it could be worth adding some preconditions as I guess that the function call > > indirect(f)(xs...) > > will be undefined if f is null That is true if `f` is a pointer, but is not true for all dereference operators. > > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/infix.html** > * > > One of the asked infix operations is pow. However we would like to evaluate from right to left and have the higher precedence than * x pow ypow z===pow(x, pow(y,z)) > x * ypow z===x * pow(y,z) x pow y* z===pow(x,y) * zWith the proposed infix notation this should be written > x <pow> (y<pow> z)===x * pow(y,z) x * (y<pow> z)===x * pow(y,z) (x <pow> y)* z===pow(x,y) * z > and the following would be surprising > x <pow> y<pow> z===pow(pow(x, y, z) x * y<pow> z===pow(x * y, z) x <pow> y*z===pow(x, y * z) It would work better for swap or compare (proposed operator <=>) as these functions are not associative. I believe a note should prevent the users for such bad use cases, for which it is better to don't define the infix operator. That is a good example to talk about. I will add that. > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/lazy.html* Note p0356r1. It would be good to have a comparison in order either to improve the proposal or your library. That seems more related to fit::partial. > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/match.html* Same comments than for fit::conditional. What are ex typo "Proposal for C++ Proposal for" > Can more than 2 parameters be final function objects? *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/mutable.html *Example of bad usage would be welcome.**Why Fit uses always const? **Why not use a reference to the function object instead? There is no way to safely manage the lifetime with a reference. > Is there a safe way to use MutableFunctionObjects with Fit? Yes, you can use `std::ref. > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/partial.html* Are there any constraints on the type of xs. Shouldn't them be MoveConstructibles? That is true, since it decays the parameters. > http://pfultz2.github.io/Fit/doc/html/include/boost/fit/pipable.html > Are there any constraints on the type of x. No. > Shouldn't it be MoveConstructible? No, it is not necessary. Pipable does not capture the parameters by value, since it is almost always used in the same expression(ie `x | f(y)`). > http://pfultz2.github.io/Fit/doc/html/include/boost/fit/protect.html It is not clear to me what this useful for. Could you elaborate? When you want `bind` or `lazy` to capture a bind expression instead of evaluating it. > Is there a typo here > assert(lazy(f)(protect(lazy(g)(_1)))() == f(lazy(g)(_1))) ^ Shouldn't it be assert(lazy(f)(protect(lazy(g)),_1)() == f(lazy(g)(_1))) Nope, that is correct. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/result.html*** > This adaptor converts explicitly the result of the call to the type. Have you considered `convert_to`? It also adds a `result_type` to the function. Its mainly used to annotate function with the result type, which can be useful for fit::fix or Boost.Variant visitors. The documentation could make this clearer. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/reveal.html* > > as_failures, with_failures, .... /adaptors/ don't appear on the index. You mean the table of contents? Yea, for them to appear there they need to be moved to a different section, with a header for each section. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/reverse_fold.html* > > reverse_fold is not right fold, as right fold is right associative, isn't it? True, it is right fold with the arguments flipped. > > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/rotate.html*** > Could you show a concrete use case? > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/static.html*** > > What are the differences of this adaptor and the macro STATIC_FUNCTION? STATIC_FUNCTION just declares a function objects at namespace or global scope, which requires the function to be constexpr constructible. The `static_` adaptor is to declare an adaptor that does not have a constexpr constructor. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/unpack.html* > > Why name it unpack instead of apply like in C++17? First, it doesn’t have the same signature as std::apply. Secondly, its very confusing, as ‘apply' generally means function applications especially in boost. So I would like to avoid this confusion. > Need to introduce the Sequence concept and how it is customized? Hmm that is probably a better way to define it. > unpack_sequence? How unpack_sequence is used by unpack? > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/unpack_sequence.html*** > Why unpack_sequence, and not the tuple-like traits? Not every sequence could be defined with indices. > Is unpack_sequence defined if the class defines the tuple-like traits? No because they are not sfinae-friendly. > Aside the example, it is not defined what the user must define. That could probably use more explanation. > What the member function apply must return? The result of calling `f`. > How the unpack_sequence parameter and the Sequence parameter of member function apply are related? > I don't understand > > template<class F, class Sequence> > constexpr static auto apply(F&& f, Sequence&& s) BOOST_FIT_RETURNS > ( > s(std::forward<F>(f)) > ); Is a Sequence a callable taking a Callable or there is a type here? Is there a missing return? > > I suspect it should be > > template<class F, class Sequence> > constexpr static auto apply(F&& f, Sequence&& s) BOOST_FIT_RETURNS > ( > std::forward<F>(f)(s0, ,, sk); > ); > If this is correct, does it means that unpack just forwards to unpack_sequence? That example, I guess is a little confusing. As the `Sequence` is a function like fit::pack, but yes unpack calls unpack_sequence to do the unpacking for a single sequence. > Does the default specialization make use of INVOKE? Its not needed, as the function passed to `unpack_sequence` will always have a call operator. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/capture.html*** > Please, could you show how it is more flexible than lambda captures in C++? You can’t capture by value or reference dependending if it is an lvalue when using lambda captures. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/if.html* > > What happens when the parameter is false_type? SFINAE? Essentially yes. There is no call operator when its false. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/limit.html*** > if a function object is overloaded with 2 and 3 parameters, would limit be useful or it is only useful when the number of parameters is fixed? Yes its still useful, as it only sets a max limit. > I believe this is answered in http://pfultz2.github.io/Fit/doc/html/doc/src/partialfunctions.html, however I believe it merits a clarification here. > > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/repeat.html* > > Add requirement on the function parameter that must be a Unary function such that f(f(x)) is well formed. True, but the first call to repeat doesn’t need to be unary. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/repeat_while.html* > The same here. > > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/arg.html*** > What is the rational for the choice of been 1-based? This is to match how placeholders work. So arg<1> and _1 are the same number. > Could you add a rationale in the doc? Yea. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/construct.html* > > Maybe add a reference to the factory proposal p03382. Do you have a link? > > What happens when the parameter is not a T is not constructible from the params? SFINAE? Yes. > > What happens when the parameter is not a MetafunctionClass? SFINAE? Yes. > > I believe Boost.Hana uses make instead of construct. That is a possible name. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/decay.html* > > Why not decay_copy? It doesn’t always copy, like when passing reference_wrapper. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/identity.html *is identity a function or a function object? do we need identity()(x)? It can be treated as a function. I should update the synopsis to use a function signature instead. > > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/placeholders.html*** > Wondering if it is not better to locate them in a placeholders namespace, so that we can avoid possible collisions with other placeholders. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/placeholders.html#unamed-placeholder* > > The same here Ah, it could cause collision if users do `using boost::fit`. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/function_param_limit.html*** > |function_param_limit is not a Metafunction. "|The|function_param_limit| metafunction …" It is a metafunction(doing ::type works), but its actually more like a type trait. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/is_callable.html*** > F must be Callable can not be a requirement ;-) > > Add reference to C++17 trait is_invocable. > > Wondering if we should have it in type_traits, if not already there. > > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/apply.html*** > Confusion with std::apply. is this related to std::invoke? Its not like std::apply, its like hana::apply. Of course, maybe I could rename this to fit::invoke, and then add a fit::apply, that only calls the call operator. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/function.html* > > "By default, all functions defined with|BOOST_FIT_STATIC_FUNCTION| use thereveal <http://pfultz2.github.io/Fit/doc/html/include/boost/fit/reveal.html> adaptor to improve error messages." > > How to change this default? There isn’t a way. Perhaps I could add PP define to change it, but I wonder if its better to have some way to change it on a per-variable basis. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/lift.html*** > WhyBOOST_FIT_LIFT_CLASSdoesn't defines a instance as do BOOST_FIT_STATIC_FUNCTION? That maybe a better approach. Maybe I can call it BOOST_FIT_LIFT_FUNCTION. > > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/pack.html*** > How this is related with fit::capture? fit::capture uses fit::pack, but also does a pack_join to combine the pack and the parameters together. > > *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/tap.html* > > How this is related to the tee unix command? I am not that familiar with unix tee. > > *http://pfultz2.github.io/Fit/doc/html/doc/src/configurations.html***Which ones? > > > _______________________________________________ > Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost

1 0

[gsoc] Change in Google Summer of Code admin
by Niall Douglas 08 Sep '17

08 Sep '17

Dear all, Google Summer of Code 2017 has ended with another successful summer of student coding with probably the highest calibre year we've ever seen. After four years as lead admin for Boost Summer of Code, my time has come to an end. I'll be making way for David Bellot, long time mentor at Boost GSoC and maintainer of Boost.uBLAS. Please join me in welcoming David as new lead admin. I'll be staying on as backup admin next summer to help David settle in. My time as Boost Summer of Code admin has certainly been eventful with lots of surprises, ups and downs. The fact these surprises did not turn into crises is due in large part to a few people in particular who went far beyond the call of duty: * Jon Kalb, who went to bat for the students repeatedly in multiple venues and finding tens of thousands of dollars when it was needed. * Boris Schäling, whom I replaced as lead admin and who acted as backup admin for some years, who also managed to arrange tens of thousands of dollars of sponsorship when it was needed most. * Bryce Adelstein Lelbach, for acting as backup admin these past few years. * Andrew Sutton, the lead GSoC admin before Boris, who gave such detailed and useful early advice and materials on how to best navigate the treacherous waters of Google Summer of Code! And finally to all the mentors who so generously volunteered their time, and to the students every single one of whom successfully finished their projects in my time as admin despite problems with sickness, deaths in close family etc. Some of those students have gone on to become mainstays of the C++ conference circuit, famous names in their own right. I'm sure they would have been so without Google Summer of Code, but I'd like to think that it helped bring them to Boost rather than them getting into C++ via elsewhere. Thank you students! Regards, Niall

5 6

echo server modification causes undefined behaviour
by Peter Koukoulis 07 Sep '17

07 Sep '17

I'm a database developer and I'm using boost for the first time.I've copied the echo server & client example from the Boost website and modified it somewhat so that when I receive a SQL statement from the client I pass pass it onto a function that performs the db execution. Once executed Ireply back to the client how many rows were affected. The code works , if I send only a single request at a time from the synchronous client, so I modified the async server so that the read is a read_until.The change now crashes the server. Could somebody please help ?Attached is the code.

2 3

[release] Boost 1.65.1
by Daniel James 07 Sep '17

07 Sep '17

Release 1.65.1 of the Boost C++ Libraries is now available. These open-source libraries work well with the C++ Standard Library, and are usable across a broad spectrum of applications. The Boost license encourages both commercial and non-commercial use. This release contains bug fixes for existing libraries. For details, including download links, see <http://www.boost.org/users/history/version_1_65_1.html> You can also download directly from: <https://dl.bintray.com/boostorg/release/1.65.1/> To install this release on your system, see <http://www.boost.org/doc/libs/release/more/getting_started/index.html> Thanks to everyone who participated in this release. Thanks, -- The Boost Release Team Vladimir Prus Rene Rivera Marshall Clow Eric Niebler Daniel James Beman Dawes

3 2

[Multi_Index] Mixing composite keys with chained pointer value types
by Nick Gordon 07 Sep '17

07 Sep '17

I have a multi-index container that I'm using to fulfill two search cases. The objects are all derived from `Base`, which is a pure virtual class. To store the `Derived` objects I'm using unique_ptrs as the container value type. However, I need to store the objects uniquely on a composite of a member string, and an enum type used for runtime reflection without dynamic_cast-ing or typeid-ing. So, I want to use a composite key to be unique over both of these things. However, it doesn't compile (why else would I be posting). The minimum source code I can construct to fail using GCC 5.4.0 or Clang 3.9.1 with Boost 1.62 is attached in test.cpp, and the compilation error from my version of clang is attached as compilation-error.txt. I compile it with `clang++ --std=c++14 test.cpp`. I'm not familiar with how the library works, but my surface-level understanding is it seems that the chained_ptr is trying to act on the value type, but the operand being passed is actually one of the composite key expressions. I couldn't find much about how these two mechanisms interact. In my case it's not strictly necessary that I have this type-determining enum value, but it's cheaper than dynamic casting, and it makes my life simpler, because there are also many cases where we want to print the class name of the derived instance. There are other approaches, but I don't want to use them if I can get this working :) -Nick Gordon

2 1

Delete and free all elements of ptr_vector
by Florian Lindner 07 Sep '17

07 Sep '17

Hello, in my project we have a simple ptr_vector that has a member function: void deleteElements () { for ( CONTENT_T * elem : _content ) { assertion ( elem != NULL ); delete ( elem ); } } I want to replace this ptr_vector with boost::ptr_vector. However, I haven't found a way to delete and free all pointers stored in the container. How can I do that? Thanks, Florian

3 5

[Test] Can't build Boost Test 1.65.0 with Visual Studio 2013
by Kerry, Richard 07 Sep '17

07 Sep '17

I've just tried building Boost Test 1.65.0 with Visual Studio 2013 (ie msvc-12) and it doesn't seem to work, showing a compiler internal error. Can anyone advise what I might be doing wrong. Or whether a newer (or older) release fixes this issue. I've also tried 1.64.0 with an identical looking failure. Details below. Regards, Richard. I run : >b2 --with-test (as in the docs, though I'm not specifying address-model, link, --prefix or install. Having tried address-model and link as documented they appear to show the same fault). And then, after some messages, including "- test : building" (and nothing else listed as building), I get some messages starting: ...patience... ...found 1239 targets... ...updating 28 targets... compile-c-c++ bin.v2\libs\chrono\build\msvc-12.0\debug\link-static\threading-multi\chrono.obj chrono.cpp C:\Users\kerryr01\Downloads\Boost\boost_1_65_0\boost/type_traits/common_type.hpp(43) : fatal error C1001: An internal error has occurred in the compiler. (compiler file 'msc1.cpp', line 1325) To work around this problem, try simplifying or changing the program near the locations listed above. Please choose the Technical Support command on the Visual C++ Help menu, or open the Technical Support help file for more information Internal Compiler Error in C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\BIN\cl.exe. You will be prompted to send an error report to Microsoft later. call "C:\Users\kerryr01\AppData\Local\Temp\b2_msvc_12.0_vcvarsall_x86.cmd" >nul cl /Zm800 -nologo @"bin.v2\libs\chrono\build\msvc-12.0\debug\link-static\threading-multi\chrono.obj.rsp" ...failed compile-c-c++ bin.v2\libs\chrono\build\msvc-12.0\debug\link-static\threading-multi\chrono.obj... This is followed by a number of similar blocks of messages relating to: chrono.obj, thread_clock.obj, process_cpu_clocks.obj, cpu_timer.obj, auto_timers_construction.obj, execution_monitor.obj and others. [Blue line] Richard Kerry BNCS Engineer, SI SOL Telco & Media Vertical Practice T: +44 (0)20 3618 2669 M: +44 (0)7812 325518 4 Triton Square, Regent’s Place, London NW1 3HG richard.kerry(a)atos.net<mailto:richard.kerry@atos.net> [Atos logo] This e-mail and the documents attached are confidential and intended solely for the addressee; it may also be privileged. If you receive this e-mail in error, please notify the sender immediately and destroy it. As its integrity cannot be secured on the Internet, the Atos group liability cannot be triggered for the message content. Although the sender endeavours to maintain a computer virus-free network, the sender does not warrant that this transmission is virus-free and will not be liable for any damages resulting from any virus transmitted.</ Atos, Atos Consulting, Worldline and Canopy The Open Cloud Company are trading names used by the Atos group. The following trading entities are registered in England and Wales: Atos IT Services UK Limited (registered number 01245534), Atos Consulting Limited (registered number 04312380), Atos Worldline UK Limited (registered number 08514184) and Canopy The Open Cloud Company Limited (registration number 08011902). The registered office for each is at 4 Triton Square, Regent’s Place, London, NW1 3HG.The VAT No. for each is: GB232327983. This e-mail and the documents attached are confidential and intended solely for the addressee, and may contain confidential or privileged information. If you receive this e-mail in error, you are not authorised to copy, disclose, use or retain it. Please notify the sender immediately and delete this email from your systems. As emails may be intercepted, amended or lost, they are not secure. Atos therefore can accept no liability for any errors or their content. Although Atos endeavours to maintain a virus-free network, we do not warrant that this transmission is virus-free and can accept no liability for any damages resulting from any virus transmitted. The risks are deemed to be accepted by everyone who communicates with Atos by email.

2 2

flat_(multi)map/set and Compare::is_transparent
by TONGARI J 06 Sep '17

06 Sep '17

Hi, Since C++14, the standard introduces transparent comparators for heteregeneous lookup, but seems that the Boost's flat counterparts don't take advantage of this yet. Is there any plan to support transparent comparators? Thanks.

2 1

[Boost.Container] Boost.Container support for transparent comparators
by dariomt＠gmail.com 05 Sep '17

05 Sep '17

Hi, I see this trac ticket [1] with a feature request, and I'd like to know if there has been any progress on it. It doesn't look like it is in the latest release yet. Thank you! [1] https://svn.boost.org/trac10/ticket/11780

3 3

Boost 1.65.2 Release Candidate 2
by Daniel James 03 Sep '17

03 Sep '17

The second release candidates for the 1.65.1 release are now available at: <https://dl.bintray.com/boostorg/release/1.65.1/> The SHA256 checksums are as follows: df7bea4ce58076bd8e9cd63966562d8cf969b431e1c587969e6aa408e51de606 boost_1_65_1_rc2.7z 9807a5d16566c57fd74fb522764e0b134a8bbe6b6e8967b83afefd30dcd3be81 boost_1_65_1_rc2.tar.bz2 a13de2c8fbad635e6ba9c8f8714a0e6b4264b60a29b964b940a22554705b6b60 boost_1_65_1_rc2.tar.gz d1775aef807bd6a14077b450cce2950d8eacd86aaf51015f79e712917f8cc3c2 boost_1_65_1_rc2.zip As always, the release managers would appreciate it if you download the candidate of your choice and give building it a try. Please report both success and failure, and anything else that is noteworthy.

1 1

[release] Boost 1.65.1 Release Candidate 1
by Daniel James 01 Sep '17

01 Sep '17

The release candidates for the 1.65.1 release are now available at: <https://dl.bintray.com/boostorg/release/1.65.1/> The SHA256 checksums are as follows: 9b440d8167043c8d70326d8a5d4df98a59abb40be7d68f51e75ea95ea24d84f3 boost_1_65_1_rc1.7z fbd5663c748a88479adb4106c8a12009b149e602dec4b40a4a778381a33cf3ce boost_1_65_1_rc1.tar.bz2 b1b18d658cc0ff8a5030b29f4ed41de1826281fcb52fc1073b106c5802a570bd boost_1_65_1_rc1.tar.gz 542624352b2c3fd6a76c98624f90d2c0e62dd810ec6cc9fdae831677c7aa1fbf boost_1_65_1_rc1.zip As always, the release managers would appreciate it if you download the candidate of your choice and give building it a try. Please report both success and failure, and anything else that is noteworthy.

2 2

Help on boost::iostreams::gzip_compressor: Linker error
by Uthpal Urubail 31 Aug '17

31 Aug '17

Experts, I am getting below linker error on gzip compressor usage. Any help is highly appreciated. I have already tried linking boost_iostreams.lib & zlib.lib Code Description LNK2001 unresolved external symbol "int const boost::iostreams::zlib::default_compression" (?default_compression@zlib@iostreams@boost@@3HB) & Code Description LNK2019 unresolved external symbol "protected: __cdecl boost::iostreams::detail::zlib_base::~zlib_base(void)" (??1zlib_base@detail@iostreams@boost@@IEAA@XZ) referenced in function "int `public: __cdecl boost::iostreams::detail::zlib_compressor_impl<class std::allocator<char> >::zlib_compressor_impl<class std::allocator<char> >(struct iostreams::detail::zlib_params const &)'::`1'::dtor$0" (?dtor$0@?0???0?$zlib_compressor_impl@V?$allocator@D@std@@@detail@iostreams@boost@@QEAA@AEBUzlib_params@23@@Z@4HA) Regards, UJ

1 0

UDP Echo Server
by Mark Hieber 25 Aug '17

25 Aug '17

Hi,

3 3

[fiber][asio] Problem running http://www.boost.org/doc/libs/1_65_0/libs/fiber/examples/asio/autoecho.cpp
by Mark Hieber 24 Aug '17

24 Aug '17

Hi, I am using cmake 3.9.1 and Boost 1.65.0. I have downloaded the autoecho.cpp file and the corresponding yield.hpp, detail/yield.hpp and round_robin.hpp from http://www.boost.org/doc/libs/1_65_0/libs/fiber/examples/asio. When I run my program (just these 4 files, with no modifications), I get this output: Thread A: started Thread A: A0: echo-server started Segmentation fault Using print statements the seg-fault happens in the io_svc->run(); call. If anyone can help me with this, I would appreciate it. BTW, I am running on Ubuntu 16.04.3 LTS Thanks, Mark

2 1

Portable file I/O with system error codes support
by Oleg Andriyanov 23 Aug '17

23 Aug '17

Hi, I'm looking for a portable way to open a file, read some data from it, and do a proper error reporting in case of error. Apparently std::fstream is not suitable for this task because it does not provide means to retrieve original error code or even some human readable description of what went wrong (checking errno does not count since the standard does not guarantee it is set by any functions in std::fstream). I'm wondering if boost::iostreams can do that, but I've found nothing this far that could help in getting the error code. I've also tried boost::filesystem::fstream, but no luck. Users of large frameworks like Qt have advantage of their portable wrappers for file I/O like QFile. Are there any means in Boost which provide similar functionality? Related StackOverflow question: https://stackoverflow.com/questions/45840686/portable-way-to-read-a-file-in… Thanks.

3 2

[release] Boost 1.65.0
by Daniel James 21 Aug '17

21 Aug '17

Release 1.65.0 of the Boost C++ Libraries is now available. These open-source libraries work well with the C++ Standard Library, and are usable across a broad spectrum of applications. The Boost license encourages both commercial and non-commercial use. This release contains two new libraries and numerous enhancements and bug fixes for existing libraries. For details, including download links, see <http://www.boost.org/users/history/version_1_65_0.html> You can also download directly from: <https://dl.bintray.com/boostorg/release/1.65.0/> To install this release on your system, see <http://www.boost.org/doc/libs/release/more/getting_started/index.html> Thanks to everyone who participated in this release. Thanks, -- The Boost Release Team Vladimir Prus, Rene Rivera, Marshall Clow, Eric Niebler, Daniel James, Beman Dawes

1 0

Is there a C++ implementation for numerical quadrature/cubature?
by Easior Lars 20 Aug '17

20 Aug '17

Hi, all in the list! I need some functions to handle numerical quadrature/cubature in C++. I found that only few packages, e.g. GSL, could do this end. However, those ones are not pure C++ implementations. Although, odeint package in Boost can partially satisfy my need. I want to know whether there is a C++ implementation for numerical quadrature/cubature in Boost. Any suggestion? -- Best wishes, Easior ------ "It was the age of wisdom, it was the age of foolishness, it was the epoch of belief, it was the epoch of incredulity, it was the season of Light, it was the season of Darkness, it was the spring of hope, it was the winter of despair, we had everything before us, we had nothing before us, we were all going direct to heaven, we were all going direct the other way - in short, the period was so far like the present period, that some of its noisiest authorities insisted on its being received, for good or for evil, in the superlative degree of comparison only." TALES OF TWO CITIES, by Charles Dickens

3 5

[Boost][Container] Why is flat_set default constructor explicit?
by dariomt＠gmail.com 17 Aug '17

17 Aug '17

Hi all, I just found out that all Boost.Container default constructors are implicit (just as I would expect) except for flat_set. Quoting from [1]: explicit flat_set() noexcept(/*snip*/); Effects: Default constructs an empty container. Why is flat_set different than the other containers? Is this an oversight? FWIW this issue is breaking my C++14 code (for both clang and gcc) when switching from std::set to boost::container::flat_set, minimal repro follows: #include <boost/container/flat_set.hpp> #include <set> #ifndef USE_STD_SET using S = boost::container::flat_set<int>; #else using S = std::set<int>; #endif struct A { int i; S s; }; int main() { A a1; // OK A a2 {0, {{}} }; // OK A b1 {}; // FAILS A b2 {0}; // FAILS A b3 {0, {}}; // FAILS } A f() { return {}; // FAILS } Using Bost 1.64.0 in case that matters. Any help appreciated. [1] http://www.boost.org/doc/libs/1_64_0/doc/html/boost/container/flat_set.html…

2 1

Re: [Boost-users] Boost 1.65.0 Release Candidate 4
by Marshall Clow 17 Aug '17

17 Aug '17

On Wed, Aug 16, 2017 at 8:33 PM, Marshall Clow <mclow.lists(a)gmail.com> wrote: > The fourth (and hopefully final) release candidates for the 1.65.0 release > are now available at: > > https://dl.bintray.com/boostorg/release/1.65.0/source/ > [snippage] As always, the release managers would appreciate it if you download > the candidate of your choice and give building it a try. Please report > both success and failure, and anything else that is noteworthy. * Builds successfully with Apple Clang [Apple LLVM version 8.0.0 (clang-800.0.42.1)] with C++03/11/14/1z * Builds successfully with Clang Trunk [clang version 6.0.0 (trunk 310587)] with C++03/11/14 * Built successfully with Clang Trunk [clang version 6.0.0 (trunk 310587)] with C++1z except for Boost.Locale. -- Marshall

2 1

Boost 1.65.0 Release Candidate 4
by Marshall Clow 17 Aug '17

17 Aug '17

The fourth (and hopefully final) release candidates for the 1.65.0 release are now available at: https://dl.bintray.com/boostorg/release/1.65.0/source/ [ Note: The RC1s/RC2s/RC3s are in that directory, too - make sure you get the right files! ] Changes since RC3: * Fix a bug in Boost.Thread where timed waits were waiting for a very long time. Changes since RC2: * Fix a crashing bug in Boost.ASIO * Fix a compilation error when including both <boost/math_fwd.hpp> and <boost/math/common_factor_ct.hpp> * An update to Boost.Spirit to fix compilation errors on Mac OS with -std=c++17 Changes since RC1: * An update to Boost.Config so that the flags BOOST_NO_CXX98_RANDOM_SHUFFLE and BOOST_NO_CXX98_BINDERS are now set appropriately for libc++. (This fixes the compilation errors for Boost.Test) * An update to Boost.Fiber to fix compilation errors * An update to Boost.Wave to fix compilation errors on Mac OS with -std=c++17 The SHA256 checksums are as follows: 5d255d1ff8460d52dffcf9a9b55d908ae704027a66c590ec774096effaea26c1 boost_1_65_0_rc4.7z 911602d830ea5d16483d1e565b9859d120d03f2e5176017226ef391eb9d17fc8 boost_1_65_0_rc4.tar.bz2 369e06dc787d32b0fbaae020f33d814c9e7b77263acb859776968e623035f760 boost_1_65_0_rc4.tar.gz a9c6b8346b05ea43ac4278e80036a9e956ea99fc61f0b7f55469471af2df934c boost_1_65_0_rc4.zip As always, the release managers would appreciate it if you download the candidate of your choice and give building it a try. Please report both success and failure, and anything else that is noteworthy. Thanks! -- The release managers

2 1

Where we are 1.65.0
by Marshall Clow 16 Aug '17

16 Aug '17

RC1 came out on Monday, and it had some problems. Specifically: * Some libraries didn't build with ToT clang/libc++ (Locale, Wave and Test) This is because in C++17, some deprecated library features have been removed. [bind1st, mem_fun, auto_ptr, random_shuffle, etc ] Boost.Config has support for these removals, but this was ... incomplete. [ This is on me; I did the partial job of adding these to Config's libc++ support a while back ] Normally, I would be tempted to say "Well, clang 5 is not shipping yet, and so we can put this off until 1.66.0". But both clang 5 and C++17 are imminent (they will both happen well before the 1.66 release, and so I think we should fix this now. Also, a future version of MSVC will have the same library issues. So I have committed a fix for Boost.Config that fixes the Boost.Test issues. Hartmut has fixed most of the Boost.Wave issues. Artymom has a fix for Boost.Locale. Windows/MSVC builds look good across the board. * Boost.Fiber fails to build on Mac OS with anything other than -std=c++03. There is a fix in develop for this; but there's still a bunch of tests failing. * There's a problem from the beta in Boost.Math. The regression regarding boost/math/common_factor_ct.hpp (vs > math_fwd.hpp) seems to be still there. (For details please see the > original mail and replies: > https://lists.boost.org/Archives/boost/2017/07/237452.php) > What I presume is the fix (https://github.com/boostorg/math/pull/75) was > merged into develop about 12 hours ago, some automatic CI tests still > running. * There's a problem with ScopeExit and Visual C++ 2017 With Visual C++ 2017 and /permissive-, ScopeExit is still broken, for which > there's an open PR: > https://github.com/boostorg/scope_exit/pull/3 > Looks good otherwise on MSVC 14.11, tested with /std=cpplatest and > _HAS_AUTO_PTR_ETC=1, targeting Windows 10 and XP, 32 bit and 64 bit, built > as static libraries. >

5 5

constructing rationals from mpfr_floats [multiprecision]
by Dani Brake 15 Aug '17

15 Aug '17

Hi, 1) I am getting signaling due to division by 0. The following lines are faulty: mpfr_float p("1.1"); mpq_rational q(p); signal: integer divide by zero; whereas this succeeds: mpq_rational q(1.1); any one seen this before? i'm on compiler Apple LLVM version 8.0.0 (clang-800.0.38) ,with homebrew-provided boost 1.64, mpfr 3.1.5, gmp 6.1.2. -- 2) I also expected to be able to construct rationals as mpq_rational q("1.1") but it fails to parse using the built-in constructor. i mean, i understand why (1.1 isn't a rational), but given that i can construct a rational from a double, i figured that i'd get something reasonable from "1.1", namely 11/10. -- thanks! dani brake university of wisconsin eau claire ps i am not disabling mixed double-multiprecision arithmetic in this scenario, in case you have been reading my other questions this last week

1 0

Re: [Boost-users] deleting operators to forbid mixed arithmetic? [multiprecision]
by Dani Brake 15 Aug '17

15 Aug '17

Paul and John, Putting a macro bracket around this might make it generally useful, perhaps > something like: > > #ifdef BOOST_MULTIPRECISION_NO_DOUBLE_OPS (BUILTIN_OPS would include > float and long double?) > > … > > template <class Backend> > struct is_compatible_arithmetic_type<double, number<Backend> > : public > mpl::false_ {}; > > say > #endif > > If you find this useful, you could create a GIT Pull Request, or just > email the file changed. You won’t be the only one J. Defining the macro > BOOST_MULTIPRECISION_NO_DOUBLE_OPS could be a way to detect dodgy > conversions that need to be changed to keep full precision. I implemented this in my codebase, and had few ill effects. Some unexpected conversions, but I did find this disabling very useful. Wrapping it in a macro bracket and making it officially supported would be fabulous. I think it should go in number_base.hpp at line 110 or so. If we wanted to make it robust and thorough, I think we need to consider turning off implicit constructors from disabled types, too. I believe that what we have so far only disables arithmetic. Dani

1 0

Re: [Boost-users] Problem building Boost 1.64.0 with Oracle Developer Studio 12.6
by Leo Carreon 15 Aug '17

15 Aug '17

It’s now nearly a week since I sent this email and I have not received a comment from anyone from Boost. Does this mean we have no experience building on Developer Studio 12.6 or Boost doesn’t care whether it works on Solaris or not. I suspect Problem #2 may be a Solaris issue but I’m not sure about Problem #1 because even the guys from Oracle have no comment about it. I would appreciate a comment from the maintainer of Boost.Optional. From: Leo Carreon Sent: Wednesday, August 9, 2017 10:52 AM To: Boost Users Mailing List Subject: Problem building Boost 1.64.0 with Oracle Developer Studio 12.6 Hi Boosters, I have been trying to build Boost 1.64.0 with Oracle Developer Studio 12.6 on Oracle Solaris 11.3 x86_64. There are two errors encountered during the build. They are: 1. Problem with Boost.Optional with this error messages: "libs/log/src/named_scope.cpp", line 118: Error: Use of overloaded binary operator '=' is ambiguous. "./boost/optional/optional.hpp", line 900: Note: Viable candidate 'boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>& boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>::operator=<boost::log::v2_mt_posix::attributes::named_scope_list&>(boost::log::v2_mt_posix::attributes::named_scope_list&)'. "./boost/optional/optional.hpp", line 962: Note: Viable candidate 'boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>& boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>::operator=<boost::log::v2_mt_posix::attributes::named_scope_list&>(boost::log::v2_mt_posix::attributes::named_scope_list&)'. 2. Problem with Boost.Python with this error message: "libs/python/src/numpy/dtype.cpp", line 61: Error: NPY_FLOAT16 is not defined. Note that these two errors are the cause of 9 Boost shared libraries to not be generated. I would appreciate it very much if someone could give me some pointers on how to resolve the above issues. Kind regards, Leo

3 2

[Log][Optional][Python] Problem building Boost 1.64.0 with Oracle Developer Studio 12.6
by Leo Carreon 15 Aug '17

15 Aug '17

Hi, This is a resend with the suggested change on the subject line. I have been trying to build Boost 1.64.0 with Oracle Developer Studio 12.6 on Oracle Solaris 11.3 x86_64 in C++14 mode. There are three errors encountered during the build. They are: 1. Problem with Boost.Log with this error message: >> Assertion: (../lnk/initializer.cc, line 1865) while processing ./boost/log/expressions/message.hpp at line 98. My comment: Acknowledged by Oracle as a compiler issue. 2. Problem with Boost.Optional with this error messages: "libs/log/src/named_scope.cpp", line 118: Error: Use of overloaded binary operator '=' is ambiguous. "./boost/optional/optional.hpp", line 900: Note: Viable candidate 'boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>& boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>::operator=<boost::log::v2_mt_posix::attributes::named_scope_list&>(boost::log::v2_mt_posix::attributes::named_scope_list&)'. "./boost/optional/optional.hpp", line 962: Note: Viable candidate 'boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>& boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>::operator=<boost::log::v2_mt_posix::attributes::named_scope_list&>(boost::log::v2_mt_posix::attributes::named_scope_list&)'. My comment: Ambiguous boost::optional<>::operator=(), possibly a Boost configuration issue or compiler SFINAE issue. I’m not that fluent with SFINAE to be able to figure this out. 3. Problem with Boost.Python with this error message: "libs/python/src/numpy/dtype.cpp", line 61: Error: NPY_FLOAT16 is not defined. My comment: Possibly a Solaris package installation issue due to no support contract. (numpy package fails to install) I would appreciate it very much if someone could give me some pointers on how to resolve the above issues. Kind regards, Leo

1 0

Boost 1.65.0 Release Candidate 3
by Marshall Clow 14 Aug '17

14 Aug '17

The third (and hopefully final) release candidates for the 1.65.0 release are now available at: https://dl.bintray.com/boostorg/release/1.65.0/source/ [ Note: The RC1s and RC2s are in that directory, too - make sure you get the right files! ] Changes since RC2: * Fix a crashing bug in Boost.ASIO * Fix a compilation error when including both <boost/math_fwd.hpp> <boost/math/common_factor_ct.hpp> * An update to Boost.Spirit to fix compilation errors on Mac OS with -std=c++17 Changes since RC1: * An update to Boost.Config so that the flags BOOST_NO_CXX98_RANDOM_SHUFFLE and BOOST_NO_CXX98_BINDERS are now set appropriately for libc++. (This fixes the compilation errors for Boost.Test) * An update to Boost.Fiber to fix compilation errors * An update to Boost.Wave to fix compilation errors on Mac OS with -std=c++17 The SHA256 checksums are as follows: 1d844a958656e76b140292ec1cbfe770d9916166c16e13b59d3dac1df3b7ef40 boost_1_65_0_rc3.7z 3fc2877cf5da4bbb0c91eab058d2e6764155e705e9c3e2dce2a0248936079675 boost_1_65_0_rc3.tar.bz2 e065b53d7f5326cc20d246b518facedb4407391aaf9fd4a1c90001e0c85accab boost_1_65_0_rc3.tar.gz 96b2ba69c6045060d1dfe012218457870200c2c22af60eb855bab5ffb75c13a2 boost_1_65_0_rc3.zip As always, the release managers would appreciate it if you download the candidate of your choice and give building it a try. Please report both success and failure, and anything else that is noteworthy. Thanks! -- The release managers

1 1

Re: [Boost-users] deleting operators to forbid mixed arithmetic? [multiprecision]
by Dani Brake 14 Aug '17

14 Aug '17

> > So in principle you just define a full or partial specialization, for > example: > template <class Backend> > struct is_compatible_arithmetic_type<double, number<Backend> > : public > mpl::false_ {}; > and then cross your fingers and hope for the best ;) Thanks for the suggestion, i'll give it a try. \e crosses fingers ~dani

2 1

Re: [Boost-users] deleting operators to forbid mixed arithmetic? [multiprecision]
by Dani Brake 13 Aug '17

13 Aug '17

> > Been there, done that – fallen into the big pit awaiting the unwary mixing > double and multiprecision – again and again… L > I am being bit by this one hard. Converted a bunch of multipliers and tolerances from mpfr_floats to doubles in an effort to simplify some code, and now mixed precision is introducing error. > I think that you don’t really want to delete a family of operator*s – what > you DO want to get a warning when there is loss of significance, similar to > the warning when you fit a double into a float. > > It’s OK to multiply (or other ops) with a double as long as this doesn’t > lose any bits or digits of precision. > > So multiplying by 0.5 is OK, but not by multiplying 0.1 (the > multiprecision type needs FP_type(1)/10 to represent 0.1 as accurately as > possible for the FP type). > Multiplying by 0.1 is a common desire in my household (adaptive precision solving of polynomials). If only the compiler provided a trait bool is_exactly_representable(double) > so that a warning could be issued… > This is a bit tricky, because any double is by definition exactly representable by a double, right?. You would want is_exactly_representable to get the value before being transformed into a double? Another issue I foresee having to deal with is runtime parsing. Forbid the runtime user from feeding doubles problematic numbers. Thanks for the help, Dani

1 0

Re: [Boost-users] Problem building Boost 1.64.0 with Oracle Developer Studio 12.6
by Leo Carreon 12 Aug '17

12 Aug '17

It appears that Problem #1 is possibly a Boost configuration issue but may also be an issue with the compiler to do with enable_if. Two Boost.Optional member functions using enable_if are showing up in the lookup. Can anyone else comment? Problem #2 is possibly a Python package issue which can only be resolved by having a Solaris support contract because I’m unable to install the required packages to resolve the problem. From: Leo Carreon Sent: Wednesday, August 9, 2017 10:52 AM To: Boost Users Mailing List Subject: Problem building Boost 1.64.0 with Oracle Developer Studio 12.6 Hi Boosters, I have been trying to build Boost 1.64.0 with Oracle Developer Studio 12.6 on Oracle Solaris 11.3 x86_64. There are two errors encountered during the build. They are: 1. Problem with Boost.Optional with this error messages: "libs/log/src/named_scope.cpp", line 118: Error: Use of overloaded binary operator '=' is ambiguous. "./boost/optional/optional.hpp", line 900: Note: Viable candidate 'boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>& boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>::operator=<boost::log::v2_mt_posix::attributes::named_scope_list&>(boost::log::v2_mt_posix::attributes::named_scope_list&)'. "./boost/optional/optional.hpp", line 962: Note: Viable candidate 'boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>& boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>::operator=<boost::log::v2_mt_posix::attributes::named_scope_list&>(boost::log::v2_mt_posix::attributes::named_scope_list&)'. 2. Problem with Boost.Python with this error message: "libs/python/src/numpy/dtype.cpp", line 61: Error: NPY_FLOAT16 is not defined. Note that these two errors are the cause of 9 Boost shared libraries to not be generated. I would appreciate it very much if someone could give me some pointers on how to resolve the above issues. Kind regards, Leo

1 0

Re: [Boost-users] Problem building Boost 1.64.0 with Oracle Developer Studio 12.6
by Leo Carreon 12 Aug '17

12 Aug '17

BTW, I forgot to mention a third issue which has been acknowledged by Oracle as a problem with the compiler: 3. Problem with Boost.Log with this error message: >> Assertion: (../lnk/initializer.cc, line 1865) while processing ./boost/log/expressions/message.hpp at line 98. From: Leo Carreon Sent: Wednesday, August 9, 2017 10:52 AM To: Boost Users Mailing List Subject: Problem building Boost 1.64.0 with Oracle Developer Studio 12.6 Hi Boosters, I have been trying to build Boost 1.64.0 with Oracle Developer Studio 12.6 on Oracle Solaris 11.3 x86_64. There are two errors encountered during the build. They are: 1. Problem with Boost.Optional with this error messages: "libs/log/src/named_scope.cpp", line 118: Error: Use of overloaded binary operator '=' is ambiguous. "./boost/optional/optional.hpp", line 900: Note: Viable candidate 'boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>& boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>::operator=<boost::log::v2_mt_posix::attributes::named_scope_list&>(boost::log::v2_mt_posix::attributes::named_scope_list&)'. "./boost/optional/optional.hpp", line 962: Note: Viable candidate 'boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>& boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>::operator=<boost::log::v2_mt_posix::attributes::named_scope_list&>(boost::log::v2_mt_posix::attributes::named_scope_list&)'. 2. Problem with Boost.Python with this error message: "libs/python/src/numpy/dtype.cpp", line 61: Error: NPY_FLOAT16 is not defined. Note that these two errors are the cause of 9 Boost shared libraries to not be generated. I would appreciate it very much if someone could give me some pointers on how to resolve the above issues. Kind regards, Leo

1 0

deleting operators to forbid mixed arithmetic? [multiprecision]
by Dani Brake 12 Aug '17

12 Aug '17

Hi, I'd like to forbid multiplication of Boost.Multiprecision floating point numbers by doubles. Any tips? I think I want to delete a family of operator*s, but am having a hard time coming up with which ones. Thanks, Dani Brake University of Wisconsin Eau Claire

3 2

Boost 1.65.0 Release Candidate 2
by Marshall Clow 12 Aug '17

12 Aug '17

The second release candidates for the 1.65.0 release are now available at: https://dl.bintray.com/boostorg/release/1.65.0/source/ [ Note: The RC1's are in that directory, too - make sure you get the right files! ] Changes from RC1: * An update to Boost.Config so that the flags BOOST_NO_CXX98_RANDOM_SHUFFLE and BOOST_NO_CXX98_BINDERS are now set appropriately for libc++. (This fixes the compilation errors for Boost.Test) * An update to Boost.Fiber to fix compilation errors * An update to Boost.Wave to fix compilation errors on Mac OS with -std=c++17 The SHA256 checksums are as follows: 786ccb478a82ef526fb8649841d2e863af90d7ea31217bb2e938d87aff06cf23 boost_1_65_0_rc2.7z 83dbc7179271825c55a59c26f30cf9de53bb8b42006d920948bad709f5372af9 boost_1_65_0_rc2.tar.bz2 493cbf33a8837b44f87e3ac8a37ec32b9a0a27b8cdb03eac6237a16027a03809 boost_1_65_0_rc2.tar.gz 40e4ccbd52322f9a8cb6e1829075c810d8aad8851f3efb2b3da7fcff6963e14d boost_1_65_0_rc2.zip As always, the release managers would appreciate it if you download the candidate of your choice and give building it a try. Please report both success and failure, and anything else that is noteworthy. Thanks! -- The release managers

2 4

[serialization] archive testing
by Sergey Spiridonov 09 Aug '17

09 Aug '17

Hi, 1. The following works with xml_archive: cd boost_1_64_0/libs/serialization/test bjam -sBOOST_ARCHIVE_LIST=xml_archive.hpp 2. Example from documentation[1] does not work for me. Documentation tells[1]: -------------------------- To test a new archive, for example, portable binary archives, with the gcc compiler, make a header file portable_binary_archive.hpp and invoke bjam with -sBOOST_ARCHIVE_LIST=portable_binary_archive.hpp This process in encapsulated in the shell or cmd script library_test whose command line is library_test --toolset=gcc -sBOOST_ARCHIVE_LIST=portable_binary_archive.hpp ------------------------- [1] http://www.boost.org/doc/libs/1_64_0/libs/serialization/doc/archive_referen… I created boost_1_64_0/libs/serialization/test/portable_binary_archive.hpp with following lines: #include <libs/serialization/example/portable_binary_oarchive.hpp> typedef portable_binary_oarchive test_oarchive; typedef std::ofstream test_ostream; #include <libs/serialization/example/portable_binary_iarchive.hpp> typedef portable_binary_iarchive test_iarchive; typedef std::ifstream test_istream; #define TEST_STREAM_FLAGS (std::ios_base::openmode)0 1. There is no "library_test" script in boost_1_64_0.tar.bz2. 2. cd boost_1_64_0/libs/serialization/test bjam -sBOOST_ARCHIVE_LIST=portable_binary_archive.hpp fails with many linking errors like that: ../../../bin.v2/libs/serialization/test/test_array_portable_binary_archive.test/gcc-6.3.0/debug/test_array.o: In function `portable_binary_oarchive::save(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)': /home/ss/src/boost_1_64_0/libs/serialization/test/../../../libs/serialization/example/portable_binary_oarchive.hpp:105: undefined reference to `boost::archive::basic_binary_oprimitive<portable_binary_oarchive, char, std::char_traits<char> >::save(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)' What am i doing wrong? -- Best regards, Sergey Spiridonov GAMIC mbH, Roermonder Str. 151, 52072 Aachen, Germany Phone +49 241 889110 CEO Paul Malkomes Amtsgericht Aachen HRB 4029 VAT-ID: DE 121 677 540 Please use support(a)gamic.com for support requests and bug reports

1 0

[heap] Singular handle issue with MSVC iterator debug facilities
by Mateusz Loskot 09 Aug '17

09 Aug '17

Hi, Using VS2017 and Boost 1.64, I'm compiling a program which uses boost::heap::d_ary_heap. In debug configuration (with default _ITERATOR_DEBUG_LEVEL), I'm observing issues at run-time when a handle of item on the heap is compared against default-constructed instance of handle_type. BTW, the handle_type compiled in is based on std::list::iterator as defined in boost::heap::detail::priority_queue_mutable_wrapper. The issue is that MSVC iterator debug facilities break execution with File: c:\program files (x86)\microsoft visual studio\2017\professional\vc\tools\msvc\14.10.25017\include\list Line: 290 Expression: list iterators incompatible AFAIU, handle_type{}; seems to yield handle h object wrapping singular iterator. Below, minimal example to reproduces the problem is included. While debugging the sample, Visual C++ debugger does not show the iterator wrapped by the handle as default-constructed with null node pointer. Instead, it displays garbage: ((???, ???), ???) // ------------------------------------------------------------------ #include <cstdint> #include <functional> #include <boost/heap/d_ary_heap.hpp> using NodeID = std::uint32_t; using EdgeWeight = std::int32_t; using HeapData = std::pair<EdgeWeight, NodeID>; using HeapContainer = boost::heap::d_ary_heap< HeapData, boost::heap::arity<4>, boost::heap::mutable_<true>, boost::heap::compare<std::greater<HeapData>>>; using HandleType = HeapContainer::handle_type; int main() { HeapContainer heap; auto const handle = heap.push(std::make_pair(100, 1)); handle == HandleType{}; // _DEBUG_ERROR("list iterators incompatible"); return 0; } // ------------------------------------------------------------------ Is this a known MSVC drawback while working with boost::heap::d_ary_heap or above the handle_type is actually misused? Best regards, -- Mateusz Loskot, http://mateusz.loskot.net

1 0

Boost 1.65.0 Release Candidate 1
by Marshall Clow 09 Aug '17

09 Aug '17

The release candidates for the 1.65.0 release are now available at: https://dl.bintray.com/boostorg/release/1.65.0/source/ The SHA256 checksums are as follows: 0f1352a7738f24b39b564263b66a8c38bc7d984b57406396400474602e961ad3 boost_1_65_0_rc1.7z c2a022d4d6706668ea94b8e799a76e38929e0e34db884ef451fa9d5db6103238 boost_1_65_0_rc1.tar.bz2 7e84a27276792209d48357a0671348768dbf4dd1d4eadbf01b855274208f148d boost_1_65_0_rc1.tar.gz 537c42771b2351b4ea3eb8e9a13a3423edcd155323d2c14c4606cd23fc22d09f boost_1_65_0_rc1.zip As always, the release managers would appreciate it if you download the candidate of your choice and give building it a try. Please report both success and failure, and anything else that is noteworthy. Thanks! -- The release managers

4 5

[filesystem] Pull request needs attention
by Robert Dailey 09 Aug '17

09 Aug '17

I have fixed a crash I found due to static initialization ordering in boost filesystem. I have a proposed fix here: https://github.com/boostorg/filesystem/pull/47 It hasn't gotten any attention yet, so I'm hoping someone can offer some advice and/or merge the PR for me. Thanks in advance.

2 1

Problem building Boost 1.64.0 with Oracle Developer Studio 12.6
by Leo Carreon 09 Aug '17

09 Aug '17

Hi Boosters, I have been trying to build Boost 1.64.0 with Oracle Developer Studio 12.6 on Oracle Solaris 11.3 x86_64. There are two errors encountered during the build. They are: 1. Problem with Boost.Optional with this error messages: "libs/log/src/named_scope.cpp", line 118: Error: Use of overloaded binary operator '=' is ambiguous. "./boost/optional/optional.hpp", line 900: Note: Viable candidate 'boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>& boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>::operator=<boost::log::v2_mt_posix::attributes::named_scope_list&>(boost::log::v2_mt_posix::attributes::named_scope_list&)'. "./boost/optional/optional.hpp", line 962: Note: Viable candidate 'boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>& boost::optional<boost::log::v2_mt_posix::attributes::named_scope_list>::operator=<boost::log::v2_mt_posix::attributes::named_scope_list&>(boost::log::v2_mt_posix::attributes::named_scope_list&)'. 2. Problem with Boost.Python with this error message: "libs/python/src/numpy/dtype.cpp", line 61: Error: NPY_FLOAT16 is not defined. Note that these two errors are the cause of 9 Boost shared libraries to not be generated. I would appreciate it very much if someone could give me some pointers on how to resolve the above issues. Kind regards, Leo

1 0

Re: [Boost-users] [filesystem] Pull request needs attention
by Robert Dailey 08 Aug '17

08 Aug '17

On Tue, Aug 8, 2017 at 12:07 PM, Daniela Engert <dani(a)ngrt.de> wrote: > Am 08.08.2017 um 18:20 schrieb Robert Dailey via Boost-users: >> I have fixed a crash I found due to static initialization ordering in >> boost filesystem. I have a proposed fix here: >> https://github.com/boostorg/filesystem/pull/47 > > There is actually an even older (from april) pull request > https://github.com/boostorg/filesystem/pull/43 (by me) open on the very > same subject. > > Ciao > Dani Ah I didn't realize someone else had solved this problem. I will close mine in favor of yours. I don't quite understand why they're trying to share globals/statics between threads without some synchronization, but it's not my battle to deal with. I just want the code to work and not crash my application. Thanks for the reply.

1 0

make file starting out
by Peter Koukoulis 08 Aug '17

08 Aug '17

Hi I am new to setting up make files, and even newer to Boost. I've been using Geany on Ubuntu to learn Boost. When I compile and link using a single file with the following : g++ -g -Wall -std=c++14 -o "%e" "%f" -lboost_thread -DBOOST_THREAD_VERSION=5 -lboost_system -ldl then everything works as expected, for the following that is: #include <iostream> #include <boost/thread.hpp> #include <boost/thread/mutex.hpp> #include <boost/bind.hpp> #include <boost/asio.hpp> class t { private: boost::asio::io_service ios; std::unique_ptr<boost::asio::io_service::work> work_ios; boost::thread_group tg; int f; boost::mutex mx; public: // Constructor t( int p ) : work_ios{std::make_unique<boost::asio::io_service::work>(ios)}, f{p} { if(p>0) p = boost::thread::hardware_concurrency()*2; for ( int i = 0; i < p; ++i ) tg.create_thread( boost::bind( &boost::asio::io_service::run, &ios ) ); } // Destructor ~t () { work_ios.reset(); tg.join_all(); ios.stop(); } template <typename Job> void run_job( Job job ) { boost::unique_lock< boost::mutex > lock( mx ); if ( 0 == f ) return; --f; ios.dispatch( boost::bind( &t::wrap_job, this, boost::function< void() >(job) )); } private: void wrap_job( boost::function< void() > job ) { try { job(); } catch ( const std::exception& ) {} boost::unique_lock< boost::mutex > lock( mx ); ++f; } }; int main() { t tp{2}; tp.run_job( [] () { std::cout << "some work \n"; } ); return 0; } But when I attempt to split "t" into a .h and .cpp file with a separate file for main to test with, my linking does not work. The make output is: g++ test_t.o t.o -o test_t test_t.o: In function `__static_initialization_and_destruction_0(int, int)': test_t.cpp:(.text+0x6e9): undefined reference to `boost::system::generic_category()' test_t.cpp:(.text+0x6f5): undefined reference to `boost::system::generic_category()' The files look as follows: # the makefile: CC=g++ CFLAGS=-c -Wall -std=gnu++14 -lboost_system -lboost_thread -DBOOST_THREAD_VERSION=5 -ldl -lpq all: test_t test_t: t.o test_t.o $(CC) test_t.o t.o -o test_t t.o: t.cpp $(CC) $(CFLAGS) t.cpp test_t.o: test_t.cpp $(CC) $(CFLAGS) test_t.cpp clean: rm *o test_t.o test_t // .h file #ifndef T_H_ #define T_H_ #include <boost/thread.hpp> #include <boost/thread/mutex.hpp> #include <boost/bind.hpp> #include <boost/asio.hpp> class t { private: boost::asio::io_service ios; std::unique_ptr<boost::asio::io_service::work> work_ios; boost::thread_group tg; int f; boost::mutex mx; public: t( int p = 0 ); ~t(); template <typename Job> void run_job( Job job ) { boost::unique_lock< boost::mutex > lock( mx ); if ( 0 == f ) return; --f; ios.dispatch( boost::bind( &t::wrap_job, this, boost::function< void() >(job) )); } private: void wrap_job( boost::function< void() > job ) { try { job(); } catch ( const std::exception& ) {} boost::unique_lock< boost::mutex > lock( mx ); ++f; } }; #endif // .cpp file #include "t.h" // Constructor t::t( int p ) : work_ios{std::make_unique<boost::asio::io_service::work>(ios)}, f{p} { if(p>0) p = boost::thread::hardware_concurrency()*2; for ( int i = 0; i < p; ++i ) tg.create_thread( boost::bind( &boost::asio::io_service::run, &ios ) ); } // Destructor t::~t () { work_ios.reset(); tg.join_all(); ios.stop(); } // main file #include <iostream> #include "t.h" int main() { t tp{4}; tp.run_job( [] () { std::cout << "some work \n"; } ); return 0; } Could somebody point out how the make file should look like ? thanks pkl

4 3

boost::asio::async_read Error Operation canceled
by jupiter 07 Aug '17

07 Aug '17

Hi, I have a client program written by someone who is no longer available. The client program can send a message via async_write to server, but when the server responded back, the client boost::asio::async_read got an error of Operation cancelled. Searching from the Internet, it said the program was caused mostly by using this which should be fixed by using shared_from_this(). But in my client program it does not use this or shared_from_this, could someone explains if it uses some default format implies to this or shared_from_this in following example? (What (=) means, some kind of lambda function?) boost::asio::async_read(this->socket, boost::asio::buffer(this->messageHeader), [=](const boost::system::error_code &error, const uint32_t length) {this->readMessageHeader(error, length);}); Thank you. Kind regards.

1 0

Boost.Test change between 1.56 and 1.64
by Dominique Devienne 06 Aug '17

06 Aug '17

1.56 class BOOST_TEST_DECL test_tree_visitor { public: // test tree visitor interface virtual void visit( test_case const& ) {} virtual bool test_suite_start( test_suite const& ) { return true; } virtual void test_suite_finish( test_suite const& ) {} protected: BOOST_TEST_PROTECTED_VIRTUAL ~test_tree_visitor() {} }; 1.64 class BOOST_TEST_DECL test_tree_visitor { public: // test tree visitor interface virtual bool visit( test_unit const& ) { return true; } virtual void visit( test_case const& tc ) { visit( (test_unit const&)tc ); } virtual bool test_suite_start( test_suite const& ts ){ return visit( (test_unit const&)ts ); } virtual void test_suite_finish( test_suite const& ) {} protected: BOOST_TEST_PROTECTED_VIRTUAL ~test_tree_visitor() {} }; To list test suites and test cases of our test exes, I implemented a custom visitor in Boost 1.56 and simply did const auto& master_ts = but::framework::master_test_suite(); but::traverse_test_tree(master_ts, visitor); This is broken in 1.64, none of the old methods from the visitor are called, and thus no suites or cases are discovered. Two out of 3 of the old methods are forwards to the new visit() method, and obviously the implementation only calls the new visit(). The forwarding should be in the other direction for backward-compatibility. Looking for visit/visitor in http://www.boost.org/doc/libs/1_64_0/libs/test/doc/html/boost_test/change_l… yield nothing. Can someone please shed some light on this incompatible change? Thanks, --DD

2 2

Boost statechart
by Georg Gast 02 Aug '17

02 Aug '17

Hi, as the last changelog entry in statechart is from 1.46. Is it still maintained? Greetings Georg

1 0

[review][mp11] Review report
by Bjorn Reese 02 Aug '17

02 Aug '17

I. VERDICT Mp11 is accepted unconditionally into Boost. There were 14 accept votes and 1 conditional accept vote. See list at end of this report. II. DESIGN Reviewers evaluated the design as very good. Many agreed with the design principle of using template aliases on type lists, which means that Mp11 can be used on std, boost, and custom type lists. Integration with MPL was discussed. This resulted in a new header file <boost/mp11/mpl.hpp> that enables the conversion between mp_list (and std::tuple) and MPL sequences. A version of mp_eval_if that can apply a metafunction to type lists in both the true and false branch was requested. This is not possible due to C++ limitations (template parameter pack must be at the end.) Instead two alternatives were suggested: (1) use a nested mp_eval_if in the true branch, or (2) use mp_if<>::type with mp_defer in both branches. Extra metafunctions were added for working with map and sets: mp_is_set, mp_is_map, and mp_map_keys which returns a list of all keys. No review without a discussion about names. The mp_ prefix received most comments. The prefix is used to avoid collision between mp11 names and C++ keywords. The argument against the mp_ prefix was that MPL and other Boost libraries already have established trailing underscore as the naming convention. The argument in favor is that the mp_ prefix is better suited for later C++ standardization. Other names that deviate from MPL, such as apply versus fn, were also pointed out, and the names of tuple operations were also discussed. III. IMPLEMENTATION The reviewers who looked at the implementation were generally pleased with its quality and simplicity. A faster version of mp_find was proposed during review. On reviewer pointed out that const lists causes obscure compilation errors. IV. DOCUMENTATION The evaluation of the documentation was more mixed. Some found it good, while others found it too terse. A recurring comment was that the documentation is missing beginner-level explanations and examples. For instance, the tuple_cat example was mentioned as being too advanced for an introduction. More examples with higher-order metafunctions (e.g. mp_bind) was requested. The reference documentation does not state the pre-conditions of the metafunctions. For example, what happens when indices are out of bounds? The description of map (list of lists) lead to confusion. Mp11 map entries have one unique key-type, and zero or more value-types. The ability to have multiple value-types per key-type makes it possible to emulate multi-maps. Some where unsure whether C++11 or C++14 was required for the library. There were plenty of other useful comments that I will omit from the review report for the sake of brevity. V. USEFULNESS The library was generally deemed useful. It was discussed if C++11 (and later) makes it too easy to write our own metaprogramming utilities, and thus not needing a metaprogramming library. This was not directed at Mp11 in particular. Some of the arguments in favor of a metaprogramming library were better performance and portability. I would like to add another advantage of a metaprogramming library, namely that it gives us a common vocabulary. VI. CONCLUSION The library fulfills the quality and usefulness criteria without major outstanding issues. The library is therefore cleared to be included into Boost. My main recommendation as review manager is to make the documentation more beginner-friendly before the library is added to Boost. This is a recommendation, not a requirement. VII. PARTICIPANTS The following formal reviews were posted: * Barrett Adair : Accept * Brook Milligan : Accept * Edward Diener : Accept * Glen Fernandes : Accept * Jason Rice : Accept * Joaquin M López Muñoz : Conditional accept * John P Fletcher : Accept * Lee Clagett : Accept * Paul Fultz : Accept * Peter Koch Larsen : Accept * Robert Ramey : Accept * Roberto Hinz : Accept * Vijayan : Accept * Vinnie Falco : Accept * Zach Laine : Accept I would like to thank all participants for their efforts. I would also like to thank Peter Dimov for bringing such a high-quality library to Boost.

2 1

boost-users@lists.boost.org
by phillip mobley 02 Aug '17

02 Aug '17

Hello all, I am a new user to boost. I am currently using the serialization library to save my data structures to a file. However, I am currently running into a few issues. At first, I was getting a lot of undefined errors. After reading on multiple forums, I realized that I forgot to link the serialization library to the project. Once done, all of the errors went away. Except for one. I am getting this error: /usr/local/boost_1_64_0/boost/serialization/throw_exception.hpp:36: undefined reference to `boost::archive::archive_exception::archive_exception(boost::archive::archive_exception const&)' I have been spinng my head around this for a few days. Did I forget to add in another referene somewhere? My code is setup in the same manner as the simple tutorial found on the boost::serialization page. This error only pops up when I have the line: boost::archive::text_oarchive oa(ofs); When I have this line commented out, I do not get the above error. Again, I am wondering if I forgot to reference something in my program but I am not sure. Any help will be greatly appreciated. <https://www.avast.com/sig-email?utm_medium=email&utm_source=link&utm_campai…> Virus-free. www.avast.com <https://www.avast.com/sig-email?utm_medium=email&utm_source=link&utm_campai…> <#DAB4FAD8-2DD7-40BB-A1B8-4E2AA1F9FDF2>

1 0

Which socket read get first when both asio::async_read and asio::read are active?
by jupiter 02 Aug '17

02 Aug '17

Hi, I have a socket server program to activate in asio::async_read for receive any messages initiated from client. But when the server sends a message to the client, it uses sync write and flowing a sync read (asio::read) to immediately receive the response. The issue I can think of is who will get first read when both asio::async_read and asio::read are active? Thank you. Kind regards.

2 2

Boost.Fusion macro expansion
by Robert Jones 01 Aug '17

01 Aug '17

Hi Peeps Can anyone tell me what's wrong with this? I think macro expansion is going awry, but I'm not sure why. Do I really have to typedef the map<...> type to keep Fusion happy? Thx. #include<string> #include<map> #include <boost/fusion/adapted/struct/define_struct.hpp> #include <boost/fusion/include/define_struct.hpp> BOOST_FUSION_DEFINE_STRUCT( (demo), curves, ((std::map<std::string, std::string>), futures) ((std::map<std::string, std::string>), credit_curves) ) int main( ) { return 0; } > make fusion.cpp|9 col 39| error: invalid declarator before ‘)’ token || ((std::map<std::string, std::string>), futures) Kind Regards Rob.

3 3

Ranges
by Robert Jones 29 Jul '17

29 Jul '17

I realise this isn't strictly about Boost, but I'd appreciate if someone could say a few words about the current state of ranges in the standard, Boost or elsewhere. I'm familiar with the current Boost.Range, but thought there was a newer and rather different range library from Eric Neibler which was Boost compatible but not formally part of Boost, is that right? Are either of these part of the C++ standard, either now or planned, or is there anything else planned for the standard? Thx. Kind Regards Rob.

2 1