- Boost - lists.preview.boost.org

boost::random, header-only, boost::uuids::detail::seed_rng, and UWP development
by James E. King, III 14 Sep '17

14 Sep '17

Hi folks, It looks like the only reason boostorg/random is not a header-only library is due to random_device (it is the only src/ file: https://github.com/boostorg/random/tree/develop/src) The older WinCrypt calls are not available in some Windows platforms going forward, so this is going to become a problem pretty quickly for the community. In the boostorg/uuid library there is a seed_rng class which is doing similar things (however providing more entropy) and the library is header-only. In addition there are two filed defects - one in Trac and one in github issues, about uuid being incompatible with UWP applications (that's Windows universal apps). In uuid, I started adding support for BCrypt which is a Windows API supported on later versions of Windows, and once I changed my build flags to target Windows 10 and WINAPI_FAMILY_APP, I started getting build failures in random_device. On further inspection it looks like the random library doesn't have support for BCrypt yet, and even worse as a source library one would need to build two variants - one for WinCrypt and one for BCrypt to support older and newer windows platforms. There are also some implications on MinGW, as the older original MinGW has support for WinCrypt and MinGW-64 supports both. I'm going to propose that the implementation from boost::uuids::detail::seed_rng be moved into boost::random as the new random_device implementation. At the same time, boost::random will become header-only, and thus support setting _WIN32_WINNT at build time of consuming applications properly, and therefore support new Windows platforms properly. At the same time I would like to change seed_rng such that it no longer silently ignores some return values, and does not disable any compiler warnings (deprecations, currently). Thoughts? Thanks, - Jim

6 15

C++17 detection
by Robert Ramey 14 Sep '17

14 Sep '17

How do I get ready for C++17? I have a piece of code which requires C++14. I want to use something from C++17 but I also want my code to work now. So I have #if C++14 being used namespace std { // implement C++ function } // std I've looked in the documentation for Boost.Config and can't find any hints there. What is the best way to do this? Robert Ramey

14 25

[review queue] we seem to have double allocated early September for review --- what to do?
by Thorsten Ottosen 12 Sep '17

12 Sep '17

Hi All, I was about to announce the start of the Boost.Double_ended review, running from today to 17th of September. This is what we agreed upon with John (Phillips). Now, when I look at http://www.boost.org/community/review_schedule.html it seems that there is also a review of the Fit library scheduled, greatly overlapping with Boost.Double_ended. Do we run two reviews simultaneously, or what? kind regards Thorsten

5 12

Re: [boost] Review Request: impl_ptr (pimpl)
by Vladimir Batov 11 Sep '17

11 Sep '17

On 2017-08-19 23:55, Mario Lang wrote: > Vladimir Batov via Boost <boost(a)lists.boost.org> writes: > ... > I got interested enough by this posting so that I ended up doing my own > mini-review just right now :-). And I just wanted to let you know (and > encourage you) that I like this one alot. Keeping the public interface > free of boilerplate is quite nice! Mario, Thank you for your input. Much appreciated... although somewhat early. :-) It was pointed out to me that Boost review procedures changed and a proposal has to be endorsed before it can move to the review stage. So far I do not see it happening... maybe because the list is quiet (overall), maybe because iml_ptr is not good enough to attract that support/endorsement, maybe giving "endorsement" puts too much pressure and people shy away from it. We'll see. > I think for a full boost review, you will probably need to work on: > * The documentation > While I gave it a read, I ended up skipping to your test case because > I wanted to see working example code. > While the current docs have quite some examples, they spend a lot > more > screen space with showing what impl_ptr tries to replace, without > showing a good motivating positive example of how it actually looks > when employed. It also feels like it is spending some time with > marketing speak, while not really showing what it is trying to sell: Yes, I hear you... and I (at least partially) agree with you. First, no code or documentation will ever be to everyone's liking... unless everyone writes their own. Secondly, the documentation reflects many discussions we've had on this list about pimpl. For ex., I had to explicitly add what you call "marketing speak" to plainly explain why IMO pimpl is important. I had to address numerous "why bother" dismissing comments. What you call "marketing speak" I call an architectural view of a project. IMO it's quite different from developer's view that you seem to favor. All views are important... and all of them IMO need to be mentioned to cater for and to convince different readers. Surely, you (as a developer) is free to skip the "marketing speak". Somebody else (an architect and code-reviewer) might decide to skip other bits. No drama. Does it make sense? > The separation between the public interface in a hpp and the template > specialization in a cpp. I think the motivating example should > clearly show what part of the code goes where. Isn't what I did in third and fourth chapters? That said, I'll never be able to write the way you (or somebody else) like it. So, if you feel really strongly about it, please feel free to re-write it as you feel proper and submit. I am more than happy to consider and take others help. Unfortunately, that'll reverse our positions as I (and potential reviewers) might be saying "nuh, not enough "marketing speak" and such. No pressure... but that's an option to shape it up to your liking. > * Namespace: > While the alias is good, I think the whole code should be moved to > boost::, and the detail to boost::detail::impl_ptr::. > I am sort of guessing this will come up in the review. > I might be interested to help with that and submit the renaming PR if > you are open to that. 1) I do agree that the "whole code should be moved to boost::"... when it is part of Boost. Currently it is not. Currently I am on the earliest stage of gathering interest and waiting for "endorsement" and the review manager. 2) As I think I mentioned before impl_ptr is not part of any namespace by design... because the way proxy and implementation are connected, the specialization of impl_ptr<>::implementation. As I also mentioned it is IMO only a "problem" for "purists" but not for "practitioners" as from outside it is all kosher and accessed via boost::impl_ptr. You might be interested in searching for "Pimpl Again?" thread on this list for prev. discussions. Still, it you know a way around it and willing to submit your suggestions, I am certainly open for and most welcome it. But just to state the obvious -- as you do not like every line of code/doc that I write -- that goes both ways.

5 14

[beast] Post-review follow up (RE: chunk-encoding) NEEDS YOU!
by Vinnie Falco 11 Sep '17

11 Sep '17

During the formal review for Beast, a valid point was raised that the facilities for interacting with the chunks which make up a chunk-encoded was insufficient for some use-cases. I added more interfaces to addresses the use-cases but I never got feedback from the stakeholders about the design. It is now September 10th, and the "pencils down" deadline for making changes to Beast ahead of the 1.66.0 scheduled release is October 25th. As I have not gotten any feedback, I am asking the community if there is anyone out there who would like to review the new chunk-encoding facilities. As of yet, no one in the wild has used them. Or if they have, I did not hear of it. This is the documentation for the chunking: <http://www.boost.org/doc/libs/master/libs/beast/doc/html/beast/using_http/c…> Repository: <https://github.com/boostorg/beast> Any feedback is appreciated. Thanks

1 0

Fit review - viboes
by Vicente J. Botet Escriba 10 Sep '17

10 Sep '17

Hi, here it is my review. I believe that Boost.Fit should be*accepted*. *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? Wondering if some parts should be moved to Boost.TypeTraits or reused from there (is_callable). I'm missing the std::invoke function. The_adaptor<> are not documented. The utility of those classes is not documented. 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. It is not clear if the functions can be final function objects or not. *Implementation* Not seen in depth. It should use as much as possible Boost.Config and/or 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/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) https://github.com/pfultz2/Fit/blob/boost/include/boost/fit/detail/compress… 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/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* 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. 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. 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. 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; }; *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. *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. *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 believe that the range proposal woul include the pipe operator. My question is how both pipe operator overloads interact. 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 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." 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 use of expresion "Is an object with ..." is confusing. What are we qualifying the type or the instance? Maybe it is worth defining FunctionObject. EvaluatableFunctionObject It is not clear why this kind of FunctionObjects is useful 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? Does your definition of INVOKE differs from the one on the standard? If yes, the differences should be mentioned. If not, the definition on the standard should be referenced. 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. Are final function objects Callable, ConstCallable? ConstCallable The brief description is the same as the one for Callable Is the definition of the second INVOKE different from the first one? 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? *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. It is not clear how by_adaptor<Projection, F> and by_adaptor<Projection> can be used by the user? Shouldn't those be hidden? This is a genral remak, why F must be 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? Can both function be final function objects? **** *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, ...? 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. Why do we need to change the Boost.Hana names? There is also std::conditional :( Can more than 2 parameters be final function objects? *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. *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/implicit.html* Is implicit a StaticFunctionAdaptor? Shouldn't StaticFunctionAdaptors have Functions as parameters? 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. Why this pattern respect the DRY principle (we don't repeat S), I believe it abuses of implicit conversions. 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 *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. *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. *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? Is there a safe way to use MutableFunctionObjects with Fit? *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? http://pfultz2.github.io/Fit/doc/html/include/boost/fit/pipable.html Are there any constraints on the type of x. Shouldn't it be MoveConstructible? 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? 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))) *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`? *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/reveal.html* as_failures, with_failures, .... /adaptors/ don't appear on the index. *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? *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? *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/unpack.html* Why name it unpack instead of apply like in C++17? Need to introduce the Sequence concept and how it is customized? 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? Is unpack_sequence defined if the class defines the tuple-like traits? Aside the example, it is not defined what the user must define. What the member function apply must return? 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? Does the default specialization make use of INVOKE? *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++? *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/if.html* What happens when the parameter is false_type? SFINAE? *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? 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. *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? Could you add a rationale in the doc? *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/construct.html* Maybe add a reference to the factory proposal p03382. What happens when the parameter is not a T is not constructible from the params? SFINAE? What happens when the parameter is not a MetafunctionClass? SFINAE? I believe Boost.Hana uses make instead of construct. *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/decay.html* Why not decay_copy? *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)? *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 *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 ..." *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? *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? *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? *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/pack.html*** How this is related with fit::capture? *http://pfultz2.github.io/Fit/doc/html/include/boost/fit/tap.html* How this is related to the tee unix command? *http://pfultz2.github.io/Fit/doc/html/doc/src/configurations.html***Which ones?

2 3

How to deal with unused variable with a BOOST_ASSERT check?
by James E. King, III 10 Sep '17

10 Sep '17

In serialization (boost/archive/iterators/mb_from_wchar.hpp) there is some code that generates a warning on release builds. We're always striving for warning-free code in all cases. Here's the snippet: std::codecvt_base::result r = m_codecvt_facet.out( m_mbs, & value, & value + 1, wend, m_buffer, m_buffer + sizeof(m_buffer), bend ); BOOST_ASSERT(std::codecvt_base::ok == r); Normally I'd say one should always check the result and throw an exception instead of relying on an assert. I'm sure consumers would like that more. That said, is there another macro that would allow me to change the code to do something like this? BOOST_ASSERT_ASSIGN_OR_IGNORE(std::codecvt_base::result r) m_codecvt_facet.out( m_mbs, & value, & value + 1, wend, m_buffer, m_buffer + sizeof(m_buffer), bend ); BOOST_ASSERT(std::codecvt_base::ok == r); where BOOST_ASSERT_ASSIGN_OR_IGNORE would expand to, assuming BOOST_ASSERT_ACTIVE is an indicator whether assert code is compiled in: #if BOOST_ASSERT_ACTIVE std::codecvt_base::result r = #else (void) #endif This would allow me to eliminate the warning without submitting a PR that changes the behavior of the code. If something like this does not exist, would it be useful for me to add it to boostorg/assert, or would folks recommend against encouraging this behavior and instead change it to use exceptions? Thanks, Jim

5 4

range/concepts.hpp broken on master
by Peter Dimov 09 Sep '17

09 Sep '17

Trying to, f.ex., build quickbook on master fails with an error like ./boost/range/concepts.hpp: In destructor 'boost::range_detail::SinglePassIteratorConcept<Iterator>::~SinglePassIteratorConcept()': ./boost/range/concepts.hpp:167:55: error: 'iterator_traits' in namespace 'boost::detail' does not name a type That's because boost/iterator/iterator_concepts.hpp used to include boost/detail/iterator.hpp, and no longer does since this commit: https://github.com/boostorg/iterator/commit/0107df44ab3ab41c46b616c9c37c30f… This apparently works on develop, which means that it's probably fixed in Range's develop branch, but the changes aren't in master.

1 2

[build] using nvcc as toolset target?
by Oliver Kowalke 09 Sep '17

09 Sep '17

Hello, a grep over the boost.config showed some code related to nvcc - but I could not figure out how to use nvcc together with b2. What is the toolset target for nvcc ('b2 toolset=nvcc' doesn't work)? Oliver

2 2

Why is the boost documentation so bad?
by Florian Lindner 08 Sep '17

08 Sep '17

Hello, I really love to use boost libraries in my project, but I always wonder, for such an accomplished project, why is the documentation so bad? A few examples: I want to get familiar with http://www.boost.org/doc/libs/1_65_1/libs/ptr_container/. What do I need to include? Neiter the tutorial, the reference or the usage guidelines mention a #include line. This is something which stroke me quite often at various boost libs. Also with the ptr_container lib, I want to find the refrence for the ptr_vector::insert function. I got to scan the reference pages of all members of it's class hierarchy to find the insert() function (it's in ptr_sequence_adapter). References and example code often have no syntax highlightning and no linking and it's extremely hard to find documentation for a specific symbol, or from there, to jump to the source code. I would really like to have a more uniform and a documentation that not feels like a annotated source code dump. I use doxygen for my own projects and I know it can generate nicely looking, with syntax highlightning and linked documentation. Please, don't take this offensive, it's just some feedback I wanted to give a long time. Best, Florian

12 13