diff --git a/boost-card.jpg b/boost-card.jpg new file mode 100644 index 0000000..1dd3c31 Binary files /dev/null and b/boost-card.jpg differ diff --git a/boost-logo.png b/boost-logo.png new file mode 100644 index 0000000..d2eb054 Binary files /dev/null and b/boost-logo.png differ diff --git a/boost.png b/boost.png new file mode 100644 index 0000000..b4d51fc Binary files /dev/null and b/boost.png differ diff --git a/common/footer-banners.html b/common/footer-banners.html new file mode 100644 index 0000000..944905f --- /dev/null +++ b/common/footer-banners.html @@ -0,0 +1,13 @@ +--- +title: +copyright: +revised: +--- +[XHTML 1.0](https://validator.w3.org/check?uri=referer) + + +[CSS](https://jigsaw.w3.org/css-validator/check/referer) + + +[OSI + Certified](https://opensource.org/docs/definition.php) diff --git a/common/footer-license.html b/common/footer-license.html new file mode 100644 index 0000000..a51bd3e --- /dev/null +++ b/common/footer-license.html @@ -0,0 +1,6 @@ +--- +title: +copyright: +revised: +--- +Distributed under the [Boost Software License, Version 1.0](/LICENSE_1_0.txt). diff --git a/common/heading-doc.html b/common/heading-doc.html new file mode 100644 index 0000000..a59c4e2 --- /dev/null +++ b/common/heading-doc.html @@ -0,0 +1,5 @@ +--- +title: +copyright: +revised: +--- diff --git a/common/heading.html b/common/heading.html new file mode 100644 index 0000000..716f876 --- /dev/null +++ b/common/heading.html @@ -0,0 +1,16 @@ +--- +title: +copyright: +revised: +--- + + +[Boost C++ Libraries +Boost +C++ Libraries](/) +============================================= +...one of the most highly + regarded and expertly designed C++ library projects in the + world. — [Herb Sutter](http://www.gotw.ca/) and [Andrei + Alexandrescu](http://en.wikipedia.org/wiki/Andrei_Alexandrescu), [C++ + Coding Standards](http://safari.awprofessional.com/?XmlId=0321113586) diff --git a/common/menu-boost.html b/common/menu-boost.html new file mode 100644 index 0000000..347a2ed --- /dev/null +++ b/common/menu-boost.html @@ -0,0 +1,23 @@ +--- +title: +copyright: +revised: +--- #### [Introduction >](/users/index.html) + + +* [Download >](/users/download/) +* [News >](/users/news/) +* [Version History + >](/users/history/) +* [License >](/users/license.html) +* [People >](/users/people.html) +* [Memoriam >](/users/memoriam.html) +* [Bibliography + >](/users/bibliography.html) +* [Who's Using Boost + >](/users/uses.html) +* [FAQ >](/users/faq.html) +* [How Boost Started >](/users/proposal.pdf) +* [Index >](/map.html) + + diff --git a/common/menu-community.html b/common/menu-community.html new file mode 100644 index 0000000..5dcbb4e --- /dev/null +++ b/common/menu-community.html @@ -0,0 +1,42 @@ +--- +title: +copyright: +revised: +--- #### [Community >](/community/index.html) + + +* [Discussion Groups >](/community/groups.html) +* [Discussion Policy >](/community/policy.html) +* [C++ >](/community/cpp.html) + + [Committee Meetings + >](/community/committee.html) + + [Official Library Maintainer Program>](/community/official_library_maintainer_program.html) + + [Generic Progamming + Techniques >](/community/generic_programming.html) + + [Error and Exception + Handling >](/community/error_handling.html) + + [Exception-Safety in + Generic Components >](/community/exception_safety.html) + + [Counted Body Techniques + >](/community/counted_body.html) + + [Implementation Variations + >](/community/implementation_variations.html) + + [Feature Model + Diagrams >](/community/feature_model_diagrams.html) +* [Acknowledgements >](/community/acknowledgements.html) +* [Mailing Lists >](/community/groups.html) +* [Moderators >](/community/moderators.html) +* [Steering + Committee >](https://sites.google.com/a/boost.org/steering/) +* [Requesting a New Feature + >](/community/requests.html) +* [Reviews >](/community/reviews.html) + + [Schedule >](/community/review_schedule.html) +* [Sandbox >](/community/sandbox.html) +* [IRC >](/community/irc.html) +* [Google Summer of Code >](/community/gsoc.html) + + [2006 Overview + >](/community/gsoc_2006_boost_overview.html) +* [C++Now >](http://cppnow.org) + + diff --git a/common/menu-development.html b/common/menu-development.html new file mode 100644 index 0000000..dc7514e --- /dev/null +++ b/common/menu-development.html @@ -0,0 +1,45 @@ +--- +title: +copyright: +revised: +--- #### [Development >](/development/index.html) + + +* [GitHub >](https://github.com/boostorg) +* [Submissions >](/development/submissions.html) +* [Reporting and Fixing + Bugs>](/development/bugs.html) +* [Open Pull + Requests Report>](/development/pull_requests.php) +* [Testing >](/development/testing.html) + + [Master Summary + >](/development/tests/master/developer/summary.html) + + [Master Issues + >](/development/tests/master/developer/issues.html) + + [Develop + Summary >](/development/tests/develop/developer/summary.html) + + [Develop + Issues >](/development/tests/develop/developer/issues.html) + + [Running + Regression Tests >](/development/running_regression_tests.html) +* [Requirements and Guidelines + >](/development/requirements.html) + + [Test policy >](/development/test.html) + + [Header policy >](/development/header.html) + + [Separate Source + >](/development/separate_compilation.html) + + [Library Reuse >](/development/reuse.html) + + [Coding + Guidelines for Integral Constant Expressions >](/development/int_const_guidelines.html) + + [Library + Metadata >](/development/library_metadata.html) +* ### Website + + + + [Updating + >](/development/website_updating.html) + + [Exemplar >](/development/exemplar.html) + + [Design FAQ >](/development/design_faq.html) + + [Self Check >](/development/webcheck/index.html) + + diff --git a/common/menu-welcome.html b/common/menu-welcome.html new file mode 100644 index 0000000..7b5e5bb --- /dev/null +++ b/common/menu-welcome.html @@ -0,0 +1,16 @@ +--- +title: +copyright: +revised: +--- #### [Welcome >](/) + + +* [Getting Started >](/doc/libs/release/more/getting_started/index.html) +* [Download >](/users/download/) +* [Libraries >](/doc/libs/) +* [Mailing Lists >](/community/groups.html) +* [Reporting and + Fixing Bugs>](/development/bugs.html) +* [Wiki>](https://github.com/boostorg/wiki/wiki/) + + diff --git a/common/sidebar-boost.html b/common/sidebar-boost.html new file mode 100644 index 0000000..0b5d7d0 --- /dev/null +++ b/common/sidebar-boost.html @@ -0,0 +1,11 @@ +--- +title: +copyright: +revised: +--- +* +* +* +* +* + diff --git a/common/sidebar-common.html b/common/sidebar-common.html new file mode 100644 index 0000000..d7975d2 --- /dev/null +++ b/common/sidebar-common.html @@ -0,0 +1,7 @@ +--- +title: +copyright: +revised: +--- + + diff --git a/common/sidebar-community.html b/common/sidebar-community.html new file mode 100644 index 0000000..0b5d7d0 --- /dev/null +++ b/common/sidebar-community.html @@ -0,0 +1,11 @@ +--- +title: +copyright: +revised: +--- +* +* +* +* +* + diff --git a/common/sidebar-development.html b/common/sidebar-development.html new file mode 100644 index 0000000..0b5d7d0 --- /dev/null +++ b/common/sidebar-development.html @@ -0,0 +1,11 @@ +--- +title: +copyright: +revised: +--- +* +* +* +* +* + diff --git a/common/sidebar-doc.html b/common/sidebar-doc.html new file mode 100644 index 0000000..0b5d7d0 --- /dev/null +++ b/common/sidebar-doc.html @@ -0,0 +1,11 @@ +--- +title: +copyright: +revised: +--- +* +* +* +* +* + diff --git a/common/sidebar-donate.html b/common/sidebar-donate.html new file mode 100644 index 0000000..5a67a1f --- /dev/null +++ b/common/sidebar-donate.html @@ -0,0 +1,7 @@ +--- +title: +copyright: +revised: +--- +[![Donate to Boost](https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif)](/donate) + diff --git a/common/sidebar-get-boost.html b/common/sidebar-get-boost.html new file mode 100644 index 0000000..0246332 --- /dev/null +++ b/common/sidebar-get-boost.html @@ -0,0 +1,7 @@ +--- +title: +copyright: +revised: +--- +[Get Boost](/users/download/) +----------------------------- diff --git a/common/sidebar-search.html b/common/sidebar-search.html new file mode 100644 index 0000000..0a8e714 --- /dev/null +++ b/common/sidebar-search.html @@ -0,0 +1,16 @@ +--- +title: +copyright: +revised: +--- + + + (function() { + var cx = '011577717147771266991:jigzgqluebe'; + var gcse = document.createElement('script'); + gcse.type = 'text/javascript'; + gcse.async = true; + gcse.src = 'https://cse.google.com/cse.js?cx=' + cx; + var s = document.getElementsByTagName('script')[0]; + s.parentNode.insertBefore(gcse, s); + })(); diff --git a/common/sidebar-support.html b/common/sidebar-support.html new file mode 100644 index 0000000..0b5d7d0 --- /dev/null +++ b/common/sidebar-support.html @@ -0,0 +1,11 @@ +--- +title: +copyright: +revised: +--- +* +* +* +* +* + diff --git a/common/sidebar-welcome.html b/common/sidebar-welcome.html new file mode 100644 index 0000000..0b5d7d0 --- /dev/null +++ b/common/sidebar-welcome.html @@ -0,0 +1,11 @@ +--- +title: +copyright: +revised: +--- +* +* +* +* +* + diff --git a/community/_template_.html b/community/_template_.html new file mode 100644 index 0000000..3e170a2 --- /dev/null +++ b/community/_template_.html @@ -0,0 +1,24 @@ +--- +title: Boost C++ Libraries +copyright: Rene Rivera 2007. +revised: +--- + + +Boost C++ Libraries + + + +Boost C++ Libraries +=================== + +{stuff} + + + + + + + + + diff --git a/community/acknowledgements.html b/community/acknowledgements.html new file mode 100644 index 0000000..375fe52 --- /dev/null +++ b/community/acknowledgements.html @@ -0,0 +1,84 @@ +--- +title: Acknowledgements +copyright: David Abrahams 2011. +revised: 2010-05-06 07:05:24 -0400 +--- +Acknowledgements + + +/\*\*/ + + + +Acknowledgements +================ + +A list of some people and organizations who contribute to + keeping Boost running. + + +Technical Resources +------------------- +Web Hosting, Mailing Lists, and Trac Administration + +Hosting resources for the Boost mailing lists, our web + server, our [wiki + and old bug tracker](http://svn.boost.org/trac/boost), are donated by [Rackspace](https://rackspace.com/). + + +Maintenance, IT support, and general care-and-feeding of + the resources is donated by [Ciere Consulting](https://ciere.com/) +SSL Certificate + +Our wildcard SSL Certificate was generously donated by + the good folks at [Ciere Consulting](https://ciere.com/). +Rendering for producing Boost documentation in PDF + format + +Thanks to [RenderX.inc](http://www.renderx.com) for free use of their XEP + rendering program, vital for the production of the very + popular PDF versions of many Boost manuals written in + Quickbook, BoostBook, etc. + +Testing +------- + + +The compiler status tables have been prepared with resources + donated by a number of individuals, educational institutions, + and companies. Boost would like to thank them for their + support. Some of the organizations helping include: + + +* ![Borland](../gfx/borland_logo.gif) + +[Borland](http://www.borland.com/) +* ![intel](../gfx/intel_logo.gif) + +[Intel + Corporation](http://www.intel.com/software/products) +* ![Microsoft](../gfx/ms_logo.gif) + +[Microsoft](http://msdn.microsoft.com/visualc/) +* [Hewlett-Packard + Company](http://www.hp.com/) +* [Lawrence Berkeley National + Laboratory](http://www.lbl.gov) +* [Open Systems + Laboratory, Indiana University](http://www.osl.iu.edu/) +Note, however, that Boost does not endorse any product or + service, nor does Boost guarantee that some or all of its + libraries work with any of the products or services mentioned + above. + + + + + + + + + diff --git a/community/blom_libraries/boost_function.html b/community/blom_libraries/boost_function.html new file mode 100644 index 0000000..5a97c62 --- /dev/null +++ b/community/blom_libraries/boost_function.html @@ -0,0 +1,47 @@ +--- +title: Boost.Function Official Maintainer +copyright: Alex Olivas 2015. +revised: +--- + + +Boost.Function Official Maintainer + + +/\*\*/ + + + +Boost.Function Official Maintainer +================================== + +![IceCube South Pole Neutrino Observatory](logos/IceCube_horizontal2.jpg) +Boost.Function +-------------- + + +[The IceCube + Collaboration](http://www.icecube.wisc.edu/) is responsible for maintenance of the + Boost.Function library. + + +The team consists of: + + +* Alex Olivas (PoC) - U. Maryland, College Park +* David Schultz - U. Wisconsin, Madison +* David Delvethal - U. Wisconsin, Madison +* Hans Dembinski - U. Delaware +* Jakob van Santen - DESY - Zeuthen + + + + + +Revised 14 September 2015 + +©: + + diff --git a/community/blom_libraries/logos/IceCube_horizontal.jpg b/community/blom_libraries/logos/IceCube_horizontal.jpg new file mode 100644 index 0000000..476cece Binary files /dev/null and b/community/blom_libraries/logos/IceCube_horizontal.jpg differ diff --git a/community/blom_libraries/logos/IceCube_horizontal2.jpg b/community/blom_libraries/logos/IceCube_horizontal2.jpg new file mode 100644 index 0000000..5a4a2d2 Binary files /dev/null and b/community/blom_libraries/logos/IceCube_horizontal2.jpg differ diff --git a/community/blom_libraries/logos/blom_logo.png b/community/blom_libraries/logos/blom_logo.png new file mode 100644 index 0000000..833968a Binary files /dev/null and b/community/blom_libraries/logos/blom_logo.png differ diff --git a/community/committee.html b/community/committee.html new file mode 100644 index 0000000..778f987 --- /dev/null +++ b/community/committee.html @@ -0,0 +1,182 @@ +--- +title: C++ Committee Meetings +copyright: +revised: +--- + + +C++ Committee Meetings + + + body {font-family: sans-serif;} + + + +C++ Committee Meeting FAQ for Boost Members +=========================================== + + +**Who can attend C++ Committee meetings?** + Members of PL22.16 (the INCITS/ANSI committee) or of WG21 (ISO) + member country committee ("national body" in ISO-speak). + [INCITS](http://www.ncits.org/) has broadened PL22.16 + membership requirements so anyone can join, regardless of + nationality or employer. + + +Meeting attendance requirements are tighter than in earlier + times, due to changes in INCITS and ISO rules. Anyone who is an + employee of a PL22.16 member organization can attend, as can + anyone who is a member of one of the national body groups such as + the [BSI](http://en.wikipedia.org/wiki/British_Standards). + + +Any non-member who would like to visit should check with the + PL22.16 chair or head of their national delegation. The Boosters + who are active on the committee can help smooth the way. Contact + the [Boost + developer list](https://lists.boost.org/mailman/listinfo.cgi/boost) for more information. + + +**When and where is the next meeting?** There + are three meetings a year. Two are usually in North + America, and one is usually outside North + America. See a general [list of + meeting locations and dates](http://www.open-std.org/jtc1/sc22/wg21/docs/meetings). Detailed information about a + particular meeting, including hotel information, is usually + provided in a paper appearing in one of [mailings](#Mailing) for the prior meeting. If there isn't a + link to it on the [Meetings](http://www.open-std.org/jtc1/sc22/wg21/docs/meetings) + web page, you will have to go to the committee's [Papers](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/) + page and search a bit. + + +**Is there a fee for attending meetings?** No, + but there can be a lot of incidental expenses like travel, + lodging, and meals. + + +**What is the schedule?** The meetings start at + 9:00AM on Monday, and 8:30AM other days, unless otherwise + announced. It is best to arrive a half-hour early to grab a good + seat, some coffee, tea, or donuts, and to say hello to people. + + +Until the next + standard ships most meetings are running through Saturday, + although some end on Friday. The last day, the meeting is generally over + much earlier than on other days. Because the last day's formal meeting is for formal votes + only, it is primarily of interest only to actual committee + members. + + +Sometimes there are evening technical sessions; the details + aren't usually available until the Monday morning meeting. + There may be a reception one evening, and, yes, significant + others are invited. Again, details usually become available + Monday morning. + + +**What actually happens at the meetings?** + Monday morning an hour or two is spent in full committee on + administrivia, and then the committee breaks up into working + groups (Core, Library, and Enhancements). The full committee + also gets together later in the week to hear working group + progress reports. + + +The working groups are where most technical activities take + place. Each active issue that appears on an issues list is + discussed, as are papers from the mailing. Most issues are + non-controversial and disposed of in a few minutes. Technical + discussions are often led by long-term committee members, often + referring to past decisions or longstanding working group + practice. Sometimes a controversy erupts. It takes first-time + attendees awhile to understand the discussions and how + decisions are actually made. The working group chairperson + moderates. + + +Sometimes straw polls are taken. In a straw poll anyone + attending can vote, in contrast to the formal votes taken by + the full committee, where only voting members can vote. + + +Lunch break is an hour and a half. Informal subgroups often + lunch together; a lot of technical problems are discussed or + actually solved at lunch, or later at dinner. In many ways + these discussions involving only a few people are the most + interesting. Sometimes during the regular meetings, a working + group chair will break off a sub-group to tackle a difficult + problem. + + +**Do I have to stay at the main hotel?** No, + and committee members on tight budgets often stay at other, + cheaper, hotels. (The main hotels are usually chosen because + they have large meeting rooms available, and thus tend to be + pricey.) The advantage of staying at the main hotel is that it + is then easier to participate in the off-line discussions, which + can be at least as interesting as what actually happens in the + scheduled meetings. + + +**What do people wear at meetings?** Programmer + casual. No neckties to be seen. + + +**What should I bring to a meeting?** It is almost + essential to have a laptop computer along. There is a meeting wiki and + there is internet connectivity. Wireless + connectivity has become the norm. + + +**What should I do to prepare for a meeting?** + It is helpful to have downloaded the mailing or individual + papers for the meeting, and read any papers you are interested + in. Familiarize yourself with the issues lists if you haven't + done so already. Decide which of the working groups you want to + attend. + + +**What is a "Paper"?** An electronic document containing + issues, proposals, or anything else the committee is interested + in. Very little gets discussed at a meeting, much less acted + upon, unless it is presented in a paper. [Papers are + available](http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/) to anyone. Papers don't just appear randomly; + they become available four (lately six) times a year, before + and after each meeting. Committee members often refer to a + paper by saying what mailing it was in: "See the pre-Redmond + mailing." + + +**What is a "Mailing"?** A mailing is the set of papers + prepared four to six times a year before and after each + meeting, or between meetings. It is physically just a [.zip or + .gz](http://www.open-std.org/jtc1/sc22/wg21/docs/mailings/) archive of all the papers for a meeting. Although the + mailing's archive file itself is only available to committee + members and technical experts, the contents (except copies of + the standard) are available to the general public as individual + papers. The ways of ISO are inscrutable. + + +**What is a "Reflector"?** The committee's + mailing lists are called "reflectors". There are a number of + them; "all", "core", "lib", and "ext" are the main ones. As a + courtesy, Boost technical experts can be added to committee + reflectors at the request of a committee member. + + + +--- + + +© Copyright Beman Dawes, 2002, 2006, 2007, 2009, 2010 + + +Distributed under the Boost Software License, Version 1.0. See + [www.boost.org/LICENSE\_1\_0.txt](https://www.boost.org/LICENSE_1_0.txt) + + +Revised + 18 January 2010 + diff --git a/community/counted_body.html b/community/counted_body.html new file mode 100644 index 0000000..e0209c6 --- /dev/null +++ b/community/counted_body.html @@ -0,0 +1,677 @@ +--- +title: Counted Body Techniques +copyright: Kevlin Henney 1998-1999. +revised: +--- + + +Counted Body Techniques + + + +Counted Body Techniques +======================= + +[Kevlin Henney](/users/people/kevlin_henney.html) + + ([kevlin@curbralan.com](mailto:kevlin@curbralan.com)) + + +Reference counting techniques? Nothing new, you might think. + Every good C++ text that takes you to an intermediate or + advanced level will introduce the concept. It has been explored + with such thoroughness in the past that you might be forgiven + for thinking that everything that can be said has been said. + Well, let's start from first principles and see if we can + unearth something new.... + + +And then there were none... +--------------------------- + + +The principle behind reference counting is to keep a running + usage count of an object so that when it falls to zero we know + the object is unused. This is normally used to simplify the + memory management for dynamically allocated objects: keep a + count of the number of references held to that object and, on + zero, delete the object. + + +How to keep a track of the number of users of an object? + Well, normal pointers are quite dumb, and so an extra level of + indirection is required to manage the count. This is + essentially the PROXY pattern described in *Design + Patterns* [Gamma, Helm, Johnson & Vlissides, + Addison-Wesley, ISBN 0-201-63361-2]. The intent is given as +> +> *Provide a surrogate or placeholder for another object +> to control access to it.* +> +> +> + + +Coplien [*Advanced C++ Programming Styles and Idioms*, + Addison-Wesley, ISBN 0-201-56365-7] defines a set of idioms + related to this essential separation of a handle and a body + part. The *Taligent Guide to Designing Programs* + [Addison-Wesley, ISBN 0-201-40888-0] identifies a number of + specific categories for proxies (aka surrogates). Broadly + speaking they fall into two general categories: + + +* *Hidden*: The handle is the object of interest, + hiding the body itself. The functionality of the handle is + obtained by delegation to the body, and the user of the + handle is unaware of the body. Reference counted strings + offer a transparent optimisation. The body is shared between + copies of a string until such a time as a change is needed, + at which point a copy is made. Such a COPY ON WRITE pattern + (a specialization of LAZY EVALUATION) requires the use of a + hidden reference counted body. +* *Explicit*: Here the body is of interest and the + handle merely provides intelligence for its access and + housekeeping. In C++ this is often implemented as the SMART + POINTER idiom. One such application is that of reference-counted smart pointers that collaborate to keep a count of an + object, deleting it when the count falls to zero. + + +Attached vs detached +-------------------- + + +For reference counted smart pointers there are two places + the count can exist, resulting in two different patterns, both + outlined in *Software Patterns* [Coplien, SIGS, ISBN + 0-884842-50-X]: + + +* COUNTED BODY or ATTACHED COUNTED HANDLE/BODY places the + count within the object being counted. The benefits are that + countability is a part of the object being counted, and that + reference counting does not require an additional object. The + drawbacks are clearly that this is intrusive, and that the + space for the reference count is wasted when the object is + not heap-based. Therefore the reference counting ties you to + a particular implementation and style of use. +* DETACHED COUNTED HANDLE/BODY places the count outside the + object being counted, such that they are handled together. + The clear benefit of this is that this technique is + completely unintrusive, with all of the intelligence and + support apparatus in the smart pointer, and therefore can be + used on classes created independently of the reference + counted pointer. The main disadvantage is that frequent use + of this can lead to a proliferation of small objects, i.e. + the counter, being created on the heap. + + +Even with this simple analysis, it seems that the DETACHED + COUNTED HANDLE/BODY approach is ahead. Indeed, with the + increasing use of templates this is often the favourite, and is + the principle behind the common - but not standard - + `counted_ptr`. *[The Boost name is [`shared_ptr`](/doc/libs/release/libs/smart_ptr/shared_ptr.htm) + rather than `counted_ptr`.]* + + +A common implementation of COUNTED BODY is to provide the + counting mechanism in a base class that the counted type is + derived from. Either that, or the reference counting mechanism + is provided anew for each class that needs it. Both of these + approaches are unsatisfactory because they are quite closed, + coupling a class into a particular framework. Added to this the + non-cohesiveness of having the count lying dormant in a + non-counted object, and you get the feeling that excepting its + use in widespread object models such as COM and CORBA the + COUNTED BODY approach is perhaps only of use in specialized + situations. + + +A requirements based approach +----------------------------- + + +It is the question of openness that convinced me to revisit + the problems with the COUNTED BODY idiom. Yes, there is a + certain degree of intrusion expected when using this idiom, but + is there anyway to minimize this and decouple the choice of + counting mechanism from the smart pointer type used? + + +In recent years the most instructive body of code and + specification for constructing open general purpose components + has been the Stepanov and Lee's STL (Standard Template + Library), now part of the C++ standard library. The STL + approach makes extensive use of compile time polymorphism based + on well defined operational requirements for types. For + instance, each container, contained and iterator type is + defined by the operations that should be performable on an + object of that type, often with annotations describing + additional constraints. Compile time polymorphism, as its name + suggests, resolves functions at compile time based on function + name and argument usage, i.e. overloading. This is less + intrusive, although less easily diagnosed if incorrect, than + runtime polymorphism that is based on types, names and function + signatures. + + +This requirements based approach can be applied to reference + counting. The operations we need for a type to be + *Countable* are loosely: + + +* An `acquire` operation that registers interest + in a *Countable* object. +* A `release` operation unregisters interest in + a *Countable* object. +* An `acquired` query that returns whether or + not a *Countable* object is currently acquired. +* A `dispose` operation that is responsible for + disposing of an object that is no longer acquired. + + +Note that the count is deduced as a part of the abstract + state of this type, and is not mentioned or defined in any + other way. The openness of this approach derives in part from + the use of global functions, meaning that no particular member + functions are implied; a perfect way to wrap up an existing + counted body class without modifying the class itself. The + other aspect of openness comes from a more precise + specification of the operations. + + +For a type to be *Countable* it must satisfy the + following requirements, where `ptr` is a non-null + pointer to a single object (i.e. not an array) of the type, and + *`#function`* indicates number of calls to + `*function(*ptr*)*`: + +| | | | +| --- | --- | --- | +| *Expression* | *Return type* | *Semantics and notes* | +| `acquire(ptr)` | no requirement | *post*: `acquired(ptr)` | +| `release(ptr)` | no requirement | *pre*: `acquired(ptr)` +*post*: `acquired(ptr) == #acquire - + #release` | +| `acquired(ptr)` | convertible to `bool` | *return*: `#acquire > #release` | +| `dispose(ptr, ptr)` | no requirement | *pre*: `!acquired(ptr)` +*post*: `*ptr` no longer usable | + + +Note that the two arguments to `dispose` are to + support selection of the appropriate type-safe version of the + function to be called. In the general case the intent is that + the first argument determines the type to be deleted, and would + typically be templated, while the second selects which template + to use, e.g. by conforming to a specific base class. + + +In addition the following requirements must also be + satisfied, where `null` is a null pointer to the + *Countable* type: + +| | | | +| --- | --- | --- | +| *Expression* | *Return type* | *Semantics and notes* | +| `acquire(null)` | no requirement | *action*: none | +| `release(null)` | no requirement | *action*: none | +| `acquired(null)` | convertible to `bool` | *return*: `false` | +| `dispose(null, null)` | no requirement | *action*: none | + + +Note that there are no requirements on these functions in + terms of exceptions thrown or not thrown, except that if + exceptions are thrown the functions themselves should be + exception-safe. + + +Getting smart +------------- + + +Given the *Countable* requirements for a type, it is + possible to define a generic smart pointer type that uses them + for reference counting: +``` + +template +class countable\_ptr +{ +public: // construction and destruction + + explicit countable\_ptr(countable\_type \*); + countable\_ptr(const countable\_ptr &); + ~countable\_ptr(); + +public: // access + + countable\_type \*operator->() const; + countable\_type &operator\*() const; + countable\_type \*get() const; + +public: // modification + + countable\_ptr &clear(); + countable\_ptr &assign(countable\_type \*); + countable\_ptr &assign(const countable\_ptr &); + countable\_ptr &operator=(const countable\_ptr &); + +private: // representation + + countable\_type \*body; + +}; + +``` + +The interface to this class has been kept intentionally + simple, e.g. member templates and `throw` specs have + been omitted, for exposition. The majority of the functions are + quite simple in implementation, relying very much on the + `assign` member as a keystone function: +``` + +template +countable\_ptr::countable\_ptr(countable\_type \*initial) + : body(initial) +{ + acquire(body); +} + +template +countable\_ptr::countable\_ptr(const countable\_ptr &other) + : body(other.body) +{ + acquire(body); +} + +template +countable\_ptr::~countable\_ptr() +{ + clear(); +} + +template +countable\_type \*countable\_ptr::operator->() const +{ + return body; +} + +template +countable\_type &countable\_ptr::operator\*() const +{ + return \*body; +} + +template +countable\_type \*countable\_ptr::get() const +{ + return body; +} + +template +countable\_ptr &countable\_ptr::clear() +{ + return assign(0); +} + +template +countable\_ptr &countable\_ptr::assign(countable\_type \*rhs) +{ + // set to rhs (uses Copy Before Release idiom which is self assignment safe) + acquire(rhs); + countable\_type \*old\_body = body; + body = rhs; + + // tidy up + release(old\_body); + if(!acquired(old\_body)) + { + dispose(old\_body, old\_body); + } + + return \*this; +} + +template +countable\_ptr &countable\_ptr::assign(const countable\_ptr &rhs) +{ + return assign(rhs.body); +} + +template +countable\_ptr &countable\_ptr::operator=(const countable\_ptr &rhs) +{ + return assign(rhs); +} + +``` + +Public accountability +--------------------- + + +Conformance to the requirements means that a type can be + used with `countable_ptr`. Here is an implementation + mix-in class (*mix-imp*) that confers countability on its + derived classes through member functions. This class can be + used as a class adaptor: +``` + +class countability +{ +public: // manipulation + + void acquire() const; + void release() const; + size\_t acquired() const; + +protected: // construction and destruction + + countability(); + ~countability(); + +private: // representation + + mutable size\_t count; + +private: // prevention + + countability(const countability &); + countability &operator=(const countability &); + +}; + +``` + +Notice that the manipulation functions are + `const` and that the `count` member + itself is `mutable`. This is because countability is + not a part of an object's abstract state: memory management + does not depend on the `const`-ness or otherwise of + an object. I won't include the definitions of the member + functions here as you can probably guess them: increment, + decrement, and return the current count, respectively for the + manipulation functions. In a multithreaded environment, you + should ensure that such read and write operations are + atomic. + + +So how do we make this class *Countable*? A simple set + of forwarding functions does the job: +``` + +void acquire(const countability \*ptr) +{ + if(ptr) + { + ptr->acquire(); + } +} + +void release(const countability \*ptr) +{ + if(ptr) + { + ptr->release(); + } +} + +size\_t acquired(const countability \*ptr) +{ + return ptr ? ptr->acquired() : 0; +} + +template +void dispose(const countability\_derived \*ptr, const countability \*) +{ + delete ptr; +} + +``` + +Any type that now derives from `countability` may + now be used with `countable_ptr`: +``` + +class example : public countability +{ + ... +}; + +void simple() +{ + countable\_ptr ptr(new example); + countable\_ptr qtr(ptr); + ptr.clear(); // set ptr to point to null +} // allocated object deleted when qtr destructs + +``` + +Runtime mixin +------------- + + +The challenge is to apply COUNTED BODY in a non-intrusive + fashion, such that there is no overhead when an object is not + counted. What we would like to do is confer this capability on + a per object rather than on a per class basis. Effectively we + are after *Countability* on any object, i.e. anything + pointed to by a `void *`! It goes without saying + that `void` is perhaps the least committed of any + type. + + +The forces to resolve this are quite interesting, to say + the least. Interesting, but not insurmountable. Given that the + class of a runtime object cannot change dynamically in any well + defined manner, and the layout of the object must be fixed, we + have to find a new place and time to add the counting state. + The fact that this must be added only on heap creation suggests + the following solution: +``` + +struct countable\_new; +extern const countable\_new countable; + +void \*operator new(size\_t, const countable\_new &); +void operator delete(void \*, const countable\_new &); + +``` + +We have overloaded `operator new` with a dummy + argument to distinguish it from the regular global + `operator new`. This is comparable to the use of the + `std::nothrow_t` type and `std::nothrow` + object in the standard library. The placement `operator + delete` is there to perform any tidy up in the event of + failed construction. Note that this is not yet supported on all + that many compilers. + + +The result of a `new` expression using + `countable` is an object allocated on the heap that + has a header block that holds the count, i.e. we have extended + the object by prefixing it. We can provide a couple of features + in an anonymous namespace (not shown) in the implementation + file for supporting the count and its access from a raw + pointer: +``` + +struct count +{ + size\_t value; +}; + +count \*header(const void \*ptr) +{ + return const\_cast(static\_cast(ptr) - 1); +} + +``` + +An important constraint to observe here is the alignment of + `count` should be such that it is suitably aligned + for any type. For the definition shown this will be the case on + almost all platforms. However, you may need to add a padding + member for those that don't, e.g. using an anonymous + `union` to coalign `count` and the most + aligned type. Unfortunately, there is no portable way of + specifying this such that the minimum alignment is also + observed - this is a common problem when specifying your own + allocators that do not directly use the results of either + `new` or `malloc`. + + +Again, note that the count is not considered to be a part of + the logical state of the object, and hence the conversion from + `const` to non-`const` - + `count` is in effect a `mutable` + type. + + +The allocator functions themselves are fairly + straightforward: +``` + +void \*operator new(size\_t size, const countable\_new &) +{ + count \*allocated = static\_cast(::operator new(sizeof(count) + size)); + \*allocated = count(); // initialise the header + return allocated + 1; // adjust result to point to the body +} + +void operator delete(void \*ptr, const countable\_new &) +{ + ::operator delete(header(ptr)); +} + +``` + +Given a correctly allocated header, we now need the + *Countable* functions to operate on `const void + *` to complete the picture: +``` + +void acquire(const void \*ptr) +{ + if(ptr) + { + ++header(ptr)->value; + } +} + +void release(const void \*ptr) +{ + if(ptr) + { + --header(ptr)->value; + } +} + +size\_t acquired(const void \*ptr) +{ + return ptr ? header(ptr)->value : 0; +} + +template +void dispose(const countable\_type \*ptr, const void \*) +{ + ptr->~countable\_type(); + operator delete(const\_cast(ptr), countable); +} + +``` + +The most complex of these is the `dispose` + function that must ensure that the correct type is destructed + and also that the memory is collected from the correct offset. + It uses the value and type of first argument to perform this + correctly, and the second argument merely acts as a strategy + selector, i.e. the use of `const void *` + distinguishes it from the earlier dispose shown for `const + countability *`. + + +Getting smarter +--------------- + + +Now that we have a way of adding countability at creation + for objects of any type, what extra is needed to make this work + with the `countable_ptr` we defined earlier? Good + news: nothing! +``` + +class example +{ + ... +}; + +void simple() +{ + countable\_ptr ptr(new(countable) example); + countable\_ptr qtr(ptr); + ptr.clear(); // set ptr to point to null +} // allocated object deleted when qtr destructs + +``` + +The `new(countable)` expression defines a + different policy for allocation and deallocation and, in common + with other allocators, any attempt to mix your allocation + policies, e.g. call `delete` on an object allocated + with `new(countable)`, results in undefined + behaviour. This is similar to what happens when you mix + `new[]` with `delete` or + `malloc` with `delete`. The whole point + of *Countable* conformance is that *Countable* + objects are used with `countable_ptr`, and this + ensures the correct use. + + +However, accidents will happen, and inevitably you may + forget to allocate using `new(countable)` and + instead use `new`. This error and others can be + detected in most cases by extending the code shown here to add + a check member to the `count`, validating the check + on every access. A benefit of ensuring clear separation between + header and implementation source files mean that you can + introduce a checking version of this allocator without having + to recompile your code. + + +Conclusion +---------- + + +There are two key concepts that this article has + introduced: + + +* The use of a generic requirements based approach to + simplify and adapt the use of the COUNTED BODY pattern. +* The ability, through control of allocation, to + dynamically and non-intrusively add capabilities to fixed + types using the RUNTIME MIXIN pattern. + + +The application of the two together gives rise to a new + variant of the essential COUNTED BODY pattern, UNINTRUSIVE + COUNTED BODY. You can take this theme even further and contrive + a simple garbage collection system for C++. + + +The complete code for `countable_ptr`, + `countability`, and the `countable new` + is also available. +*First published in* [Overload](http://www.accu.org/index.php/overloadonline) +*25, April 1998, ISSN 1354-3172* + + + + + + + + diff --git a/community/cpp.html b/community/cpp.html new file mode 100644 index 0000000..7dc2bc5 --- /dev/null +++ b/community/cpp.html @@ -0,0 +1,90 @@ +--- +title: C++ +copyright: Beman Dawes 2002. Daniel James 2007. Rene Rivera 2007. +revised: 2007-10-22 22:55:52 +0100 +--- + + +C++ + + + +C++ +=== + +C++ Organizations +----------------- +[C++ + Standards Committee](http://www.open-std.org/jtc1/sc22/wg21/) +Issues lists and papers give insight into current status + and future directions. +[Association of C & C++ + Users](http://www.accu.org) +Over 2400 book reviews, and lots more. + +Online Publications +------------------- +[The + C++ Source](http://www.artima.com/cppsource/index.jsp) +*"The Premier Online Journal for the C++ + Community"*. + +Copies of the C++ Standard +-------------------------- +[ANSI Store](http://webstore.ansi.org/ansidocstore/product.asp?sku=INCITS%2FISO%2FIEC+14882%2D2003) +The full C++ Standard including TC1 corrections + (INCITS/ISO/IEC 14882) is available as a PDF document for $18 + US. The document is certainly not a tutorial but is + interesting to those who care about the precise specification + of both the language and the standard library. +[Book](http://www.wiley.com/WileyCDA/WileyTitle/productCd-0470846747.html) +The full C++ Standard including TC1 corrections is also + available in book form, list price $65 US. Since the content + of the book is the same as the much cheaper ANSI PDF, the + book form is only of interest to those who prefer a physical + book, say for a school or company library. + +Contributed Articles +-------------------- +[C++ Committee + Meetings](/community/committee.html) +FAQ for Boost Members wishing to attend a standards + committee meeting. +[Generic Programming + Techniques](generic_programming.html) +By [David + Abrahams](/users/people/dave_abrahams.html) and [Jeremy Siek](/users/people/jeremy_siek.html) describes + some of the techniques used in Boost libraries. +[Error and Exception + Handling](error_handling.html) +Describes approaches to errors and exceptions by [David Abrahams](/users/people/dave_abrahams.html). +[Exception-Safety in + Generic Components](exception_safety.html) +Lessons Learned from Specifying Exception-Safety for the + C++ Standard Library by [David Abrahams](/users/people/dave_abrahams.html). +[Counted Body + Techniques](/community/counted_body.html) +By [Kevlin + Henney](/users/people/kevlin_henney.html) is must reading for those interested in reference + counting, a widely used object management idiom. Originally + published in [Overload](http://www.accu.org/index.php/overloadonline) + magazine. +[Implementation + Variations](/community/implementation_variations.html) +Sometimes one size fits all, sometimes it doesn't. This + page deals with the trade-offs. +[Feature + Model Diagrams in text and HTML](/community/feature_model_diagrams.html) +Describes how to represent feature model diagrams in text + form. + + + + + + + + + + + diff --git a/community/error_handling.html b/community/error_handling.html new file mode 100644 index 0000000..5908708 --- /dev/null +++ b/community/error_handling.html @@ -0,0 +1,267 @@ +--- +title: Error and Exception Handling +copyright: David Abrahams 2001-2003. +revised: +--- + + +Error and Exception Handling + + + +Error and Exception Handling +============================ + +References +---------- + + +The following paper is a good introduction to some of the + issues of writing robust generic components: +> +> [D. Abrahams: +> ``Exception Safety in Generic Components''](/community/exception_safety.html), originally +> published in [M. Jazayeri, R. Loos, D. Musser (eds.): Generic Programming, +> Proc. of a Dagstuhl Seminar, Lecture Notes on Computer +> Science. Volume. 1766](https://doi.org/10.1007/3-540-39953-4) +> +> +> + + +Guidelines +---------- + + +### When should I use exceptions? + + +The simple answer is: ``whenever the semantic and + performance characteristics of exceptions are + appropriate.'' + + +An oft-cited guideline is to ask yourself the question ``is + this an exceptional (or unexpected) situation?'' This guideline + has an attractive ring to it but is usually a mistake. The + problem is that one person's ``exceptional'' is another's + ``expected'': when you look at the terms carefully, the + distinction evaporates and you're left with no guideline. After + all, if you check for an error condition, then in some sense + you expect it to happen, or the check is wasted code. + + +A more appropriate question to ask is: ``do we want stack + unwinding here?'' Because actually handling an exception is + likely to be significantly slower than executing mainline code, + you should also ask: ``Can I afford stack unwinding here?'' For + example, a desktop application performing a long computation + might periodically check to see whether the user had pressed a + cancel button. Throwing an exception could allow the operation + to be canceled gracefully. On the other hand, it would + probably be inappropriate to throw and *handle* exceptions + in the inner loop of this computation because that could have a + significant performance impact. The guideline mentioned above + has a grain of truth in it: in time-critical code, throwing an + exception should *be* the exception, not the rule. + + +### How should I design my exception classes? + + +1. **Derive your exception class from + `std::exception`**. Except in \*very\* rare + circumstances where you can't afford the cost of a virtual + table, `std::exception` makes a reasonable + exception base class, and when used universally, allows + programmers to catch "everything" without resorting to + `catch(...)`. For more about + `catch(...)`, see below. +2. **Use *virtual* inheritance.** This + insight is due to Andrew Koenig. Using virtual inheritance + from your exception's base class(es) prevents ambiguity + problems at the catch-site in case someone throws an + exception derived from multiple bases which have a base + class in common: + +``` + +#include +struct my\_exc1 : std::exception { char const\* what() const throw(); }; +struct my\_exc2 : std::exception { char const\* what() const throw(); }; +struct your\_exc3 : my\_exc1, my\_exc2 {}; + +int main() +{ + try { throw your\_exc3(); } + catch(std::exception const& e) {} + catch(...) { std::cout << "whoops!" << std::endl; } +} + +``` +The program above prints `"whoops"` because the C++ runtime +can't resolve which `exception` instance to match in the first +catch clause. +3. ***Don't* embed a std::string object** or + any other data member or base class whose copy constructor + could throw an exception. That could lead directly to + std::terminate() at the throw point. Similarly, it's a bad + idea to use a base or member whose ordinary constructor(s) + might throw, because, though not necessarily fatal to your + program, you may report a different exception than intended + from a *throw-expression* that includes construction + such as: + +``` + +throw some\_exception(); + +``` + +There are various ways to avoid copying string objects + when exceptions are copied, including embedding a + fixed-length buffer in the exception object, or managing + strings via reference-counting. However, consider the next + point before pursuing either of these approaches. +4. **Format the `what()` message on + demand**, if you feel you really must format the + message. Formatting an exception error message is typically a + memory-intensive operation that could potentially throw an + exception. This is an operation best delayed until after + stack unwinding has occurred, and presumably, released some + resources. It's a good idea in this case to protect your + `what()` function with a `catch(...)` + block so that you have a fallback in case the formatting code + throws +5. **Don't worry *too* much about the + `what()` message**. It's nice to have a + message that a programmer stands a chance of figuring out, + but you're very unlikely to be able to compose a relevant and + *user*-comprehensible error message at the point an + exception is thrown. Certainly, internationalization is + beyond the scope of the exception class author. [Peter Dimov](/users/people/peter_dimov.html) makes an + excellent argument that the proper use of a + `what()` string is to serve as a key into a table + of error message formatters. Now if only we could get + standardized `what()` strings for exceptions + thrown by the standard library... +6. **Expose relevant information about the cause of + the error** in your exception class' public interface. + A fixation on the `what()` message is likely to + mean that you have neglected to expose information someone might + need, in order to make it a coherent message for users. For + example, if your exception reports a numeric range error, + it's important to have the actual numbers involved available + *as numbers* in the exception class' public interface + where error reporting code can do something intelligent with + them. If you only expose a textual representation of those + numbers in the `what()` string, you will make life + very difficult for programmers who need to do something more + (e.g. subtraction) with them than dumb output. +7. **Make your exception class immune to + double-destruction** if possible. Unfortunately, + several popular compilers occasionally cause exception + objects to be destroyed twice. If you can arrange for that to + be harmless (e.g. by zeroing deleted pointers) your code will + be more robust. + + +### What About Programmer Errors? + + +As a developer, if I have violated a precondition of a + library I'm using, I don't want stack unwinding. What I want is + a core dump or the equivalent - a way to inspect the state of + the program at the exact point where the problem was detected. + That usually means `assert()` or something like + it. + + +Sometimes it is necessary to have resilient APIs which can + stand up to nearly any kind of client abuse, but there is + usually a significant cost to this approach. For example, it + usually requires that each object used by a client be tracked + so that it can be checked for validity. If you need that sort + of protection, it can usually be provided as a layer on top of + a simpler API. Beware half-measures, though. An API that + promises resilience against some, but not all abuse is an + invitation to disaster. Clients will begin to rely on the + protection and their expectations will grow to cover + unprotected parts of the interface. + + +**Note for Windows developers**: unfortunately, + the native exception-handling used by most Windows compilers + actually throws an exception when you use + `assert()`. Actually, this is true of other + programmer errors such as segmentation faults and + divide-by-zero errors. One problem with this is that if you use + JIT (Just In Time) debugging, there will be collateral + exception-unwinding before the debugger comes up because + `catch(...)` will catch these not-really-C++ + exceptions. Fortunately, there is a simple but little-known + workaround, which is to use the following incantation: +``` + +extern "C" void straight\_to\_debugger(unsigned int, EXCEPTION\_POINTERS\*) +{ + throw; +} +extern "C" void (\*old\_translator)(unsigned, EXCEPTION\_POINTERS\*) + = \_set\_se\_translator(straight\_to\_debugger); + +``` + +This technique doesn't work if the SEH is raised from within + a catch block (or a function called from within a catch block), + but it still eliminates the vast majority of JIT-masking + problems. + + +### How should I handle exceptions? + + +Often the best way to deal with exceptions is to not handle + them at all. If you can let them pass through your code and + allow destructors to handle cleanup, your code will be + cleaner. + + +#### Avoid `catch(...)` when + possible + +Unfortunately, operating systems other than + Windows also wind non-C++ "exceptions" (such as thread + cancellation) into the C++ EH machinery, and there is sometimes + no workaround corresponding to the + `_set_se_translator` hack described above. The + result is that `catch(...)` can have the effect of + making some unexpected system notification at a point where + recovery is impossible to look just like a C++ exception thrown + from a reasonable place, invalidating the usual safe + assumptions that destructors and catch blocks have taken valid + steps to ensure program invariants during unwinding. + + I reluctantly concede this point to Hillel Y. Sims, after + many long debates in the newsgroups: until all OSes are + "fixed", if every exception were derived from + `std::exception` and everyone substituted + `catch(std::exception&)` for + `catch(...)`, the world would be a better place. + + +Sometimes, `catch(...)`, is still the most + appropriate pattern, in spite of bad interactions with + OS/platform design choices. If you have no idea what kind of + exception might be thrown and you really *must* stop + unwinding it's probably still your best bet. One obvious place + where this occurs is at language boundaries. + + + + + + + + + diff --git a/community/exception_safety.html b/community/exception_safety.html new file mode 100644 index 0000000..a313ee1 --- /dev/null +++ b/community/exception_safety.html @@ -0,0 +1,764 @@ +--- +title: Exception-Safety in Generic Components +copyright: David Abrahams 2001. +revised: +--- + + +Exception-Safety in Generic Components + + +/\*\*/ + + + +Exception-Safety in Generic Components +====================================== + +**Lessons Learned from Specifying + Exception-Safety for the C++ Standard Library** + + +### [David Abrahams](http://daveabrahams.com) + + +### [dave@boostpro.com](mailto:dave@boostpro.com) + + +**Abstract.** This paper represents the + knowledge accumulated in response to a real-world need: that + the C++ Standard Template Library exhibit useful and + well-defined interactions with exceptions, the error-handling + mechanism built-in to the core C++ language. It explores the + meaning of exception-safety, reveals surprising myths about + exceptions and genericity describes valuable tools for + reasoning about program correctness, and outlines an automated + testing procedure for verifying exception-safety. + + +**Keywords:** exception-safety, exceptions, + STL, C++ + + +1 What is exception-safety? +--------------------------- + + +Informally, exception-safety in a component means that it + exhibits reasonable behavior when an exception is thrown during + its execution. For most people, the term + “reasonable” includes all the usual expectations + for error-handling: that resources should not be leaked, and + that the program should remain in a well-defined state so that + execution can continue. For most components, it also includes + the expectation that when an error is encountered, it is + reported to the caller. + + +More formally, we can describe a component as minimally + exception-safe if, when exceptions are thrown from within that + component, its invariants are intact. Later on, we'll see that + at least three different levels of exception-safety can be + usefully distinguished. These distinctions can help us to + describe and reason about the behavior of large systems. + + +In a generic component, we usually have an additional + expectation of *exception-neutrality*, which means that + exceptions thrown by a component's type parameters should be + propagated, unchanged, to the component's caller. + + +2 Myths and Superstitions +------------------------- + + +Exception-safety seems straightforward so far: it doesn't + constitute anything more than we'd expect from code using more + traditional error-handling techniques. It might be worthwhile, + however, to examine the term from a psychological viewpoint. + Nobody ever spoke of “error-safety” before C++ had + exceptions. + + +It's almost as though exceptions are viewed as a + *mysterious attack* on otherwise correct code, from which + we must protect ourselves. Needless to say, this doesn't lead + to a healthy relationship with error handling! During + standardization, a democratic process that requires broad + support for changes, I encountered many widely-held + superstitions. To even begin the discussion of + exception-safety in generic components, it may be worthwhile + confronting a few of them. + + +*“Interactions between templates and exceptions are + not well-understood.”* This myth, often heard from + those who consider these both new language features, is easily + disposed of: there simply are no interactions. A template, once + instantiated, works in all respects like an ordinary class or + function. A simple way to reason about the behavior of a + template with exceptions is to think of how a specific + instantiation of that template works. Finally, the genericity + of templates should not cause special concern. Although the + component's client supplies part of the operation (which may, + unless otherwise specified, throw arbitrary exceptions), the + same is true of operations using familiar virtual functions or + simple function pointers. + + +*“ It is well known to be impossible to write an + exception-safe generic container.”* This claim is + often heard concerning an article by Tom Cargill + [[4]](#reference4 "Tom Cargill, “Exception Handling: A False Sense of Security”, C++ Report, Nov-Dec 1994") in which he explores the + problem of exception-safety for a generic stack template. In + his article, Cargill raises many useful questions, but + unfortunately fails to present a solution to his + problem.[1](#footnote1 "Probably the greatest impediment to a solution in Cargill's case was an unfortunate combination of choices on his part: the interface he chose for his container was incompatible with his particular demands for safety. By changing either one he might have solved the problem.") He concludes by suggesting + that a solution may not be possible. Unfortunately, his article + was read by many as “proof” of that speculation. + Since it was published there have been many examples of + exception-safe generic components, among them the C++ standard + library containers. + + +*“Dealing with exceptions will slow code down, and + templates are used specifically to get the best possible + performance.”* A good implementation of C++ will not + devote a single instruction cycle to dealing with exceptions + until one is thrown, and then it can be handled at a speed + comparable with that of calling a function [[7]](#reference7 "Bjarne Stroustrup, The Design And Evolution of C++. Addison Wesley, Reading, MA, 1995, ISBN 0-201-54330-3, Section 16.9.1."). That alone gives + programs using exceptions performance equivalent to that of a + program which ignores the possibility of errors. Using + exceptions can result in faster programs than + “traditional” error handling methods for other + reasons. First, a catch block indicates to the compiler + which code is devoted to error-handling; it can then be + separated from the usual execution path, improving locality of + reference. Second, code using “traditional” error + handling must typically test a return value for errors after + every single function call; using exceptions completely + eliminates that overhead. + + +*“Exceptions make it more difficult to reason about + a program's behavior.”* Usually cited in support of + this myth is the way “hidden” execution paths are + followed during stack-unwinding. Hidden execution paths are + nothing new to any C++ programmer who expects local variables + to be destroyed upon returning from a function: +``` + +ErrorCode f( int& result ) // 1 +{ // 2 + X x; // 3 + ErrorCode err = x.g( result ); // 4 + if ( err != kNoError ) // 5 + return err; // 6 + // ...More code here... + return kNoError; // 7 +} + +``` + +In the example above, there is a “hidden” call + to `X::~X()` in lines 6 and 7. Granted, using + exceptions, there is no code devoted to error handling + visible: +``` + +int f() // 1 +{ // 2 + X x; // 3 + int result = x.g(); // 4 + // ...More code here... + return result; // 5 +} + +``` + +For many programmers more familiar with exceptions, the + second example is actually more readable and understandable + than the first. The “hidden” code paths include the + same calls to destructors of local variables. Also, they + follow a simple pattern which acts *exactly* as though + there was a potential return statement after each function + call in case of an exception. Readability is enhanced because + the normal path of execution is unobscured by error-handling, + and return values are freed up to be used naturally. + + +There is an even more important way in which exceptions can + enhance correctness: by allowing simple class invariants. In + the first example, if `x`'s constructor should need + to allocate resources, it has no way to report a failure: in + C++, constructors have no return values. The usual result when + exceptions are avoided is that classes requiring resources must + include a separate initializer function which finishes the job + of construction. The programmer can therefore never be sure, + when an object of class `X` is used, whether he is + handling a full-fledged `X` or some abortive attempt + to construct one (or worse: someone simply forgot to call the + initializer!) + + +3 A contractual basis for exception-safety +------------------------------------------ + + +A non-generic component can be described as exception-safe + in isolation, but because of its configurability by client + code, exception-safety in a generic component usually depends + on a contract between the component and its clients. For + example, the designer of a generic component might require that + an operation that is used in the component's destructor not + throw any exceptions.[2](#footnote2 " It is usually inadvisable to throw an exception from a destructor in C++, since the destructor may itself be called during the stack-unwinding caused by another exception. If the second exception is allowed to propagate beyond the destructor, the program is immediately terminated.") The generic component might, + in return, provide one of the following guarantees: + + +* The *basic* guarantee: that the invariants of the + component are preserved, and no resources are leaked. +* The *strong* guarantee: that the operation has + either completed successfully or thrown an exception, leaving + the program state exactly as it was before the operation + started. +* The *no-throw* guarantee: that the operation will + not throw an exception. + + +The basic guarantee is a simple minimum standard for + exception-safety to which we can hold all components. It says + simply that after an exception, the component can still be used + as before. Importantly, the preservation of invariants allows + the component to be destroyed, potentially as part of + stack-unwinding. This guarantee is actually less useful than it + might at first appear. If a component has many valid states, + after an exception we have no idea what state the component is + in; only that the state is valid. The options for recovery, in + this case, are limited: either destruction or resetting the + component to some known state before further use. Consider the + following example: +``` + +template +void print\_random\_sequence() +{ + std::vector v(10); // A vector of 10 items + try { + // Provides only the *basic* guarantee + v.insert( v.begin(), X() ); + } + catch(...) {} // ignore any exceptions above + // print the vector's contents + std::cout "(" << v.size() << ") "; + std::copy( v.begin(), v.end(), + std::ostream\_iterator( std::cout, " " ) ); +} + +``` + +Since all we know about v after an exception is that it is + valid, the function is allowed to print any random sequence of + `X`s.[3](#footnote3 "In practice, of course, this function would make an extremely poor random sequence generator!") It is “safe” in + the sense that it is not allowed to crash, but its output may + be unpredictable. + + +The *strong* guarantee provides full + “commit-or-rollback” semantics. In the case of C++ + standard containers, this means, for example, that if an + exception is thrown all iterators remain valid. We also know + that the container has the same elements as before the + exception was thrown. A transaction that has no effects if it + fails has obvious benefits: the program state is simple and + predictable in case of an exception. In the C++ standard + library, nearly all of the operations on the node-based + containers list, set, multiset, map, and multimap provide the + *strong* guarantee.[4](#footnote4 "It is worth noting that mutating algorithms usually cannot provide the strong guarantee: to roll back a modified element of a range, it must be set back to its previous value using operator=, which itself might throw. In the C++ standard library, there are a few exceptions to this rule, whose rollback behavior consists only of destruction: uninitialized_copy, uninitialized_fill, and uninitialized_fill_n.")). + + +The *no-throw* guarantee is the strongest of all, and + it says that an operation is guaranteed not to throw an + exception: it always completes successfully. This guarantee is + necessary for most destructors, and indeed the destructors of + C++ standard library components are all guaranteed not to throw + exceptions. The *no-throw* guarantee turns out to be + important for other reasons, as we shall see.[5](#footnote5 "All type parameters supplied by clients of the C++ standard library are required not to throw from their destructors. In return, all components of the C++ standard library provide at least the basic guarantee.") + + +4 Legal Wrangling +----------------- + + +Inevitably, the contract can get more complicated: a quid + pro quo arrangement is possible. Some components in the C++ + Standard Library give one guarantee for arbitrary type + parameters, but give a stronger guarantee in exchange for + additional promises from the client type that no exceptions + will be thrown. For example, the standard container operation + `vector::erase` gives the *basic* + guarantee for any `T`, but for types whose copy + constructor and copy assignment operator does not throw, it gives + the *no-throw* guarantee.[6](#footnote6 "Similar arrangements might have been made in the C++ standard for many of the mutating algorithms, but were never considered due to time constraints on the standardization process.") + + +5 What level of exception-safety should a component + specify? +------------------------------------------------------------- + + +From a client's point-of-view, the strongest possible level + of safety would be ideal. Of course, the *no-throw* + guarantee is simply impossible for many operations, but what + about the *strong* guarantee? For example, suppose we + wanted atomic behavior for + `vector::insert`. Insertion into the middle + of a vector requires copying elements after the insertion point + into later positions, to make room for the new element. If + copying an element can fail, rolling back the operation would + require “undoing” the previous copies...which + depends on copying again. If copying back should fail (as it + likely would), we have failed to meet our guarantee. + + +One possible alternative would be to redefine + `insert` to build the new array contents in a fresh + piece of memory each time, and only destroy the old contents + when that has succeeded. Unfortunately, there is a non-trivial + cost if this approach is followed: insertions near the end of a + vector which might have previously caused only a few copies + would now cause every element to be copied. The *basic* + guarantee is a “natural” level of safety for this + operation, which it can provide without violating its + performance guarantees. In fact all of the operations in the + library appears to have such a “natural” level of + safety. + + +Because performance requirements were already a + well-established part of the draft standard and because + performance is a primary goal of the STL, there was no attempt + to specify more safety than could be provided within those + requirements. Although not all of the library gives the + *strong* guarantee, almost any operation on a standard + container which gives the *basic* guarantee can be made + *strong* using the “make a new copy” strategy + described above: +``` + +template +void MakeOperationStrong( Container& c, const BasicOp& op ) +{ + Container tmp(c); // Copy c + op(tmp); // Work on the copy + c.swap(tmp); // Cannot fail[7](#footnote7 "Associative containers whose Compare object might throw an exception when copied cannot use this technique, since the swap function might fail.") +} + +``` + +This technique can be folded into a wrapper class to make a + similar container which provides stronger guarantees (and + different performance characteristics).[8](#footnote8 "This suggests another potential use for the oft-wished-for but as yet unseen container traits<> template: automated container selection to meet exceptionsafety constraints.") + + +6 Should we take everything we can get? +--------------------------------------- + + +By considering a particular implementation, we can hope to + discern a natural level of safety. The danger in using this to + establish requirements for a component is that the + implementation might be restricted. If someone should come up + with a more-efficient implementation which we'd like to use, we + may find that it's incompatible with our exception-safety + requirements. One might expect this to be of no concern in the + well-explored domains of data structures and algorithms covered + by the STL, but even there, advances are being made. A good + example is the recent *introsort* algorithm [[6]](#reference6 "D. R. Musser, “ Introspective Sorting and Selection Algorithms” Software-Practice and Experience 27(8):983-993, 1997."), which represents a + substantial improvement in worst-case complexity over the + well-established *quicksort*. + + +To determine exactly how much to demand of the standard + components, I looked at a typical real-world scenario. The + chosen test case was a “ composite container.” Such + a container, built of two or more standard container + components, is not only commonly needed, but serves as a simple + representative case for maintaining invariants in larger + systems: +``` + +// SearchableStack - A stack which can be efficiently searched +// for any value. +template +class SearchableStack +{ + public: + void push(const T& t); // O(log n) + void pop(); // O(log n) + bool contains(const T& t) const; // O(log n) + const T& top() const; // O(1) + private: + std::set set\_impl; + std::list::iterator> list\_impl; +}; + +``` + +The idea is that the list acts as a stack of set iterators: + every element goes into the set first, and the resulting + position is pushed onto the list. The invariant is + straightforward: the set and the list should always have the + same number of elements, and every element of the set should be + referenced by an element of the list. The following + implementation of the push function is designed to give the + *strong* guarantee within the natural levels of safety + provided by set and list: +``` + +template // 1 +void SearchableStack::push(const T& t) // 2 +{ // 3 + set::iterator i = set\_impl.insert(t); // 4 + try // 5 + { // 6 + list\_impl.push\_back(i); // 7 + } // 8 + catch(...) // 9 + { // 10 + set\_impl.erase(i); // 11 + throw; // 12 + } // 13 +} // 14 + +``` + +What does our code require of the library? We need + to examine the lines where non-const operations occur: + + +* Line 4: if the insertion fails but `set_impl` + is modified in the process, our invariant is violated. We + need to be able to rely on the *strong* guarantee from + `set::insert`. +* Line 7: likewise, if `push_back` fails, but + `list_impl` is modified in the process, our + invariant is violated, so we need to be able to rely on the + *strong* guarantee from list::insert. +* Line 11: here we are “rolling back” the + insertion on line 4. If this operation should fail, we will + be unable to restore our invariant. We absolutely depend on + the *no-throw* guarantee from + `set::erase`.[9](#footnote9 "One might be tempted to surround the erase operation with a try/catch block to reduce the requirements on set< T> and the problems that arise in case of an exception, but in the end that just begs the question. First, erase just failed and in this case there are no viable alternative ways to produce the necessary result. Second and more generally, because of the variability of its type parameters a generic component can seldom be assured that any alternatives will succeed.") +* Line 11: for the same reasons, we also depend on being + able to pass the `i` to the `erase` + function: we need the *no-throw* guarantee from the copy + constructor of `set::iterator`. + + +I learned a great deal by approaching the question this way + during standardization. First, the guarantee specified for the + composite container depends on stronger guarantees + from its components (the *no-throw* guarantees in line + 11). Also, I took advantage of all of the natural levels of + safety to implement this simple example. Finally, the analysis + revealed a requirement on iterators which I had previously + overlooked when operations were considered on their own. The + conclusion was that we should provide as much of the natural + level of safety as possible. Faster but less-safe + implementations could always be provided as extensions to the + standard components. [10](#footnote10 "The prevalent philosophy in the design of STL was that functionality that wasn't essential to all uses should be left out in favor of efficiency, as long as that functionality could be obtained when needed by adapting the base components. This departs from that philosophy, but it would be difficult or impossible to obtain even the basic guarantee by adapting a base component that doesn't already have it.") + + +7 Automated testing for exception-safety +---------------------------------------- + + +As part of the standardization process, I produced an + exception-safe reference implementation of the STL. + Error-handling code is seldom rigorously tested in real life, + in part because it is difficult to cause error conditions to + occur. It is very common to see error-handling code that + crashes the first time it is executed ...in a shipping product! + To bolster confidence that the implementation worked + as advertised, I designed an automated test suite, based on an + exhaustive technique due to my colleague Matt Arnold. + + +The test program started with the basics: reinforcement and + instrumentation, especially of the global operators + `new` and `delete`.[11](#footnote11 "An excellent discussion on how to fortify memory subsystems can be found in: Steve Maguire, Writing Solid Code, Microsoft Press, Redmond, WA, 1993, ISBN 1-55615- 551-4.")Instances of the components + (containers and algorithms) were created, with type parameters + chosen to reveal as many potential problems as possible. For + example, all type parameters were given a pointer to + heap-allocated memory, so that leaking a contained object would + be detected as a memory leak. + + +Finally, a scheme was designed that could cause an operation + to throw an exception at each possible point of failure. At the + beginning of every client-supplied operation which is allowed + to throw an exception, a call to `ThisCanThrow` was + added. A call to `ThisCanThrow` also had to be added + everywhere that the generic operation being tested might throw + an exception, for example in the global operator + `new`, for which an instrumented replacement was + supplied. +``` + +// Use this as a type parameter, e.g. vector +struct TestClass +{ + TestClass( int v = 0 ) + : p( ThisCanThrow(), new int( v ) ) {} + TestClass( const TestClass& rhs ) + : p( ThisCanThrow(), new int( \*rhs.p ) ) {} + const TestClass& operator=( const TestClass& rhs ) + { ThisCanThrow(); \*p = \*rhs.p; } + bool operator==( const TestClass& rhs ) const + { ThisCanThrow(); return \*p == \*rhs.p; } + ...etc... + ~TestClass() { delete p; } +}; + +``` + +`ThisCanThrow` simply decrements a “throw + counter” and, if it has reached zero, throws an + exception. Each test takes a form which begins the counter at + successively higher values in an outer loop and repeatedly + attempts to complete the operation being tested. The result is + that the operation throws an exception at each successive step + along its execution path that can possibly fail. For example, + here is a simplified version of the function used to test the + *strong* guarantee: [12](#footnote12 "Note that this technique requires that the operation being tested be exception-neutral. If the operation ever tries to recover from an exception and proceed, the throw counter will be negative, and subsequent operations that might fail will not be tested for exception-safety.") +``` + +extern int gThrowCounter; // The throw counter +void ThisCanThrow() +{ + if (gThrowCounter-- == 0) + throw 0; +} + +template +void StrongCheck(const Value& v, const Operation& op) +{ + bool succeeded = false; + for (long nextThrowCount = 0; !succeeded; ++nextThrowCount) + { + Value duplicate = v; + try + { + gThrowCounter = nextThrowCount; + op( duplicate ); // Try the operation + succeeded = true; + } + catch(...) // Catch all exceptions + { + bool unchanged = duplicate == v; // Test *strong* guarantee + assert( unchanged ); + } + // Specialize as desired for each container type, to check + // integrity. For example, size() == distance(begin(),end()) + CheckInvariant(v); // Check any invariant + } +} + +``` + +Notably, this kind of testing is much easier and less + intrusive with a generic component than with non-generics, + because testing-specific type parameters can be used without + modifying the source code of the component being tested. Also, + generic functions like `StrongCheck` above were + instrumental in performing the tests on a wide range of values + and operations. + + +8 Further Reading +----------------- + + +To my knowledge, there are currently only two descriptions + of STL exception-safety available. The original specification + [[2]](#reference2 "D. Abrahams, Exception Safety in STLport") for the reference + exception-safe implementation of the STL is an informal + specification, simple and self-explanatory (also verbose), and + uses the *basic-* and *strong-*guarantee distinctions + outlined in this article. It explicitly forbids leaks, and + differs substantively from the final C++ standard in the + guarantees it makes, though they are largely identical. I hope + to produce an updated version of this document soon. + + +The description of exception-safety in the C++ Standard + [[1]](#reference1 "International Standard ISO/IEC 14882, Information Technology-Programming Languages-C++, Document Number ISO/IEC 14882-1998") is only slightly more + formal, but relies on hard-to-read “standardese” + and an occasionally subtle web of implication.[13](#footnote13 "The changes to the draft standard which introduced exception-safety were made late in the process, when amendments were likely to be rejected solely based on the number of altered words. Unfortunately, the result compromises clarity somewhat in favor of brevity. Greg Colvin was responsible for the clever language-lawyering needed to minimize the extent of these changes.") In particular, leaks are + not treated directly at all. It does have the advantage that it + *is* the standard. + + +The original reference implementation [[5]](#reference5 "B. Fomitchev, Adapted SGI STL Version 1.0, with exception handling code by D. Abrahams") of the exception-safe STL + is an adaptation of an old version of the SGI STL, designed for + C++ compilers with limited features. Although it is not a + complete STL implementation, the code may be easier to read, + and it illustrates a useful base-class technique for + eliminating exception-handling code in constructors. The full + test suite [[3]](#reference3 "D. Abrahams and B. Fomitchev, Exception Handling Test Suite") used to validate the + reference implementation has been used successfully to validate + all recent versions of the SGI STL, and has been adapted to + test one other vendor's implementation (which failed). As noted + on the documentation page, it also seems to have the power to + reveal hidden compiler bugs, particularly where optimizers + interact with exception-handling code. + + +References +---------- + + +1. International + Standard ISO/IEC 14882, *Information Technology-Programming + Languages-C++*, Document Number ISO/IEC 14882-1998, + available from . +2. D. Abrahams, + *Exception Safety in STLport*, available at . +3. D. Abrahams and + B. Fomitchev, *Exception Handling Test Suite*, available + at . +4. Tom Cargill, + “Exception Handling: A False Sense of Security,” + C++ Report, Nov-Dec 1994, also available at [http://www.awprofessional.com/content/images/020163371x/supplements/Exception\_Handling\_Article.html](http://www.informit.com/content/images/020163371x/supplements/Exception_Handling_Article.html). +5. B. Fomitchev, + *Adapted SGI STL Version 1.0*, with exception handling + code by D. Abrahams, available at . +6. D. R. Musser, + “Introspective Sorting and Selection Algorithms,” + *Software-Practice and Experience* 27(8):983-993, + 1997. +7. Bjarne + Stroustrup, *The Design And Evolution of C++*. Addison + Wesley, Reading, MA, 1995, ISBN 0-201-54330-3, Section + 16.9.1. + + +Footnotes +--------- + + +1 Probably the + greatest impediment to a solution in Cargill's case was an + unfortunate combination of choices on his part: the interface + he chose for his container was incompatible with his particular + demands for safety. By changing either one he might have solved + the problem. + + +2 It is usually + inadvisable to throw an exception from a destructor in C++, + since the destructor may itself be called during the + stack-unwinding caused by another exception. If the second + exception is allowed to propagate beyond the destructor, the + program is immediately terminated. + + +3 In practice of + course, this function would make an extremely poor random + sequence generator! + + +4 It is worth noting + that mutating algorithms usually cannot provide the + *strong* guarantee: to roll back a modified element of a + range, it must be set back to its previous value using + `operator=`, which itself might throw. In the C++ + standard library, there are a few exceptions to this rule, + whose rollback behavior consists only of destruction: + `uninitialized_copy`, + `uninitialized_fill`, and + `uninitialized_fill_n`. + + +5 All type parameters + supplied by clients of the C++ standard library are required + not to throw from their destructors. In return, all components + of the C++ standard library provide at least the *basic* + guarantee. + + +6 Similar + arrangements might have been made in the C++ standard for many + of the mutating algorithms, but were never considered due to + time constraints on the standardization process. + + +7 Associative + containers whose `Compare` object might throw an + exception when copied cannot use this technique, since the swap + function might fail. + + +8 This suggests + another potential use for the oft-wished-for but as yet unseen + `container_traits<>` template: automated + container selection to meet exception-safety constraints. + + +9 One might be + tempted to surround the erase operation with a + `try`/`catch` block to reduce the + requirements on `set` and the problems that + arise in case of an exception, but in the end that just begs + the question. First, erase just failed and in this case there + are no viable alternative ways to produce the necessary result. + Second and more generally, because of the variability of its + type parameters a generic component can seldom be assured that + any alternatives will succeed. + + +10 The prevalent + philosophy in the design of STL was that functionality that + wasn't essential to all uses should be left out in favor of + efficiency, as long as that functionality could be obtained + when needed by adapting the base components. This departs from + that philosophy, but it would be difficult or impossible to + obtain even the *basic* guarantee by adapting a base + component that doesn't already have it. + + +11 An excellent + discussion on how to fortify memory subsystems can be found in: + Steve Maguire, Writing Solid Code, Microsoft Press, Redmond, + WA, 1993, ISBN 1-55615- 551-4. + + +12 Note that this + technique requires that the operation being tested be + exception-neutral. If the operation ever tries to recover from + an exception and proceed, the throw counter will be negative, + and subsequent operations that might fail will not be tested + for exception-safety. + + +13 The changes to + the draft standard which introduced exception-safety were made + late in the process, when amendments were likely to be rejected + solely based on the number of altered words. + Unfortunately, the result compromises clarity somewhat in favor + of brevity. Greg Colvin was responsible for the clever + language-lawyering needed to minimize the extent of these + changes. + + + + + + + + + diff --git a/community/feature_model_diagrams.html b/community/feature_model_diagrams.html new file mode 100644 index 0000000..fc30636 --- /dev/null +++ b/community/feature_model_diagrams.html @@ -0,0 +1,169 @@ +--- +title: Feature Model Diagrams in text and HTML +copyright: Beman Dawes 2000. +revised: +--- + + +Feature Model Diagrams in text and HTML + + + +Feature Model Diagrams in text and HTML +======================================= + + +By [Beman + Dawes](/users/people/beman_dawes.html) + +Introduction +------------ + + +In their seminal book, Generative Programming, Czarnecki and + Eisenecker ([C&E](#GenerativeProgramming))) + describe how to build feature models [C&E 4.4] consisting + of a feature diagram plus semantic, rationale, and other + attributes. Feature models are then used to drive design cycles + which eventually lead to manual or automatic assembly of + configurations. + + +Feature models provide a language to describe the library + variability that is often such an issue in boost.org + discussions. The Whorf hypothesis that "Language shapes the way + we think, and determines what we can think about" seems to + apply. In discussion of library variability issues, we have + been crippled by lack of a good language. With feature models, + we now have a language to carry on the dialog. + + +The graphical feature diagrams presented by C&E are not + in a suitable form for the email discussions boost.org depends + upon. The hierarchical nature of feature diagrams can be + represented by a simple text-based feature diagram language. A + feature model can also take advantage of the hyperlinks + inherent in HTML. + + +Grammar +------- + + +The grammar for the feature diagram language is expressed in + Extended Bakus-Naur Form;::= represents productions, [...] + represents options, {...} represents zero or more instances, + and represents | alternatives. +``` + +feature-model ::= concept-name details { feature } + +feature ::= feature-name [details] + +details ::= "(" feature-list ")" // required features + | "[" feature-list "]" // optional features + +feature-list ::= element { "|" element } // one only + | element { "+" element } // one or more + | element { "," element } // all + // [a+b] equivalent to [a,b] + +element ::= feature + | details +concept-name ::= name + +feature-name ::= name + +``` + +The usual lexical conventions apply. Names are + case-insensitive and consist of a leading letter, followed by + letters, digits, underscores or hyphens, with no spaces + allowed. + + +At least one instance of each name should be hyperlinked to + the corresponding [Feature + Description](#FeatureDescriptions). + + +While the grammar is intended for written communication + between people, it may also be trivially machine parsed for use + by automatic tools. +Descriptive information is associated with each concept or + feature. According to [C&E 4.4.2] this includes: + + +* Semantic descriptions. +* Rationale. +* Stakeholders and client programs. +* Exemplar systems. +* Constraints and default dependency rules. +* Availability sites, binding sites, and binding mode. +* Open/Closed attribute. + + +What is a Feature? +------------------ + + +A feature [C&E 4.9.1] is "anything users or client + programs might want to control about a concept. Thus, during + feature modeling, we document no only functional features ... + but also implementation features, ..., various optimizations, + alternative implementation techniques, and so on." + + +Example +------- +``` + +special-container ( organization, + performance, + interface ) // all required + +organization [ ordered + indexed ] // zero or more (4 configurations) + +indexed [ hash-function ] // zero or one (2 configurations) + +performance ( fast | small | balanced ) // exactly one (3 configurations) + +interface ( STL-style + cursor-style ) // one or more (3 configurations) + +``` + +There should be feature descriptions for + `some-container, organization, ordered, indexed, + hash-function, performance, fast, small, balanced, interface, + STL-style, and cursor-style`. + + +The number of possible configurations is (2 + 2\*2) \* 3 \* 3 = + 54, assuming no constraints. + + +There are equivalent representations. For example: +``` + +special-container ( organization[ ordered+indexed[ hash-function ]], + performance( fast|small|balanced ), + interface( STL-style+cursor-style ) ) + +``` + +References +---------- + + +Krzysztof Czarnecki and Ulrich W. + Eisenecker, [Generative + Programming](http://www.generative-programming.org), Addison-Wesley, 2000, ISBN 0-201-30977-7 + + + + + + + + + diff --git a/community/generic_programming.html b/community/generic_programming.html new file mode 100644 index 0000000..fd418de --- /dev/null +++ b/community/generic_programming.html @@ -0,0 +1,469 @@ +--- +title: Generic Programming Techniques +copyright: David Abrahams 2001. +revised: +--- + + +Generic Programming Techniques + + +/\*\*/ + + + +Generic Programming Techniques +============================== + +This is an incomplete survey of some of the generic + programming techniques used in the [boost](/) + libraries. + + +Table of Contents +----------------- + + +* [Introduction](#introduction) +* [The Anatomy of a Concept](#concept) +* [Traits](#traits) +* [Tag Dispatching](#tag_dispatching) +* [Adaptors](#adaptors) +* [Type Generators](#type_generator) +* [Object Generators](#object_generator) +* [Policy Classes](#policy) + + +Introduction +------------ + + +Generic programming is about generalizing software + components so that they can be easily reused in a wide variety + of situations. In C++, class and function templates are + particularly effective mechanisms for generic programming + because they make the generalization possible without + sacrificing efficiency. + + +As a simple example of generic programming, we will look at + how one might generalize the `memcpy()` function of + the C standard library. An implementation of + `memcpy()` might look like the following: +``` + +void\* memcpy(void\* region1, const void\* region2, size\_t n) +{ + const char\* first = (const char\*)region2; + const char\* last = ((const char\*)region2) + n; + char\* result = (char\*)region1; + while (first != last) + \*result++ = \*first++; + return result; +} + +``` + +The `memcpy()` function is already generalized to + some extent by the use of `void*` so that the + function can be used to copy arrays of different kinds of data. + But what if the data we would like to copy is not in an array? + Perhaps it is in a linked list. Can we generalize the notion of + copy to any sequence of elements? Looking at the body of + `memcpy()`, the function's **minimal requirements** are that it needs to + *traverse* through the sequence using some sort of + pointer, *access* elements pointed to, *write* the + elements to the destination, and *compare* pointers to + know when to stop. The C++ standard library groups requirements + such as these into **concepts**, in + this case the [Input + Iterator](http://en.cppreference.com/w/cpp/concept/InputIterator) concept (for `region2`) and the [Output + Iterator](http://en.cppreference.com/w/cpp/concept/OutputIterator) concept (for `region1`). + + +If we rewrite the `memcpy()` as a function + template, and use the [Input + Iterator](http://en.cppreference.com/w/cpp/concept/InputIterator) and [Output + Iterator](http://en.cppreference.com/w/cpp/concept/OutputIterator) concepts to describe the requirements on the + template parameters, we can implement a highly reusable + `copy()` function in the following way: +``` + +template +OutputIterator +copy(InputIterator first, InputIterator last, OutputIterator result) +{ + while (first != last) + \*result++ = \*first++; + return result; +} + +``` + +Using the generic `copy()` function, we can now + copy elements from any kind of sequence, including a linked + list that exports iterators such as `std::[list](http://en.cppreference.com/w/cpp/container/list)`. +``` + +#include +#include +#include + +int main() +{ + const int N = 3; + std::vector region1(N); + std::list region2; + + region2.push\_back(1); + region2.push\_back(0); + region2.push\_back(3); + + std::copy(region2.begin(), region2.end(), region1.begin()); + + for (int i = 0; i < N; ++i) + std::cout << region1[i] << " "; + std::cout << std::endl; +} + +``` + +Anatomy of a + Concept +--------------------- + + +A **concept** is a set of + requirements consisting of valid expressions, associated types, + invariants, and complexity guarantees. A type that satisfies + the requirements is said to **model** + the concept. A concept can extend the requirements of another + concept, which is called **refinement**. + + +* **Valid Expressions** are + C++ expressions which must compile successfully for the + objects involved in the expression to be considered + *models* of the concept. +* **Associated Types** are + types that are related to the modeling type in that they + participate in one or more of the valid expressions. + Typically associated types can be accessed either through + typedefs nested within a class definition for the modeling + type, or they are accessed through a [traits + class](#traits). +* **Invariants** are run-time characteristics + of the objects that must always be true, that is, the + functions involving the objects must preserve these + characteristics. The invariants often take the form of + pre-conditions and post-conditions. +* **Complexity Guarantees** are maximum limits + on how long the execution of one of the valid expressions + will take, or how much of various resources its computation + will use. + + +The concepts used in the C++ Standard Library are documented + at the [C++ reference + website](http://en.cppreference.com/w/). + + +Traits +------ + + +A traits class provides a way of associating information + with a compile-time entity (a type, integral constant, or + address). For example, the class template [`std::iterator_traits`](http://en.cppreference.com/w/cpp/iterator/iterator_traits) + looks something like this: +``` + +template +struct iterator\_traits { + typedef ... iterator\_category; + typedef ... value\_type; + typedef ... difference\_type; + typedef ... pointer; + typedef ... reference; +}; + +``` + +The traits' `value_type` gives generic code the + type which the iterator is "pointing at", while the + `iterator_category` can be used to select more + efficient algorithms depending on the iterator's + capabilities. + + +A key feature of traits templates is that they're + *non-intrusive*: they allow us to associate information + with arbitrary types, including built-in types and types + defined in third-party libraries, Normally, traits are + specified for a particular type by (partially) specializing the + traits template. + + +For an in-depth description of + `std::iterator_traits`, see [this + page](http://en.cppreference.com/w/cpp/iterator/iterator_traits). Another very different expression of the traits idiom + in the standard is `std::numeric_limits` + which provides constants describing the range and capabilities + of numeric types. + + +Tag + Dispatching +---------------- + + +Tag dispatching is a way of using function overloading to + dispatch based on properties of a type, and is often used hand + in hand with traits classes. A good example of this synergy is + the implementation of the [`std::advance()`](http://en.cppreference.com/w/cpp/iterator/advance) function in the C++ Standard + Library, which increments an iterator `n` times. + Depending on the kind of iterator, there are different + optimizations that can be applied in the implementation. If the + iterator is [random + access](http://en.cppreference.com/w/cpp/concept/RandomAccessIterator) (can jump forward and backward arbitrary distances), + then the `advance()` function can simply be + implemented with `i += n`, and is very efficient: + constant time. Other iterators must be `advance`d in + steps, making the operation linear in n. If the iterator is + [bidirectional](http://en.cppreference.com/w/cpp/concept/BidirectionalIterator), then it makes sense for `n` to be + negative, so we must decide whether to increment or decrement + the iterator. + + +The relation between tag dispatching and traits classes is + that the property used for dispatching (in this case the + `iterator_category`) is often accessed through a + traits class. The main `advance()` function uses the + [`iterator_traits`](http://en.cppreference.com/w/cpp/iterator/iterator_traits) class to get the + `iterator_category`. It then makes a call the the + overloaded `advance_dispatch()` function. The + appropriate `advance_dispatch()` is selected by the + compiler based on whatever type the `iterator_category` resolves to, either [`input_iterator_tag`](http://en.cppreference.com/w/cpp/iterator/iterator_tags), [`bidirectional_iterator_tag`](http://en.cppreference.com/w/cpp/iterator/iterator_tags), or [`random_access_iterator_tag`](http://en.cppreference.com/w/cpp/iterator/iterator_tags). A **tag** is simply a class whose only purpose is to + convey some property for use in tag dispatching and similar + techniques. Refer to [this + page](http://en.cppreference.com/w/cpp/iterator/iterator_tags) for a more detailed description of iterator tags. +``` + +namespace std { + struct input\_iterator\_tag { }; + struct bidirectional\_iterator\_tag { }; + struct random\_access\_iterator\_tag { }; + + namespace detail { + template + void advance\_dispatch(InputIterator& i, Distance n, **input\_iterator\_tag**) { + while (n--) ++i; + } + + template + void advance\_dispatch(BidirectionalIterator& i, Distance n, + **bidirectional\_iterator\_tag**) { + if (n >= 0) + while (n--) ++i; + else + while (n++) --i; + } + + template + void advance\_dispatch(RandomAccessIterator& i, Distance n, + **random\_access\_iterator\_tag**) { + i += n; + } + } + + template + void advance(InputIterator& i, Distance n) { + typename **iterator\_traits::iterator\_category** category; + detail::advance\_dispatch(i, n, **category**); + } +} + +``` + +Adaptors +-------- + + +An *adaptor* is a class template which builds on + another type or types to provide a new interface or behavioral + variant. Examples of standard adaptors are [std::reverse\_iterator](http://en.cppreference.com/w/cpp/iterator/reverse_iterator), + which adapts an iterator type by reversing its motion upon + increment/decrement, and [std::stack](http://en.cppreference.com/w/cpp/container/stack) , which adapts a container to provide a simple stack + interface. + + +A more comprehensive review of the adaptors in the standard + can be found [here](http://portal.acm.org/citation.cfm?id=249118.249120). + + +Type + Generators +---------------- + + +**Note:** The *type generator* concept has + largely been superseded by the more refined notion of a + [metafunction](/doc/libs/release/libs/mpl/doc/refmanual/metafunction.html). + See *[C++ + Template Metaprogramming](http://www.boost-consulting.com/mplbook/)* for an in-depth discussion of + metafunctions. + + +A *type generator* is a template whose only purpose is + to synthesize a new type or types based on its template + argument(s)[[1]](#footnote1). The generated type is + usually expressed as a nested typedef named, appropriately + `type`. A type generator is usually used to + consolidate a complicated type expression into a simple one. + This example uses an old version of [`iterator_adaptor`](/doc/libs/release/libs/iterator/doc/iterator_adaptor.html) whose design didn't allow derived + iterator types. As a result, every adapted iterator had to be a + specialization of `iterator_adaptor` itself and + generators were a convenient way to produce those types. +``` + +template +struct filter\_iterator\_generator { + typedef iterator\_adaptor< + + Iterator,filter\_iterator\_policies, + Value,Reference,Pointer,Category,Distance> **type**; +}; + +``` + +Now, that's complicated, but producing an adapted filter + iterator using the generator is much easier. You can usually + just write: +``` + +boost::filter\_iterator\_generator::type + +``` + +Object + Generators +------------------ + + +An *object generator* is a function template whose only + purpose is to construct a new object out of its arguments. + Think of it as a kind of generic constructor. An object + generator may be more useful than a plain constructor when the + exact type to be generated is difficult or impossible to + express and the result of the generator can be passed directly + to a function rather than stored in a variable. Most Boost + object generators are named with the prefix + "`make_`", after `std::[make\_pair](http://en.cppreference.com/w/cpp/utility/pair/make_pair)(const T&, const U&)`. + + +For example, given: +``` + +struct widget { + void tweak(int); +}; +std::vector widget\_ptrs; + +``` + +By chaining two standard object generators, + `std::[bind2nd](http://en.cppreference.com/w/cpp/utility/functional/bind12)()` + and `std::[mem\_fun](http://en.cppreference.com/w/cpp/utility/functional/mem_fun)()`, + we can easily tweak all widgets: +``` + +void tweak\_all\_widgets1(int arg) +{ + for\_each(widget\_ptrs.begin(), widget\_ptrs.end(), + **bind2nd**(std::**mem\_fun**(&widget::tweak), arg)); +} + +``` + +Without using object generators the example above would look + like this: +``` + +void tweak\_all\_widgets2(int arg) +{ + for\_each(struct\_ptrs.begin(), struct\_ptrs.end(), + **std::binder2nd >**( + std::**mem\_fun1\_t**(&widget::tweak), arg)); +} + +``` + +As expressions get more complicated the need to reduce the + verbosity of type specification gets more compelling. + + +Policy Classes +-------------- + + +A policy class is a template parameter used to transmit + behavior. An example from the standard library is + `std::[allocator](http://en.cppreference.com/w/cpp/memory/allocator)`, + which supplies memory management behaviors to standard [containers](http://en.cppreference.com/w/cpp/container). + + +Policy classes have been explored in detail by [Andrei Alexandrescu](http://www.moderncppdesign.com/) in + [this + chapter](http://www.informit.com/articles/article.aspx?p=167842) of his book, *Modern C++ Design*. He + writes: +> +> In brief, policy-based class design fosters assembling a +> class with complex behavior out of many little classes +> (called policies), each of which takes care of only one +> behavioral or structural aspect. As the name suggests, a +> policy establishes an interface pertaining to a specific +> issue. You can implement policies in various ways as long as +> you respect the policy interface. +> +> +> Because you can mix and match policies, you can achieve a +> combinatorial set of behaviors by using a small core of +> elementary components. +> +> +> + + +Andrei's description of policy classes suggests that their + power is derived from granularity and orthogonality. + Less-granular policy interfaces have been shown to work well in + practice, though. [This paper](http://svn.boost.org/svn/boost/tags/release/Boost_1_30_2/boost/libs/utility/iterator_adaptors.pdf) describes an old version of [`iterator_adaptor`](/doc/libs/release/libs/iterator/doc/iterator_adaptor.html) that used non-orthogonal policies. + There is also precedent in the standard library: [`std::char_traits`](http://en.cppreference.com/w/cpp/string/char_traits), despite its name, acts as a + policies class that determines the behaviors of [std::basic\_string](http://en.cppreference.com/w/cpp/string/basic_string). + + +Notes +----- + + +[1] Type generators + are sometimes viewed as a workaround for the lack of + “templated typedefs” in C++. + + + + + + + + + diff --git a/community/groups.html b/community/groups.html new file mode 100644 index 0000000..24239f7 --- /dev/null +++ b/community/groups.html @@ -0,0 +1,280 @@ +--- +title: Boost Mailing Lists +copyright: Beman Dawes, David Abrahams, 2001-2005. +revised: +--- + + +Boost Mailing Lists + + + +Boost Mailing Lists (A.K.A. Discussion Groups) +============================================== + +The mailing lists are the heart of the Boost community. You + may read the lists via full-content email or email digests. +Before Posting +-------------- + + +**Read the [Discussion Policy + and Guide to Effective Posting](policy.html).** Doing so will + help you to ensure that your post is read by the people who + can help you and received in the spirit in which it was + intended. + + +**Subscribe your posting address.** As an + anti-spam measure, postings to most Boost mailing lists will + only be accepted if the posting's "From:" header contains an + email address that is subscribed to the list. If you try to + post from an address that isn't subscribed, you will probably + get a message that says: +> +> You are not allowed to post to this mailing list, +> and your message has been automatically rejected. If you +> think that your messages are being rejected in error, +> contact the mailing list owner at *list +> administrator's email address*. +> +> +> + + +If you need to post from multiple email addresses, you + should subscribe to each one separately. You can configure your + subscription settings for any address to disable mail + delivery via each mailing list's web interface. +* [Users](#users) +* [Developers](#main) + + [Archives](#archive) +* [Announce](#announce) +* [Interest](#interest) +* [Project-Specific](#projects) + + [Boost.Build](#jamboost) + + [Boost CMake](#cmake) + + [Python C++-Sig (for + Boost.Python)](#cplussig) + + [Language Binding](#langbinding) + + [Boost.MPI Development](#mpi) + + [Boost.Spirit](#spirit) + + [Boost.Documentation](#boostdocs) + + [Testing](#testing) + + [Boost.uBlas (numerics)](#ublas) + + [Boost.Thread](#thread) + + [Translation Groups](#translation) +* [#boost IRC channel](#IRC) + + +Boost Users mailing list +------------------------ + + +This list is oriented toward casual users of the Boost + libraries. It is a good place to start if you are having + trouble getting started with Boost or its individual libraries. + Feel free to post both "newbie" and more challenging questions, + but please check first to see if there's an appropriate + [Project-Specific](#projects) list; you'll often get + better answers in a forum dedicated to your problem area. This + list is relatively low volume (less than 500 per month). + Subscribe or unsubscribe at the [Boost Users list home page](https://lists.boost.org/mailman/listinfo.cgi/boost-users). + + +Boost developers mailing list +----------------------------- + + +This is the main Boost mailing list. It is high volume (over + 1000 messages per month), very technical, and oriented toward + Boost library developers. It is also read by many other members + interested in watching the Boost library development process. + Virtually all Boost decisions, major or minor, technical or + otherwise, are reached via public discussion on this mailing + list. It is where the formal reviews of proposed libraries take + place. Subscribe or unsubscribe at . + + +When we talk about the "members of Boost", we are talking + about those signed up for this main mailing list. + + +### Archives for Boost + developers list + + +Archives of Boost messages include the [MailMan Archive](https://lists.boost.org/Archives/boost/) on [our home + page](/). + + +Boost Announce mailing + list +---------------------------- + + +This is an announce-only list for notification of upcoming + software releases and formal reviews of proposed libraries. One + to three messages per month.  Subscribe or unsubscribe at + the [Boost Announce list home page](https://lists.boost.org/mailman/listinfo.cgi/boost-announce). + + +Boost Interest Mailing + List +---------------------------- + + +This list is a moderated low-traffic announcement-only list + of interest to the Boost community. On-topic messages will + include announcements of books, magazine articles, papers, + talks, seminars, products, tools, events, or conferences on + advanced uses of C++, generic/generative/meta-programming, and, + of course, the Boost libraries. Off-topic will be discussion of + any kind. Job postings are accepted at the moderators' + discretion. Subscribe or unsubscribe at the [Boost-Interest home page](https://lists.boost.org/mailman/listinfo.cgi/boost-interest). + + +Project-Specific + lists +----------------------- + +Several mailing lists have been established for + specific Boost projects: + + ### Boost.Build list + + +The mailing list for the [Boost + Build System](../build/) is located [here](https://lists.boost.org/mailman/listinfo.cgi/boost-build). + + +### Boost CMake list + + +Development of the experimental [CMake build + system](http://svn.boost.org/trac/boost/wiki/CMake) is being coordinated on the [Boost + CMake mailing list](https://lists.boost.org/mailman/listinfo.cgi/boost-cmake). Any questions about CMake should be + asked here and not on the main Boost.Build list. + + +### Python C++-Sig (for + Boost.Python) + + +The [Python C++-sig](http://www.python.org/community/sigs/current/c++-sig/) is not strictly Boost-specific, + but nearly all the traffic concerns [Boost.Python](/doc/libs/release/libs/python). See also the + [Language Binding](#langbinding) list below. You can + join the [mailing list](http://mail.python.org/mailman/listinfo/cplusplus-sig "Python C++-sig mailing list"). There are + also searchable archives at [ASPN](http://aspn.activestate.com/ASPN/Mail/Browse/Threaded/cpp-sig). + + +### Language + Binding + + +The [Language Binding](http://lists.sourceforge.net/lists/listinfo/boost-langbinding) list is for discussion of + a generalized framework for binding C++ to other languages and + systems based on the technology of [Boost.Python](/doc/libs/release/libs/python) and [Luabind](http://luabind.sourceforge.net/). + The plan is to provide a single front-end for describing + bindings with runtime-pluggable back ends for binding to + specific languages. + + +### Boost.MPI Development + + +A separate developer mailing list for [Boost.MPI](/doc/libs/release/libs/mpi/) specific topics is + located [here](https://lists.boost.org/mailman/listinfo.cgi/boost-mpi). + + +### Boost.Spirit lists + + +Spirit has two additional mailing lists. [Spirit-general](https://lists.sourceforge.net/lists/listinfo/spirit-general) for Spirit users and + [Spirit-devel](https://lists.sourceforge.net/lists/listinfo/spirit-devel) for Spirit developers (open + to anyone who wishes to hang out with Spirit coders). + + +### Boost.Documentation + list + + +The mailing list for the [Boost Documentation + System](/doc/libs/release/doc/html/boostbook.html) is located [here](https://lists.boost.org/mailman/listinfo.cgi/boost-docs). + + +### uBLAS development + (ublas-dev) list + + +A separate user and developer mailing list for [Boost + uBLAS](/doc/libs/release/libs/numeric/ublas/doc/) specific topics is located [here](https://lists.boost.org/). + + +### Thread development + (threads-devel) list + + +A separate developer mailing list for [Boost Thread](/doc/libs/release/libs/thread/doc/index.html) + specific topics is located [here](https://lists.boost.org/mailman/listinfo.cgi/threads-devel). + + +**Important:** This mailing list is for the + discussion of the specification and implementation of + Boost.Threads only — questions regarding + usage should be directed to the [Boost + Users](#users) list, or the main [Boost + developers](#main) list. + + +### Testing list + + +The setup, procedures and tools necessary for running Boost + regression tests are discussed on [this list](https://lists.boost.org/mailman/listinfo.cgi/boost-testing). The list's main participants are + regression runners - people who run Boost tests on a variety of + compilers and platforms, and the maintainers of tools for + collecting and processing test results. + + +**Important:** questions relevant to a wider audience, + including questions about Boost.Test framework or test results + for a particular library, should be posted to main development + list. + + +### Translation + Groups + + +Boost doesn't have the resources to translate the + documentation itself, but there is at least one separate group + translating the documentation. If you have formed another, tell + us on the [documentation list](#boostdocs) and we'll + add a link. + + +* [Chinese + translators group](http://groups.google.com/group/boost_doc_translation) ([main + webpage](http://code.google.com/p/boost-doc-zh/)) + + +#boost IRC channel +------------------ + + +In addition to the mailing lists presented above, a #boost + IRC channel on [freenode](http://freenode.net) is + frequented by Boost developers and users. As usual with IRC + channels, one should not necessarily expect that his questions + will be answered right away. The channel is not strictly + moderated. + + + + + + + + + diff --git a/community/gsoc.html b/community/gsoc.html new file mode 100644 index 0000000..43a5bb2 --- /dev/null +++ b/community/gsoc.html @@ -0,0 +1,161 @@ +--- +title: Boost C++ Libraries +copyright: David Bellot 2020, Rene Rivera 2007. +revised: +--- + + +Boost C++ Libraries + + + +Boost C++ Libraries +=================== + +Since 2005, Boost has participated in the Google [Summer of Code™](https://summerofcode.withgoogle.com/), + initiative, a program in which student developers are sponsored + for their contributions within open source organizations that are + willing to mentor the participants. + + +Currently the application process begins around + March/April by the student + [reviewing past GSoC + project ideas](#HistoricalGSoCIdeaspagesforyears2006tonow) and approaching the [Boost + developers mailing list](https://www.boost.org/community/groups.html#main) to find a mentor willing to mentor + them and codevelop a project proposal to be submitted to Google + for funding the upcoming summer. Students are expected to be + flexible with regard to what topics and proposals mentors are + willing to mentor. + + +If you arrive at the process too late to prearrange a mentor, + some potential mentors supply prewritten project proposals with + C++ programming competency tests on [this year's GSoC Project Ideas page](https://github.com/boostorg/wiki/wiki/Google-Summer-of-Code%3A-Overview). If you have in the past + made a **substantial** contribution to a well known open source project or participated in previous editions of the GSoC, it may be + possible to skip submission of the C++ programming competency test solution (decided on a case by case basis). + + +Submit the competency test solution as part of the project proposal + you will submit to the Google Summer of Code program. You can copy and + paste relevant parts of your code or you can include links to, for example, + GitHub repository with your solution project. + + + +### Google Summer of Code 2020 overview +This year, in 2020, 10 students will work with us on improving and adding new features to many of our libraries. + +Once again, the competition has been very hard. A few numbers: +- we received 93 proposals in total. 85 of them were complete, then we kept 47 proposals only +- finally we selected 10 of them, covering 7 different Boost libraries +- and countless hours of work from the most incredible team of mentors! + +Here is the list of projects for 2020: + +#### Boost.Real + + +* Kishan Shukla will be working on making the Real library ready for revision. His main goal is to reimplement the division algorithm so it can be used with any number base representation and the Karatsuba multiplication algorithm. Also, it will be working on implementing some operators and common irrational numbers as Pi. + *Mentors*: Laouen Belloli and Damian Vicino. + + +#### Boost.Astronomy + + +* Syed Ali Hasan will be working on the astronomical coordinate system, he will implement different coordinate conversion using SOFA library + *Mentor*: Pranam Lashkari +* Gopi Krishna Menon will be completing the parser for FITS file and also optimise the already developed components. + *Mentor*: Sarthak Singhal + + +#### Boost.GIL + + +* Debabrata Mandal will be implementing histogram computation as a built-in feature, algorithms for histogram analysis, + image processing algorithms based on histogram and possibly integration with Boost.Histogram library. + *Mentors*: Mateusz Loskot, Pranam Lashkari +* Olzhas Zhumabek will be extending GIL's portfolio of image processing algorithms, implementing for image scaling and + sampling, Perona–Malik diffusion, Non-Maximum Suppression for object detection, Hysteresis threshold and some more. + *Mentor*: Mateusz Loskot + + +**Boost.Multiprecision** + + +* Dimitris Los will work on extending and optimizing parts of Boost.Multiprecision to higher precision of many thousands of bits or more. + *Mentor*: Christopher Kormanyos + + +#### Boost.uBlas + + +* Ashar Khan will stabilize and improve Boost.uBlas using the C++20-Standard. The main focus of his project will be enhancing code-coverage and documentation, + integrating static code analysis and generating tensor concepts. + *Mentor*: Cem Bassoy +* Tom Kwok will improve and finalize the implementation of data frames in uBlas, with the aim of delivering production-ready by the end of the summer. + Data frames in uBlas are similar in functionalities to other implementations like in R, Python.Pandas or Julia. + *Mentor*: David Bellot + + +#### Boost.Geometry + + +* Tinko Bartels will work on robust yet efficient geometric predicates for Boost Geometry. + *Mentor*: Vissarion Fisikopoulos + + +#### Boost.Real + + +* Vikram Singh Chundawat will work in taking Real to revision ready state. His focus will be in improving the internal representation datatypes + and providing functions required to conveniently support Taylor series. + *Mentors*: Damian Vicino and Laouen Belloli + + +### Github's for standalone GSoCs past and present +Since 2013 with Boost's transition to git we have kept a single umbrella org on github for those GSoCs which are fairly self standing. Incremental extensions to existing libraries usually enter that library's main git repo as an experimental branch. Here are those orgs: +* GSoC 2020: +* GSoC 2019: +* GSoC 2018: +* GSoC 2017: +* GSoC 2015: +* GSoC 2014: +* GSoC 2013: + + +Students may find examining past GSoC source code and commit histories of use. +### Historical GSoC Ideas pages for years 2006 to now + + +* 2020 [Project Ideas](https://github.com/boostorg/wiki/wiki/Google-Summer-of-Code:-2020) +* 2019 [Project Ideas](https://github.com/boostorg/wiki/wiki/Google-Summer-of-Code:-2019) +* 2018 [Project Ideas](https://github.com/boostorg/wiki/wiki/Google-Summer-of-Code:-2018) +* 2017 [Project Ideas](https://svn.boost.org/trac/boost/wiki/SoC2017) +* 2016 [Project Ideas](https://svn.boost.org/trac/boost/wiki/SoC2016) +* 2015 [Project Ideas](https://svn.boost.org/trac/boost/wiki/SoC2015) +* 2014 [Project Ideas](https://svn.boost.org/trac/boost/wiki/SoC2014) +* 2013 [Project Ideas](https://svn.boost.org/trac/boost/wiki/SoC2013) +* 2012 [Project Ideas](https://svn.boost.org/trac/boost/wiki/SoC2012) +* 2011 [Project Ideas](https://svn.boost.org/trac/boost/wiki/SoC2011) +* 2010 [Project Ideas](https://svn.boost.org/trac/boost/wiki/SoC2010) +* 2009 [Project Ideas](https://svn.boost.org/trac/boost/wiki/soc2009) +* 2008 [Project Ideas](http://www.crystalclearsoftware.com/cgi-bin/boost_wiki/wiki.pl?Google_Summer_Of_Code_2008) +* 2007 [Project Ideas](http://www.crystalclearsoftware.com/cgi-bin/boost_wiki/wiki.pl?Google_Summer_Of_Code_2007) +* 2006 [Project Ideas](http://www.crystalclearsoftware.com/cgi-bin/boost_wiki/wiki.pl?Google_Summer_Of_Code_2006). +[An overview of Boost participation in Google Summer of Code™ 2006](https://www.boost.org/community/gsoc_2006_boost_overview.html). + + +### Sponsorships + + +* [IMC Financial Markets, 2016](imc_summer_of_code_2016.html) + + + + +Revised $Date: 2020-05-12$ + + + + diff --git a/community/gsoc_2006_boost_overview.html b/community/gsoc_2006_boost_overview.html new file mode 100644 index 0000000..33d70a7 --- /dev/null +++ b/community/gsoc_2006_boost_overview.html @@ -0,0 +1,823 @@ +--- +title: An overview of Boost participation in Google Summer of Code™ 2006 +copyright: +revised: 2007-10-22 22:55:52 +0100 +--- + + +An overview of Boost participation in Google Summer of Code™ + 2006 + + +/\*\*/ + + + +An overview of Boost participation in Google Summer of + Code™ 2006 +================================================================== + +For the second consecutive year, Google has conducted its + [Summer of Code™](http://code.google.com/soc/) + initiative, a program by which student developers are sponsored + for their contributions within open source organizations + willing to mentor the participants. The 2006 campaign has run + between April and September, with active development work + taking place between May 23 and August 21. + + +Around mid April, when the program had just started, some + Boost members began considering the possibility to enter Summer + of Code as a mentoring organization. Despite the lack of time + and the fact that most of us were completely new to this + initiative, Boost managed to successfully apply for the + program. As a result ten projects were selected and mentored, + most of which are expected to become full contributions to + Boost shortly. + + +We give here a summary report of this experience, along with + a short analysis of the main problems we found, so that we can + work at solving them and do better next year. + + +Contents +-------- + + +* [How the program works](#how_the_program_works) + + [2006 figures](#figures_2006) +* [Boost participation](#boost_participation) + + [Application and + process selection](#application_and_process_selection) + + [Accepted + projects](#accepted_projects) + + [Development](#development) + + [Results](#results) +* [Analysis](#analysis) + + [Boost appeal](#boost_appeal) + + [Opportunities + lost?](#opportunities_lost) + + [Projects startup](#projects_startup) + + [Ongoing + development](#ongoing_development) + + [Public + communication issues](#public_communication_issues) + + [Scope of + projects](#scope_of_projects) +* [Suggestions for + improvement](#suggestions_for_improvement) + + [Preparation](#preparation) + + [Public + communication](#public_communication) + + [Project + management](#project_management) +* [Conclusions](#conclusions) +* [Acknowledgements](#acknowledgements) + + +How the program works +--------------------- + + +There are three types of participants in Google Summer of + Code: + + +* Google itself acts as the funding partner and conducts + the overall program. +* The open-source organizations accepted into the program + must designate people inside the organization who will act as + project mentors. +* Students submit their project ideas and, if selected, + work in collaboration with one of the mentoring + organizations; upon successful completion of the project, + students receive the full stipend for the program. + + +The program goes through the following stages: + + +* Organization selection: those open source organizations + willing to enter Summer of Code submit an expression of + interest to Google, along with information Google uses for + qualifying purposes. Selected organizations are publicly + announced and each organization is expected to provide a pool + of project ideas. +* Student selection: students willing to participate submit + one or more project proposals, typically expanding on some of + the ideas previously provided by the mentoring organizations. + A student can apply several times and for different + organizations, but ultimately can only be chosen for just one + project. These proposals are routed by Google to the + appropriate organizations, which must analyze them, rank + them, and assign mentors to the most promising applications. + Based on the information provided by mentoring organizations, + Google issues the final list of accepted projects. +* Development: Students, guided by their assigned mentors, + are expected to complete the projects during a period of three + months. Google asks mentors for a mid-program review upon + which continuation of the project depends. +* Final review: Once the development period is over, + mentors are requested to inform Google of the results of the + project, and determine whether students qualify to receive + the full stipend. + + +### 2006 + figures + + +The 2006 campaign of Google Summer of Code took place + between April 14 and September 25. A total of 102 mentoring + organizations participated. Of the 6,338 applications submitted + by 3,044 students around the globe, 630 were finally selected + and funded. Google has spent more than US$3 million in student + stipends and compensations to the mentoring organizations. + + +Boost participation +------------------- + + +### Application and process + selection + + +On April 14, the same day Google Summer of Code started, + Julio M. Merino Vidal (later to become one of the selected + students) sent a message encouraging Boost members to + participate in this program as a mentoring organization. This + call sparked the interest of the community; although time was + already short for doing all the preparation labors, Boost + moderators put rapidly themselves to work and conducted the + preliminary registration steps. In the meantime, a Wiki page + was grown with project ideas provided by Boost members, + totaling more than twenty proposals. + + +By the beginning of May Boost was officially accepted into + the program and Boost moderators set out to form a group of + mentors, selected on an invitation basis. As student selection + is a delicate process, involving the assessment of individuals + on their technical skills, all subsequent discussions were + conducted by the selected mentors on a private mail list + established for their collaboration. + + +We were not prepared for the avalanche of student + applications that followed. On day two after the application + period was open, we had received three proposals; the next day it + was 14, and within a week the count exceeded 50. By the end of + the application period the total number of proposals received + was 174, which forced us to go through a very intensive ranking + process and recruit additional mentors. Two rules were followed + so as rationalize the process of selection among dozens of + different proposals: + + +* Where there were competing applications for the same + project idea, only one were to be ultimately selected; so, no + two projects with the same or very similar goals were + accepted. +* Some of the applications built on a given Boost library + (for instance, the Boost Graph Library is a frequent target + for the addition of algorithms.) We limited the applications + to a maximum of two per Boost library. + + +These rules have the combined effect of greatly reducing the + number of eligible applications while at the same time + distributing the accepted projects evenly across the space of + ideas. Moreover, students with unique proposals, i.e. project + ideas not coming from the pool originally presented by Boost, + are at a competitive advantage. + + +The different proposals were classified according to their + related technological area so that each cluster could be + handled by an appointed mentor with the required expertise on + the subject. Mentors submitted then "focus reports" summarizing + the applications under their responsibility; these reports + served as a first filter to help reduce the number of final + applications to be evaluated jointly. Along the process, + students with the most promising proposals were asked to refine + their ideas and provide further information. + + +Although not enforced by the official rules, we agreed upon + a one-to-one ratio of mentors to students, which ultimately + marked a hard limit on the maximum number of eligible + projects. + + +### Accepted projects + + +Google accepted and funded the ten top-ranked projects + endorsed by Boost. Of these, eight projects are libraries or + library components targeted for future inclusion into Boost, + while the remaining two consist of utility programs heavily + relying on Boost. +> +> **C++ Coroutine Library** +> +> Giovanni Piero Deretta, mentored by Eric Niebler. +> +> Library for the management through a modern C++ interface of +> OS-provided coroutine facilities. +> +> +> +> +> **Concurrency Library** +> +> Matthew Calabrese, mentored by David Abrahams. +> +> STL-inspired generic framework for high-level specification +> and execution of parallelizable algorithms. +> +> +> +> +> **TR1 Math Special Functions** +> +> Xiaogang Zhang, mentored by John Maddock. +> +> Implementation of the 23 special mathematical functions +> specified in C++ standard library extension proposal TR1. +> +> +> +> +> **The Boost.Process library** +> +> Julio M. Merino Vidal, mentored by Jeff Garland. +> +> Portable library for process launching and basic +> management. +> +> +> +> +> **Out-of-Core Graphs and Graph +> Algorithms** +> +> Stéphane Zampelli, mentored by Jeremy Siek. +> +> Extension of the Boost Graph Library to deal with out-of-core +> structures, i.e. data sets too large to be kept in main +> memory at once. +> +> +> +> +> **MISC (M)ulti (I)ndex (S)pecialized +> (C)ontainers** +> +> Matías Capeletto, mentored by Joaquín M +> López Muñoz. +> +> Families of specialized containers internally based on +> Boost.MultiIndex. +> +> +> +> +> **Generic Tree Container** +> +> Bernhard Reiter, mentored by René Rivera. +> +> Design and implementation of a family of STL-compatible tree +> containers. +> +> +> +> +> **Viewer utility for FSMs** +> +> Ioana Tibuleac, mentored by Andreas Huber Dönni. +> +> Utility program for the visualization of finite state +> machines (FSMs) specified with Boost.Statechart. +> +> +> +> +> **Modular C++ preprocessor, using +> Boost.Spirit** +> +> Hermanpreet 'Lally' Singh, mentored by Joel de Guzman. +> +> Implementation with Boost.Spirit and Boost.Wave of a +> front-end translator from Modular C++ (as specified in a +> proposal to add modules to C++ by Daveed Vandevoorde) to +> standard C++. +> +> +> +> +> **Implementing a state of the art Mincut/Maxflow +> algorithm.** +> +> Stephan Diederich, mentored by Douglas Gregor. +> +> Implementation of a fast mincut/maxflow routine for the Boost +> Graph Library based on a new algorithm devised by Vladimir +> Kolmogorov. +> +> +> + + +### Development + + +Two main facilities were set up to assist students and + mentors during the development phase: a mailing list and a + Trac/SVN project management system with separate directories + for each project. One of the students, Matí as Capeletto, + out of personal initiative registered a Google Group aimed at + giving students with Boost a place for informal interaction and + discussion of common problems. + + +After the initial warm-up period, each student-mentor pair + performed development work mostly privately. The usage of the + Boost mailing lists was scarce, and only by the end of the + program did some students publicly announced their results. + + +### Results + + +By the date the development period was officially closed, + the status of the different projects was as follows: + + +* Seven projects were completed or nearly completed and the + students are expected to ask for a formal review within 2006 + or early 2007. Four of these projects necessitated a goal + reorientation during development, basically because the + original plan was too ambitious for three months. Most of the + projects are still in active development during the months + following the Summer of Code program. +* Two projects did not reach the planned goals, but + nevertheless produced useful material that could be expanded + outside of the Summer of Code program. +* One project was abandoned shortly after the midterm + review. The reasons for the abandonment are unknown. + + +The results of all the projects can be consulted online at + the dedicated [Trac + site](http://svn.boost.org/trac/boost/browser/sandbox/SOC/2006). + + +Analysis +-------- + + +We examine the various stages of Boost participation in + Summer of Code, with an emphasis on discovering opportunities + for improvement. + + +### Boost + appeal + + +In a mid project [presentation + at OSCON 2006](http://code.google.com/soc/GSoC2006Statistics.pdf), Chris DiBona from Google provided some data + about the organizations which received the most + applications: + +| Organization | No of applications | +| --- | --- | +| KDE | 244 | +| Ubuntu & Bazaar | 236 | +| Python Software Foundation | 212 | +| GNOME | 199 | +| Apache Software Foundation | 190 | +| **Boost** | **174** | +| Gaim | 152 | +| The GNU Project | 148 | +| Drupal | 146 | +> +> The numbers shown here have been estimated from a chart +> included in the presentation slides. This chart contains an +> additional column labeled "Google" which actually accounts +> for the applications dismissed because of their low +> quality. +> +> +> + + +The fact that Boost is ranked the sixth most attractive + organization out of a total of 102 was entirely unexpected, + especially considering the wide popularity of the rest of + top-rated organizations. There is a more or less implicit + consensus among Boost members that ours is a relatively niche + project, known for its quality standards by seasoned C++ + practitioners, but with a limited penetration among entry level + programmers: maybe the figures above should make us reconsider + this assumption. A cursory examination of the applications + submitted to Boost reveals that most applicants were regular + users of Boost: many cite the Boost status among the C++ + community as an appealing factor to apply. + + +### Opportunities lost? + + +If we look at the number of funded projects concerning + the applications received, figures are not so favorable to + Boost. + +| Organization | No of projects | Project/app ratio | +| --- | --- | --- | +| KDE | 24 | 9.8 % | +| Ubuntu & Bazaar | 22 | 9.3 % | +| Python Software Foundation | 23 | 10.8 % | +| GNOME | 19 | 9.5 % | +| Apache Software Foundation | 27 | 14.2 % | +| **Boost** | **10** | **5.7 %** | +| Gaim | 8 | 5.3 % | +| The GNU Project | 10 | 6.8 % | +| Drupal | 14 | 9.6 % | + + +It turns out that the project/application ratio for almost + any other organization among the top nine is considerably + higher than that of Boost. As it happens, Google initially + requested that organizations submitted the maximum number of + projects they felt they could cope with, and we got funding for + exactly what we aimed for, so the limiting factor lies entirely + on Boost's side. + + +### Projects startup + + +Contributing to Boost relies on a fair number of guidelines + and protocols for coding, documentation, testing and + maintenance. Many of the required tools are exclusively used + within Boost, and some of them are not trivial, like for + instance Boost.Build. Although the Boost web site contains + information about all these tools and procedures, this + intelligence is scattered through unrelated pages and sometimes + is very hard to come by. + + +So, there is a good deal of expertise required to begin + working at Boost. Some students have reported on startup + difficulties getting to know these details and familiarizing + themselves with the tools, most notably `bjam` and + Quickbook. Each student overcome the startup difficulties on + their own or resorting to their mentors (see the section on + [public communication + issues](#public_communication_issues)). + + +### Ongoing development + + +Once students got past the startup stage, most projects + advanced without serious complications. In the majority of + cases, it was realized at some point during the development + that there was no time to complete it. Some participants had to + redefine the goals to keep the project within + schedule, while others simply decided that they would continue + working after the official deadline of Summer of Code. + + +The information flow between each student and their mentor + was usually reported by both parties to be satisfactory. The + projects suffering from lack of communication have been + precisely those yielding the poorest results. In general, + mentors have not felt overwhelmed by requests from their + students, and even in a couple of cases, the projects were run + practically unattended. This fact is witness to the high + competence of the students recruited into the program. + + +The degree of usage of the Trac/SVN system has varied. Some + students did frequent updates, while others have just used the + repository to dump the final results for the official + submission to Google. + + +### Public communication + issues + + +Students and mentors had at their disposal three different + forums for the public interchange of information and + support: + + +* Boost public lists, especially the developers and users + lists. +* A dedicated mailing list reaching all students and + mentors working at Summer of Code in Boost. +* A more casual Google Group, set up by one of the + students, aimed at providing the participants with a place + for socializing and resolution of common problems. + + +Despite this abundance of resources, there was an almost + complete lack of group communication among all the parties + involved and between these and the larger Boost community. + Seemingly, students were satisfied to pursue their activities + by relying on support from their mentors alone. This + circumstance has prevented Boost members from enriching the + initiative by offering their experience and insight, and has + possibly led students to the false impression that contributing + to Boost proceeds in a predictable linear path from requisites + to completion of the work. When asked about their not engaging + in public communication, the students gave vague justifications + that can be classified into the following: + + +* Doubts were deemed too technical or specific to be worth + raising in public. +* A craving for perfectionism detracted students from asking + or submitting work in progress until they felt their material + looked good enough. +* Shyness: some students probably lacked previous + experience communicating in public, and most are not English + native speakers, which could also be a limiting factor. + + +Although students did not identify the following as a reason + not to go public, likely, many of them did not feel + the need given the ready access to their mentors they + enjoyed. It is easy to grow used to such a dedicated source of + support and neglect to resort to other resources. Mentors + should have encouraged their students to pursue the public + discussion of projects, which constitutes one of the pillars of + Boost renowned quality. + + +### Scope of projects + + +In hindsight, it has become apparent that most projects were + too ambitious to be completed within the three months of + duration of the program, and even those that were considered a + success will need weeks or months of polishing up before the + material is ready for a formal review. In contrast with other + organizations participating in the Summer of Code program, + Boost has as of this writing included no results into its codebase. No formal review for any project has been requested yet, + either. + + +These scope issues are very dependent on the particular type + of project. We can classify the Boost projects for Summer of + Code as follows: + + +* Full-fledged libraries, +* additions to existing Boost libraries, +* utilities and tool projects using Boost. + + +Of these, additions (like for instance the max-flow min-cut + algorithm for BGL by Stephan Diederich) are the most suitable + for completion in a short period of time: most of the + preparation work is already done, and the student has clear + guides as to what coding and documentation standards to follow. + Also, these projects need not undergo a formal review, since it + is the responsibility of the hosting library author to review + the code and include it within her discretion. Utility projects + seem also suitable for small timeframes, though most project + proposals and requests are naturally oriented to contributions + of actual code to the Boost project. + + +As for those projects involving the design and realization + of full-fledged libraries, there is little hope that the goals + and scope can be kept modest enough for a three-month schedule. + Boost candidate libraries developed by professional authors + usually take much longer than three months to be accepted; some + libraries have been evolving through several *years* + before being included in Boost. So, the best we can hope for + if we are to support the realization of library projects for + Boost inside Summer of Code is that the results by the end of + the program can be evaluated to constitute a viable + *potential* contribution to Boost. When this is the case, + it is crucial that the student commits to further working on + the project up to completion and formal review. Perhaps more + important than getting libraries coded is to engage new authors + in a long-term relationship with the Boost project. + + +Suggestions for + improvement +---------------------------- + + +The following proposals aim to alleviate some of the + problems we have identified during the development of Summer of + Code within Boost. These action points are related only to the + issues found in connection with Boost: we are not addressing + other areas of improvement associated with the Summer of Code + program itself. + + +### Preparation + + +Much work can be done before the actual program begins. The + following preparation activities can already be launched: + + +**Create a pool of ideas for projects.** This + action will provide valuable extra time for evaluation and + refining of ideas before the Summer of Code begins. The + experience has shown that those projects with more preparation + work, especially in the area of design, were ultimately more + successful. The pool can also be used to retain interesting + ideas that arise on the mailing lists and very often are not + given proper attention and become abandoned. + + +**Create a student pool.** Prior involvement + with Boost is an advantage both in the selection phase + and later during project development. Those students with a + serious interest in participating in Summer of Code with Boost + can enter the pool and begin exploring ideas and interacting + with the community well in advance of the summer, to put + themselves in a favorable position for the selection. + Advertisement for the student pool can be initiated in the + beginning of 2007 through the usual channels (web site and + mailing lists): additionally, Boost members involved with the + University can spread this information locally and help raise + the interest of students in their environment. + + +**Create a mentor pool.** Given the rush with + which Boost entered the 2006 Summer of Code campaign, the + invitation of mentors has to be done on an on-demand basis as + it became all too evident that the task was growing bigger and + bigger. The organization must be better + prepared next year so that several people with the ability + and will to participate as Boost mentors are identified in + advance. + + +**Prepare a startup package.** In order to + facilitate the initial period of getting familiarized with the + various Boost guidelines, protocols and tools, it would be + extremely useful to prepare a compilation of startup material + for students. This package can consist of a single document + gathering the currently dispersed information, or go beyond + this and provide some bundle of documentation and pre-built + tools, an approach that one of the students is currently + working on. + + +### Public communication + + + students must get involved with the community + as soon as possible and grow to appreciate the advantages of + public development concerning solitary coding. + + +**Mandate (bi)weekly reports.** These reports + should be directed to the public mailing lists to allow all Boost members to follow the work in progress + and contribute. Reporting has the extra benefit for students of + forcing them to reflect on their work periodically and + struggle with the often difficult task of presenting their + ideas to others. + + +**Conduct student-mentor exclusively through public + channels.** This might be too drastic a policy, as some + matters need privacy and depending on the amount of + information exchanged flooding problems may arise. Less severe + variations involve allowing for some private interchange at the + mentors' discretion and moving this kind of communication to a + dedicated public mailing list different from the general + ones. + + +### Project management + + +The two most important issues to improve upon with respect + to the management are: + + +* Project scope must be kept under control, +* The progress has to be publicly visible, so that problems + of scope, design and/or schedule can be more easily + detected. + + +Some of the proposals in this section are not to be regarded + as strict rules, but rather as general guidelines to be kept in + mind by students and encouraged by mentors. + + +**Create a best practices document.** This + document can serve as a guideline for project management, an + area in which Boost traditionally imposes no requirements. + Students might lack the expertise in this area that is usually + taken for granted in the traditional model where contributions + to Boost are made by professional programmers. + + +**Mandate a design phase.** Having a concrete + design set up and clearly described early in the project will + help estimate the necessary effort for completion of the work. + This is also an opportunity for public discussion. + + +**Maintain code, docs and tests in parallel.** + All too often, novice programmers do the coding in one fell + swoop and only then move to testing and documenting their work. + This is unacceptable by all current methodology standards, and + can result in serious underestimations of the time to + completion. + + +**Encourage the KISS principle.** It is much + better to finish a simpler library and then iteratively evolve + it, once it has been exposed to public scrutiny and usage. + + +**More Trac updates.** The repository should be + viewed as an everyday work tool, not only as of the place into + which to dump the final results. Updating often leads to more + visibility of the work by the mentor and the public in + general. + + +**Informal reviews.** The typical Summer of + Code Boost project will not be completed by the official + deadline, as have been discussed earlier. To somehow + officialize the work done within the Summer of Code proper, and + also to allow the students to reach some sort of psychological + milestone, informal reviews can be instituted where Boost + members evaluate the work done at the end of Summer of + Code. + + +**Engage students.** This experience has shown + that it is possible to guide willing and bright students to the + competence levels required for contributing to Boost. The best + possible outcome of Summer of Code campaigns are the + incorporation of new people into the circle of Boost active + contributors. Strive to make the students commit to Boost. + + +Conclusions +----------- + + +Despite the lack of previous experience in Boost, our + participation in Google Summer of Code has been extremely + fruitful: much useful material has been produced, and, perhaps + more importantly, some of the students are likely to commit on + a long-term basis and grow to be regular Boost contributors. + Traditionally, becoming a productive Boost author has a very + high entry barrier due to the extreme quality standards, lack + of public support and the very specific culture of the project. + The appeal of Summer of Code itself and the possibility of + being gently mentored into the world of Boost has most likely + been key factors in lowering this entry barrier. + + +The process has not been without some difficulties, either, + as it was expected of a newcomer organization as Boost. We have + tried to identify in this paper the areas of improvement and + suggest specific actions so that the upcoming Google Summer of + Code 2007 can be an even more rewarding experience. + + +Acknowledgements +---------------- + + +This paper couldn't have been written without the numerous + reports and contributions kindly provided by Boost students and + mentors: Many thanks to all the participants for sharing their + experiences with me. Thank you also to the people at Google who + have promoted and conducted the Summer of Code initiative. + + + + + + +© Copyright 2006 Joaquín M López + Muñoz. + + diff --git a/community/imc_summer_of_code_2016.html b/community/imc_summer_of_code_2016.html new file mode 100644 index 0000000..1eec807 --- /dev/null +++ b/community/imc_summer_of_code_2016.html @@ -0,0 +1,58 @@ +--- +title: Boost C++ Libraries +copyright: Jon Kalb 2016. +revised: +--- + + +Boost C++ Libraries + + + +IMC Summer of Code 2016 +======================= + +[![IMC](../gfx/imc.png)](http://www.imc.com/) +Boost has participated in the Google Summer of Code program + for a decade and is very grateful for Google's generous past + support. This program allows college students to have a paid + summer internship working on open source projects, giving them + an interesting alternative to summer onsite internships. + Because the students that work on Boost libraries tend to stay + with the same libraries summer after summer, the continuity of + this program is important to Boost and to the students that + work on Boost projects. + + +Boost has traditionally been a model GSoC participant + receiving a more than average slot allocation, so we were + caught by surprise when Google rejected our 2016 application. + They asked us to apply again next year but to sit out 2016 to give open-source projects which don't normally get awarded + an opportunity. We understand this rationale, but this policy + would mean no summer internships for Boost and leave students + that have been working on Boost libraries looking for other + alternatives for the summer of 2016. + + +When [IMC Financial Markets](http://www.imc.com/) + learned about this situation, they saw it as an opportunity to + support the Boost community and demonstrate their commitment to + student development and open source. + + +IMC worked with Boost to create its own "Boost Summer of + Code" program, deliberately patterned after Google's program. + IMC also stepped up to underwrite all the costs of this program + for the summer of 2016. + + +We thank IMC for their support and community leadership. + + + + + + + + + diff --git a/community/implementation_variations.html b/community/implementation_variations.html new file mode 100644 index 0000000..f221237 --- /dev/null +++ b/community/implementation_variations.html @@ -0,0 +1,287 @@ +--- +title: Boost Implementation Variations +copyright: Beman Dawes 2001. +revised: +--- + + +Boost Implementation Variations + + + +Boost Implementation Variations +=============================== + +Separation of interface and implementation +------------------------------------------ + + +The interface specifications for boost.org library + components (as well as for quality software in general) are + conceptually separate from implementations of those interfaces. + This may not be obvious, particularly when a component is + implemented entirely within a header, but this separation of + interface and implementation is always assumed. From the + perspective of those concerned with software design, + portability, and standardization, the interface is what is + important, while the implementation is just a detail. + + +Dietmar Kühl, one of the original boost.org + contributors, comments "The main contribution is the interface, + which is augmented with an implementation, proving that it is + possible to implement the corresponding class and providing a + free implementation." + + +Implementation variations +------------------------- + + +There may be a need for multiple implementations of an + interface, to accommodate either platform dependencies or + performance tradeoffs. Examples of platform dependencies + include compiler shortcomings, file systems, thread mechanisms, + and graphical user interfaces. The classic example of a + performance tradeoff is a fast implementation that uses a lot + of memory versus a slower implementation which uses less + memory. + + +Boost libraries generally use a [configuration + header](/doc/libs/release/libs/config/config.htm), boost/config.hpp, to capture compiler and platform + dependencies. Although the use of boost/config.hpp is not + required, it is the preferred approach for simple configuration + problems. + + +Boost policy +------------ + + +The Boost policy is to avoid platform dependent variations + in interface specifications, but supply implementations which + are usable over a wide range of platforms and applications. + That means boost libraries will use the techniques below + described as appropriate for dealing with platform + dependencies. + + +The Boost policy toward implementation variations designed + to enhance performance is to avoid them unless the benefits + greatly exceed the full costs. The term "full costs" is + intended to include both tangible costs like extra maintenance, + and intangible cost like increased difficulty in user + understanding. + + +Techniques for providing implementation variations +-------------------------------------------------- + + +Several techniques may be used to provide implementation + variations. Each is appropriate in some situations, and not + appropriate in other situations. + + +### Single general purpose implementation + + +The first technique is to simply not provide implementation + variation at all. Instead, provide a single general-purpose + implementation, and forgo the increased complexity implied by + all other techniques. + + +**Appropriate:** When it is possible to write a + single portable implementation which has reasonable performance + across a wide range of platforms. Particularly appropriate when + alternative implementations differ only in esoteric ways. + + +**Not appropriate:** When implementation + requires platform specific features, or when there are multiple + implementation possible with widely differing performance + characteristics. + + +Beman Dawes comments "In design discussions, some + implementation is often alleged to be much faster than another, + yet a timing test discovers no significant difference. The + lesson is that while algorithmic differences may affect speed + dramatically, coding differences such as changing a class from + virtual to non-virtual members or removing a level of + indirection are unlikely to make any measurable difference + unless deep in an inner loop. And even in an inner loop, modern + CPUs often execute such competing code sequences in the same + number of clock cycles! A single general purpose implementation + is often just fine." + + +Or as Donald Knuth said, "Premature optimization is the root + of all evil." (Computing Surveys, vol 6, #4, p 268). + + +### Macros + + +While the evils of macros are well known, there remain a few + cases where macros are the preferred solution: + + +* Preventing multiple inclusion of headers via #include + guards. +* Passing minor configuration information from a + configuration header to other files. + + +**Appropriate:** For small compile-time + variations that would otherwise be costly or confusing to + install, use, or maintain. More appropriate to communicate + within and between library components than to communicate with + library users. + + +**Not appropriate:** If other techniques will + do. + + +To minimize the negative aspects of macros: + + +* Only use macros when they are clearly superior to other + techniques. They should be viewed as a last resort. +* Names should be all uppercase and begin with the + namespace name. This will minimize the chance of name + collisions. For example, the #include guard for a boost + header called foobar.h might be named BOOST\_FOOBAR\_H. + + +### Separate files + + +A library component can have multiple variations, each + contained in its own separate file or files. The files for the + most appropriate variation are copied to the appropriate + include or implementation directories at installation time. + + +The way to provide this approach in boost libraries is to + include specialized implementations as separate files in + separate sub-directories in the .ZIP distribution file. For + example, the structure within the .ZIP distribution file for a + library named foobar which has both default and specialized + variations might look something like: +``` + +foobar.h // The default header file +foobar.cpp // The default implementation file +readme.txt // Readme explains when to use which files +self\_contained/foobar.h // A variation with everything in the header +linux/foobar.cpp // Implementation file to replace the default +win32/foobar.h // Header file to replace the default +win32/foobar.cpp // Implementation file to replace the default + +``` + +**Appropriate:** When different platforms + require different implementations, or when there are major + performance differences between possible implementations. + + +**Not appropriate:** When it makes sense to use + more that one of the variations in the same installation. + + +### Separate components + + +Rather than have several implementation variations of a + single component, supply several separate components. For + example, the Boost library currently supplies + `scoped_ptr` and `shared_ptr` classes + rather than a single `smart_ptr` class parameterized + to distinguish between the two cases. There are several ways to + make the component choice: + + +* Hardwired by the programmer during coding. +* Chosen by programmer written runtime logic (trading off + some extra space, time, and program complexity for the + ability to select the implementation at run-time.) + + +**Appropriate:** When the interfaces for the + variations diverge, and when it is reasonable to use more than + one of the variations. When run-time selection of + implementation is called for. + + +**Not appropriate:** When the variations are + data type, traits, or specialization variations which can be + better handled by making the component a template. Also not + appropriate when choice of variation is best done by some setup + or installation mechanism outside of the program itself. Thus + usually not appropriate to cope with platform differences. + + +**Note:** There is a related technique where + the interface is specified as an abstract (pure virtual) base + class (or an interface definition language), and the + implementation choice is passed off to some third-party, such + as a dynamic-link library or object-request broker. While that + is a powerful technique, it is way beyond the scope of this + discussion. + + +### Template-based approaches + + +Turning a class or function into a template is often an + elegant way to cope with variations. Template-based approaches + provide optimal space and time efficiency in return for + constraining the implementation selection to compile time. + + +Important template techniques include: + + +* Data type parameterization. This allows a single + component to operate on a variety of data types and is why + templates were originally invented. +* Traits parameterization. If parameterization is complex, + bundling up aspects into a single traits helper class can + allow great variation while hiding messy details. The C++ + Standard Library provides several examples of this idiom, + such as `iterator_traits<>` (24.3.1 + lib.iterator.traits) and char\_traits<> (21.2 + lib.char.traits). +* Specialization. A template parameter can be used purely + for the purpose of selecting a specialization. For + example: +``` + +SomeClass my\_fast\_object; // fast and small are empty classes +SomeClass my\_small\_object; // used just to select specialization + +``` + +**Appropriate:** When the need for variation is + due to data type or traits or is performance-related like + selecting among several algorithms, and when a program might + reasonably use more than one of the variations. + + +**Not appropriate:** When the interfaces for + variations are different, or when choice of variation is best + done by some mechanism outside of the program itself. Thus + usually not appropriate to cope with platform differences. + + + + + + + + + diff --git a/community/index.html b/community/index.html new file mode 100644 index 0000000..6adaf67 --- /dev/null +++ b/community/index.html @@ -0,0 +1,50 @@ +--- +title: Community +copyright: Rene Rivera 2007. +revised: +--- +Community + + +/\*\*/ + + + +Community +========= + +Although Boost was begun by members of the C++ Standards + Committee Library Working Group, participation has expanded to + include thousands of programmers from the C++ community at + large. + + +If you are interested in participating in Boost, please join + our main [developers mailing + list](groups.html#main). Discussions are highly technical, and listed members + are encouraged to participate in formal reviews of proposed + libraries. There is also a [users + mailing list](groups.html#users), and several [project specific lists](groups.html#projects). + + +If you are looking for more lively interaction with the + Boost community there are also some [internet + relay chat](irc.html) channels (freenode) that users and developers + like to hang out in. + + +Below is a community maintained calendar of Boost related + events. Mostly, this includes development of the release. Note + that schedules slip and this might not be up to + date. + + + + + + + + + diff --git a/community/irc.html b/community/irc.html new file mode 100644 index 0000000..142dcf6 --- /dev/null +++ b/community/irc.html @@ -0,0 +1,66 @@ +--- +title: Boost IRC Hangouts +copyright: Rene Rivera 2007. +revised: +--- + + +Boost IRC Hangouts + + + +Boost IRC Hangouts +================== + +Boost users and developers spend time in various IRC + channels to generally work together. The attendance and traffic + of the channels vary greatly but there is usually someone + around to chat. And many times chat about just about any topic, + not just about the Boost C++ Libraries. + + +Even though the channels are not moderated in the strict + sense, for some there is the expectation that one should follow + the usual Boost discussion rules of civility. This is both as a + recognition that the Boost community is varied in age, and in + sensibilities. So please keep your language clean. And don't be + surprised if you find yourself reprimanded by the ops. + + +Our channels can be found on the [freenode](http://freenode.net/) network. + + +#boost +------ + + +This is the main channel, and as such sees a good deal of + traffic at times. Most times one can find about 80 "people" + (there are a few bots in there) and a good representation from + Boost developers. If you are looking for some quick help in + getting something in Boost working this is a good place to + go. + + +* [Connect](irc://freenode/boost) + + +##c++ +----- + + +This is rather chatty but topical, hence the ## in the name, + C++ language discussion channel. Many of the same people who + hang out in the #boost channel, also hang out here. + + +* [Connect](irc://freenode/%23%23c++) + + + + + + + + + diff --git a/community/moderators.html b/community/moderators.html new file mode 100644 index 0000000..81135fe --- /dev/null +++ b/community/moderators.html @@ -0,0 +1,72 @@ +--- +title: Moderators +copyright: Beman Dawes 2001-2004. +revised: +--- + + +Moderators + + + +Boost Moderators +================ + +The Boost moderators are [Dave Abrahams](/users/people/dave_abrahams.html), Carl + Daniel, [Beman + Dawes](/users/people/beman_dawes.html), [Jeff + Garland](/users/people/jeff_garland.html), [Doug + Gregor](/users/people/doug_gregor.html), and [John + Maddock](/users/people/john_maddock.html). You can reach the moderators at [boost-owner@lists.boost.org](mailto:boost-owner@lists.boost.org). + + +**Note:** The boost moderators do not moderate any + mailing lists other than the main Boost developers' list. For + example, the boost-users list moderators are at [boost-users-owner@lists.boost.org](mailto:boost-users-owner@lists.boost.org). + The moderators of [every other + Boost list](/community/groups.html) can be reached through its home page. + + +Moderator Functions +------------------- + + +* Monitor the mailing list to ensure dialog remains within + the acceptable boundaries set by the [discussion policy](/community/policy.html). When + discussion strays, use private email to gently remind, + strongly rebuke, or outright ban, as the situation + demands. + + +* Approve the initial postings of new (and thus still + moderated) members, and move members to the "Group Policy" + posting status. + + +* Administer the internal operations of the Boost web site, + the main Boost mailing list, the CVS repository, and other + Boost administrative machinery. + + +* Act as an executive committee overseeing important + administrative and policy decisions. Boost is a zero-budget + organization with no income and no expenses, so that + eliminates the need for most management. Technical decisions + are worked out on the mailing list. The moderators handle the + few remaining decisions that need a definite answer. + + +* Beyond the purely administrative duties, work to keep the + Boost community vibrant and alive. That may be as simple as + saying "thank you" to an individual member, or as complex as + starting some major new initiative. Do whatever it + takes! + + + + + + + + + diff --git a/community/official_library_maintainer_program.html b/community/official_library_maintainer_program.html new file mode 100644 index 0000000..492b0ef --- /dev/null +++ b/community/official_library_maintainer_program.html @@ -0,0 +1,88 @@ +--- +title: Boost Library Official Maintainer Program +copyright: Alex Olivas 2015. +revised: +--- + + +Boost Library Official Maintainer Program + + +/\*\*/ + + + +Boost Library Official Maintainer Program +========================================= + + +Introduction +------------ + + +The [Boost Community Maintenance Team](https://svn.boost.org/trac/boost/wiki/CommunityMaintenance) (CMT) has identified many Boost + libraries still used but not maintained actively. To protect the + reputation that Boost has cultivated over the years, as an + organization that provides high-quality open-source software, + all libraries bundled with Boost releases + have active and engaged maintainers. The purpose of the Boost + Library Official Maintainer Program is to recruit companies and + organizations, that are likely already providing internal support, + to become official maintainers of those libraries already important + to them. + + +In exchange for taking on maintenance of a library, Boost will + display the maintainer's logo below in the [Libraries and Participants](#libraries_and_participants) + section. Boost may also display the logo on the Boost github + and Trac sites. Maintainers are also allowed to use the [Boost Official Library + Maintainer Logo](blom_libraries/logos/blom_logo.png) on their own sites, presentations, + etc... + + +Applying to the Program +----------------------- + + +If you're interested in maintaining a Boost library : + + +1. Read the [Memorandum of + Understanding](blom_libraries/BLOM_MoU_v0.pdf), which outlines what's expected of + mainainers as well as terms for leaving the program. +2. Send an email to the program administrator ([Alex Olivas](mailto:olivas@icecube.umd.edu)) indicating + which library (or libraries) you'd like to maintain. + + +Thanks for helping out! + + +Libraries and + Participants +--------------------------- + + +[Boost.Function](blom_libraries/boost_function.html) - + Maintained by [The IceCube + Collaboration](http://www.icecube.wisc.edu) ![IceCube South Pole Neutrino Observatory](blom_libraries/logos/IceCube_horizontal2.jpg) + + +### Program Administrator + + +The Boost Library Official Maintainer Program is currently + administered by [Alex + Olivas](mailto:olivas@icecube.umd.edu). Feel free to send an email if you'd like more + information about the program. + + + + + +Revised 14 September 2015 + + + + diff --git a/community/policy.html b/community/policy.html new file mode 100644 index 0000000..80a934d --- /dev/null +++ b/community/policy.html @@ -0,0 +1,415 @@ +--- +title: Boost Discussion Policy +copyright: Beman Dawes, Rob Stewart, David Abrahams, 2000-2005. +revised: +--- + + +Boost Discussion Policy + + + +Boost Discussion Policy +======================= + +Email discussion is the tie that binds boost members + together into a community. If the discussion is stimulating and + effective, the community thrives. If the discussion degenerates + into name-calling and ill will, the community withers and + dies. + + +* [Acceptable Topics](#acceptable) +* [Unacceptable Topics](#unacceptable) +* [Effective Posting](#effective) + + [Well-Crafted Posting is Worth the Effort](#well-crafted) + + [Put the Library Name in the Subject Line](#subject-line) + + [Don't Use Tabs](#tabs) + + [Limit Line + Length](#longlines) + + [Don't Overquote, Don't Top-Post, and Do + Use Inline Replies for Readable Quotations](#quoting) + + [Keep the Formatting of Quotations Consistent](#formatting-quotations) + + [Summarizing and Referring to Earlier Messages](#summarizing-referring) + + [Maintain the Integrity of Discussion Threads](#discussion-threads) + + [Keep The Size of Your Posting Manageable](#max-size) +* [Prohibited Behavior](#behavior) + + [Flame wars](#flame-wars) + + [Third-party attacks](#third-party-attacks) + + [Off-topic posts](#off-topic-posts) +* [Culture](#culture) +* [Guidelines for Effective Discussions](#effective-discussions) +* [Library Names](#lib_names) + + +Acceptable + topics +------------------ + + +* Queries to determine interest in a possible library + submission. +* Technical discussions about a proposed or existing + library, including bug reports and requests for help. +* Formal Reviews of proposed libraries. +* Reports of user experiences with Boost libraries. +* Boost administration or policies. +* Compiler specific workarounds as applied to Boost + libraries. + + +Other topics related to boost development may be acceptable, + at the discretion of moderators. If unsure, go ahead and post. + The moderators will let you know. + + +Unacceptable + Topics +-------------------- + + +* Advertisements for commercial products. +* Requests for help getting non-boost code to compile with + your compiler. Try the comp.lang.c++.moderated newsgroup + instead. +* Requests for help interpreting the C++ standard. Try the + comp.std.c++ newsgroup instead. +* Job offers. +* Requests for solutions to homework assignments. + + +Effective + Posting +------------------ + + +Most Boost mailing lists host a great deal of traffic, so + your post is usually competing for attention with many other + communications. This section describes how to make sure it has + the desired impact. + + +### Well-Crafted Posting is Worth the Effort + + +Don't forget, you're a single writer but there are many + readers, and you want them to stay interested in what you're + saying. Saving your readers a little time and effort is usually + worth the extra time you spend when writing a message. Also, + boost discussions are saved for posterity, as rationales and + history of the work we do. A post's usefulness in the future is + determined by its readability. + + +### Put the Library Name in the Subject Line + + +When your post is related to a particular Boost library, + it's helpful to put the library name in square brackets at the + beginning of the subject line, e.g. +> +> Subject: [Regex] Why doesn't this pattern match? +> +> +> + + +The Boost developers' list is a high-volume mailing list, + and most maintainers don't have time to read every message. A + tag on the subject line will help ensure the right people see + your post. + + +### Don't Use Tabs + + +If you use tabs to indent your source code, convert them to + spaces before inserting the code in a posting. Something in the + processing chain usually strips all the indentation and leaves + a mess behind. + + +### Limit Line + Length + + +If you put source code in your postings and your mailer + wraps long lines automatically, either keep the code narrow or + insert the code as an (inline, if possible) attachment. That + will help ensure others can read what you've posted. + + +### Don't Overquote, Don't + Top-Post, and Do Use Inline Replies for Readable Quotations + + +Please **prune extraneous quoted text** from + replies so that only the relevant parts are included. It will + save time and make your post more valuable when readers do not + have to find out which exact part of a previous message you + are responding to. + + +Don't [top-post](http://en.wikipedia.org/wiki/Posting_style#Top-posting); + inline replies are the appropriate [posting style](http://en.wikipedia.org/wiki/Posting_style) + for Boost lists. + + +The common and very useful inline approach cites the small + fractions of the message you are actually responding to and + puts your response directly beneath each citation, with a blank + line separating them for readability: +``` +Person-you're-replying-to wrote: + +> Some part of a paragraph that you wish to reply to goes +> here; there may be several lines. + +Your response to that part of the message goes here. There may, +of course, be several lines. + +> The second part of the paragraph that is relevant to your +> reply goes here; again there may be several lines. + +Your response to the second part of the message goes here. +... + +``` + +For more information about effective use of quotation in + posts, see [this helpful guide](http://www.netmeister.org/news/learn2quote.html). + + +### Keep the Formatting of Quotations Consistent + + +Some email and news clients use poor word wrapping + algorithms that leave successive lines from the same quotation + with differing numbers of leading "`>`" + characters. **Microsoft Outlook** and + **Outlook Express**, and some web clients, are + especially bad about this. If your client offends in this way, + please take the effort to clean up the mess it makes in quoted + text. Remember, even if you didn't write the original text, + it's *your* posting; whether you get your point across + depends on its readability. + + +The Microsoft clients also create an unusually verbose + header at the beginning of the original message text and leave + the cursor at the beginning of the message, which encourages + users to write their replies before all of the quoted text + rather than putting the reply in context. Fortunately, Dominic + Jain has written a utility that fixes all of these problems + automatically: [Outlook Quotefix](http://home.in.tum.de/~jain/software/outlook-quotefix/) for Outlook Users and [OE QuoteFix](http://home.in.tum.de/~jain/software/oe-quotefix/) for users of Outlook Express. + + +### Summarizing and Referring to Earlier Messages + + +A summary of the foregoing thread is only needed after a + long discussion, especially when the topic is drifting or a + result has been achieved in a discussion. The mail system will + do the tracking that is needed to enable mail readers to + display message threads (and every decent mail reader supports + that). + + +If you ever have to refer to single message earlier in a + thread or in a different thread then you can use a URL to the + [message archives](groups.html#archive). To help to + keep those URLs short, you can use [tinyurl.com](http://tinyurl.com). Citing the relevant portion + of a message you link to is often helpful (if the citation is + small). + + +### Maintain the Integrity of Discussion Threads + + +**When starting a new topic, always send a fresh + message**, rather than beginning a reply to some other + message and replacing the subject and body. Many mailers can detect the thread you started with and will show the + new message as part of the original thread, which probably + isn't what you intended. Follow this guideline for your own + sake as well as for others'. Often, people scanning for + relevant messages will decide they're done with a topic and + hide or kill the entire thread: your message will be missed, + and you won't get the response you're looking for. + + +By the same token, **When replying to an existing + message, use your mailer's "Reply" function**, so that + the reply shows up as part of the same discussion thread. + + +**Do not reply to digests** if you are a digest + delivery subscriber. Your reply will not be properly threaded + and will probably have the wrong subject line. Instead, you can + reply through the [GMane web interface](http://news.gmane.org/gmane.comp.lib.boost.devel). + + +### Keep The Size of Your Posting Manageable + + +The mailing list software automatically limits message and + attachment size to a reasonable amount, typically 75K, which is + adjusted from time-to-time by the moderators. This limit is a + courtesy to those who rely on dial-up Internet access and let's + face it, no one wants to read a posting that consists of 75K of + error message text. + + +Prohibited + Behavior +-------------------- + + +Prohibited behavior will not be tolerated. The moderators + will ban postings by abusers. + + +### Flame wars + + +Personal insults, argument for the sake of argument, and all + the other behaviors which fall into the "flame war" category + are prohibited. Discussions should focus on technical + arguments, not the personality traits or motives of + participants. + + +### Third-party attacks + + +Attacks on third parties such as software vendors, hardware + vendors, or any other organizations, are prohibited. Boost + exists to unite and serve the entire C++ community, not to + disparage the work of others. + + +Does this mean that we ban the occasional complaint or wry + remark about a troublesome compiler? No, but be wary of + overdoing it. + + +### Off-topic posts + + +Discussions that stray from the acceptable topics are + strongly discouraged. While off-topic posts are often well + meaning and not as individually corrosive as other abuses, + cumulatively the distraction damages the effectiveness of + discussion. + + +Culture +------- + + +In addition to technical skills, Boost members value + collaboration, acknowledgment of the help of others, and a + certain level of politeness. Boost membership is very + international, and ranges widely in age and other + characteristics. Think of discussion as occurring among + colleagues in a widely read forum, rather than among a few + close friends. + + +Always remember that the cumulative effort spent by people + reading your contribution scales with the (already large) + number of boost members. Thus, do invest time and effort to + make your message as readable as possible. Adhere to English + syntax and grammar rules such as proper capitalization. Avoid + copious informalism, colloquial language, or abbreviations, + they may not be understood by all readers. Re-read your message + before submitting it. + + +Guidelines for Effective Discussions +------------------------------------ + + +Apply social engineering to prevent heated technical + discussion from degenerating into a shouting match, and to + actively encourage the cooperation upon which Boost + depends. + + +* Questions help. If someone suggests something that you + don't think will work, then replying with a question like + "will that compile?" or "won't that fail to compile, or am I + missing something?" is a lot smoother than "That's + stupid - it won't compile." Saying "that fails to compile for + me, and seems to violate section n.n.n of the standard" would + be yet another way to be firm without being abrasive. +* If most of the discussion has been code-free + generalities, posting a bit of sample code can focus people + on the practical issues. +* If most of the discussion has been in terms of specific + code, try to talk a bit about hidden assumptions and + generalities that may be preventing discussion closure. +* Taking a time-out is often effective. Just say: "Let me + think about that for a day or two. Let's take a time-out to + digest the discussion so far." + + +Avoid ***Parkinson's Bicycle Shed***. + Parkinson described a committee formed to oversee design of an + early nuclear power plant. There were three agenda items - when + to have tea, where to put the bicycle shed, and how to ensure + nuclear safety. Tea was disposed of quickly as trivial. Nuclear + safety was discussed for only an hour - it was so complex, + scary, and technical that even among experts few felt + comfortable with the issues. Endless days were then spent + discussing construction of the bicycle shed (the parking lot + would be the modern equivalent) because everyone thought they + understood the issues and felt comfortable discussing them. + + +Library Names +------------- + + +In order to ensure a uniform presentation in books and + articles, we have adopted a convention for referring to Boost + libraries. Library names can either be written in a compact + form with a dot, as "Boost.Name", or in a long form + as "the Boost Name library." For example: +> +> **Boost.Python** serves a very different +> purpose from **the Boost Graph library**. +> +> +> + + +Note that the word "library" is not part of the name, and as + such isn't capitalized. + + +Please take care to avoid confusion in discussions between + libraries that have been accepted into Boost and those that + have not. Acceptance as a Boost library indicates that the code + and design have passed through our peer-review process; failing + to make the distinction devalues the hard work of library + authors who've gone through that process. Here are some + suggested ways to describe potential Boost libraries: + + +* the proposed Boost Name library +* the Boost.Name candidate +* the Name library (probably the best choice + where applicable) + + +Note that this policy only applies to discussions, not to + the documentation, directory structure, or even identifiers in + the code of potential Boost libraries. + + + + + + + + diff --git a/community/requests.html b/community/requests.html new file mode 100644 index 0000000..446a117 --- /dev/null +++ b/community/requests.html @@ -0,0 +1,43 @@ +--- +title: Requesting New Features +copyright: +revised: +--- + + +Requesting New Features + + + +Requesting new features for Boost libraries +=========================================== + +If you have an idea for a feature or improvement to an + existing Boost library - go ahead and post it to either + [boost-users list](/community/groups.html#users) or + [boost mailing list](/community/groups.html#main) + (if you are posting for the first time, please read our + [discussion + policy](https://www.boost.org/more/discussion_policy.htm) before you actually post). + + +You can also try submitting a feature request to our + [issue tracker](https://github.com/boostorg/) + on GitHub, but experience has shown that posting to either of the mailing lists is usually a more effective way to get attention + of boost developers. + + +If your proposal has its merits, it's very likely that it + will generate a constructive discussion that might actually + result in (sometimes substantial) improvement of the library - + and your name being put on the library's [Acknowledgements](/development/requirements.html#Acknowledgements) + section! + + + + + + +© html) 2002 + + diff --git a/community/review_schedule.html b/community/review_schedule.html new file mode 100644 index 0000000..722b3a6 --- /dev/null +++ b/community/review_schedule.html @@ -0,0 +1,456 @@ +--- +title: Boost Formal Review Schedule +copyright: Beman Dawes, Tom Brinkman, Jeff Garland, 2001-2005. +revised: +--- + + +Boost Formal Review Schedule + + + +Boost Formal Review Schedule +============================ + +Reviews are scheduled when the review wizards approve a + review manager and agree with the manager and author on dates. + See [Formal Review Process](reviews.html) for more + information. + + +In addition to upcoming reviews, the schedule includes + recent reviews already completed; that helps track review + manager assignments and libraries reviewed but not yet posted + on the website. There is often a lag between acceptance and + site posting as authors address issues raised in the formal + review. + + +Schedule +-------- + +| Submission | Submitter | Link | Review Manager | Review Dates | +| --- | --- | --- | --- | --- | +| URL | Vinnie Falco, Alan de Freitas | * [Github](https://github.com/CPPAlliance/url) +* [Documentation](https://master.url.cpp.al/) + | [Klemens Morgenstern](https://lists.boost.org/Archives/boost/2022/06/253225.php) | August 13, 2022 - August 22, 2022 | +| Text (mini-review) | Zach Laine | * [Github](https://github.com/tzlaine/text) +* [Documentation](https://tzlaine.github.io/text) + | [Needed!](https://lists.boost.org/Archives/boost/2020/08/249594.php) | - | + + +Past Review Results and Milestones +---------------------------------- + +| Submission | Submitter | Review Manager | Review Dates | Result | +| --- | --- | --- | --- | --- | +| MySQL | Ruben Perez | Richard Hodges | May 9, 2022 - May 18, 2022 | ~~[Pending](https://lists.boost.org/Archives/boost/2022/05/252898.php)~~ +[Accepted](https://lists.boost.org/Archives/boost//2022/06/253193.php) || Lambda2 | Peter Dimov | Joel de Guzman | March 22, 2021 - March 31, 2021 | ~~[Pending](https://lists.boost.org/Archives/boost/2021/03/251218.php)~~ +[Accepted](https://lists.boost.org/Archives/boost/2021/04/251393.php) || Describe | Peter Dimov | Richard Hodges | March 1, 2021 - March 10, 2021 | ~~[Pending](https://lists.boost.org/Archives/boost/2021/02/250933.php)~~ +[Accepted](https://lists.boost.org/Archives/boost/2021/03/251099.php) | +| PFR(Precise and Flat Reflection) | Antony Polukhin | Benedek Thaler | September 28, 2020 - October 7, 2020 | ~~[Pending](https://lists.boost.org/Archives/boost/2020/09/250077.php)~~ +[Accepted](https://lists.boost.org/Archives/boost/2020/10/250176.php) | +| JSON | Vinnie Falco, Krystian Stasiowski | Pranam Lashkari | September 14, 2020 - September 23, 2020 | ~~[Pending](https://lists.boost.org/Archives/boost/2020/09/249708.php)~~ +[Accepted](https://lists.boost.org/Archives/boost/2020/10/250129.php) | +| LEAF(Lightweight Error Augmentation Framework) | Emil Dotchevski | Michael Caisse | May 22, 2020 - May 31, 2020 | ~~[Pending](https://lists.boost.org/Archives/boost/2020/05/248850.php)~~ +[Accepted](https://lists.boost.org/Archives/boost/2020/08/249657.php) | +| Text | Zach Laine | Glen Fernandes | June 11, 2020 - June 20, 2020 | ~~[Pending](https://lists.boost.org/Archives/boost/2020/06/249094.php)~~ +[Rejected](https://lists.boost.org/Archives/boost/2020/06/249242.php) | +| Review Wizard Status Report | | Mateusz Loskot | May 20, 2020 | [Report](https://lists.boost.org/Archives/boost/2020/05/248944.php) | +| Boost 1.73.0 Released | | Marshall Clow | April 28, 2020 | [Notes](https://www.boost.org/users/history/version_1_73_0.html) | +| Boost 1.72.0 Released | | Marshall Clow | December 11, 2019 | [Notes](https://www.boost.org/users/history/version_1_72_0.html) | +| STLInterfaces | Zach Laine | Barrett Adair | December 10, 2019 - December 19, 2019 | ~~[Pending](https://lists.boost.org/boost-announce/2019/12/0564.php)~~ +[Conditionally Accepted](https://lists.boost.org/boost-announce/2019/12/0568.php) | +| StaticString (was FixedString) | Krystian Stasiowski and Vinnie Falco | Joaquin M López Muñoz | November 25, 2019 - December 4, 2019 | ~~[Pending](https://lists.boost.org/boost-announce/2019/11/0563.php)~~ +[Accepted -- Added in 1.73](https://lists.boost.org/Archives/boost/2020/02/248229.php) | +| Boost 1.71.0 Released | | Marshall Clow | August 19, 2019 | [Notes](https://www.boost.org/users/history/version_1_71_0.html) | +| out\_ptr | JeanHeyd Meneide | Zach Laine | June 16, 2019 - July 10, 2019 | ~~[Pending](https://lists.boost.org/boost-announce/2019/06/0556.php)~~ +[Rejected](https://lists.boost.org/boost-announce/2019/07/0558.php) | +| Boost 1.70.0 Released | | Marshall Clow | April 12, 2019 | [Notes](https://www.boost.org/users/history/version_1_70_0.html) | +| Variant2 | Peter Dimov | Michael Caisse | April 1, 2019 - April 15, 2019 | ~~[Ongoing](https://lists.boost.org/Archives/boost/2019/03/245563.php)~~ +[Accepted -- Added in 1.71](https://lists.boost.org/boost-announce/2019/06/0553.php) | +| Boost 1.69.0 Released | | Marshall Clow | December 11, 2018 | [Notes](https://www.boost.org/users/history/version_1_69_0.html) | +| Histogram | Hans Dembinski | Mateusz Loskot | September 17, 2018 - September 26, 2018 | ~~[Pending](https://lists.boost.org/boost-announce/2018/09/0544.php)~~ +[Accepted -- Added in 1.70](https://lists.boost.org/boost-announce/2018/10/0548.php) | +| Boost 1.68.0 Released | | Marshall Clow | August 09, 2018 | [Notes](https://www.boost.org/users/history/version_1_68_0.html) | +| Boost 1.67.0 Released | | Daniel James | April 16, 2018 | [Notes](https://www.boost.org/users/history/version_1_67_0.html) | +| YAP | Zach Laine | Louis Dionne | February 5, 2018 - February 14, 2018 | ~~[Ongoing](https://lists.boost.org/boost-announce/2018/02/0537.php) +[Conditionally Accepted](https://lists.boost.org/boost-announce/2018/03/0540.php)~~ +[Accepted -- Added in 1.70](https://lists.boost.org/boost-announce/2018/06/0542.php) | +| Outcome | Niall Douglas | Charley Bay | January 19, 2018 - January 28, 2018 | ~~[Pending](https://lists.boost.org/boost-announce/2018/01/0533.php)~~ +[Accepted -- Added in 1.70](https://lists.boost.org/boost-announce/2018/02/0536.php) | +| Boost 1.66.0 Released | | Daniel James | December 19, 2017 | [Notes](https://www.boost.org/users/history/version_1_66_0.html) | +| Double-Ended | Benedek Thaler | Thorsten Ottosen | September 21, 2017 - October 7, 2017 | ~~[Pending](https://lists.boost.org/boost-announce/2017/09/0528.php)~~ +[Conditionally Accepted](https://lists.boost.org/boost-announce/2017/10/0530.php) | +| Fit (now HOF) | Paul Fultz | Matt Calabrese | September 8, 2017 - September 20, 2017 | ~~[Pending](https://lists.boost.org/boost-announce/2017/09/0526.php)~~ +[Accepted -- Added in 1.67](https://lists.boost.org/boost-announce/2017/09/0529.php) | +| Boost 1.65.1 Released | | Daniel James | September 7, 2017 | [Notes](https://www.boost.org/users/history/version_1_65_1.html) | +| Boost 1.65.0 Released | | Daniel James | August 21, 2017 | [Notes](https://www.boost.org/users/history/version_1_65_0.html) | +| mp11 | Peter Dimov | Bjorn Reese | July 15, 2017 - July 24, 2017 | ~~[Ongoing](https://lists.boost.org/boost-announce/2017/07/0519.php)~~ +[Accepted -- Added in 1.66](https://lists.boost.org/boost-announce/2017/08/0520.php) | +| Beast | Vinnie Falco | Michael Caisse | July 1, 2017 - July 10, 2017 | ~~[Pending](https://lists.boost.org/boost-announce/2017/06/0515.php)~~ +[Accepted -- Added in 1.66](https://lists.boost.org/Archives/boost/2017/07/237385.php) | +| pdqsort | Orson Peters | Steven Ross | June 21, 2017 - June 30, 2017 | [Accepted](https://lists.boost.org/boost-announce/2017/06/0518.php) | +| Nowide | Artyom Beilis | Frédéric Bron | June 12, 2017 - June 21, 2017 | ~~[Pending](https://lists.boost.org/boost-announce/2017/06/0512.php)~~ +[Accepted -- Added in 1.73](https://lists.boost.org/boost-announce/2017/06/0516.php) | +| Timsort | Alexander Zaitsev | Steven Ross | June 3, 2017 - June 12, 2017 | ~~[Ongoing](https://lists.boost.org/boost-announce/2017/06/0509.php)~~ +[Rejected](https://lists.boost.org/boost-announce/2017/06/0513.php) | +| Outcome | Niall Douglas | Charley Bay | May 19, 2017 - May 28, 2017 | ~~[Pending](https://lists.boost.org/boost-announce/2017/05/0504.php)~~ +[Rejected](https://lists.boost.org/boost-announce/2017/06/0510.php) | +| PolyCollection | Joaquín Mª López Muñoz | Ion Gaztañaga | May 3, 2017 - May 12, 2017 | ~~[Ongoing](https://lists.boost.org/boost-announce/2017/05/0502.php)~~ +[Accepted -- Added in 1.65](https://lists.boost.org/boost-announce/2017/05/0505.php) | +| Boost 1.64.0 Released | | Rene Rivera | April 19, 2017 | [Notes](https://www.boost.org/users/history/version_1_64_0.html) | +| CallableTraits | Barrett Adair | Louis Dionne | April 3, 2017 - April 12, 2017 | ~~[Ongoing](https://lists.boost.org/Archives/boost/2017/03/234005.php)~~ +[Conditionally Accepted -- Added in 1.66](https://lists.boost.org/Archives/boost/2017/04/234513.php) | +| Stacktrace | Antony Polukhin | Niall Douglas | March 17, 2017 - March 26, 2017 | ~~[Ongoing](https://lists.boost.org/boost-announce/2017/03/0493.php)~~ +[Accepted -- Added in 1.65](https://lists.boost.org/boost-announce/2017/03/0496.php) | +| Safe Numerics | Robert Ramey | Andrzej Krzemienski | March 2, 2017 - March 16, 2017 | ~~[Ongoing](https://lists.boost.org/boost-announce/2017/03/0491.php)~~ +[Conditionally Accepted -- Added in 1.69](https://lists.boost.org/boost-announce/2017/03/0494.php) | +| Boost 1.63.0 Released | | Marshall Clow | December 26, 2016 | [Notes](https://www.boost.org/users/history/version_1_63_0.html) | +| Stacktrace | Antony Polukhin | Niall Douglas | December 14, 2016 - December 23, 2016 | ~~[Pending](https://lists.boost.org/boost-announce/2016/12/0483.php)~~ +[Conditionally Accepted](https://lists.boost.org/boost-announce/2017/01/0486.php) | +| Synapse | Emil Dotchevski | Edward Diener | December 2, 2016 - December 11, 2016 | ~~[Pending](https://lists.boost.org/boost-announce/2016/12/0479.php)~~ +[Rejected](https://lists.boost.org/boost-announce/2016/12/0484.php) | +| Parallel Sorting Sub-library | Francisco José Tapia | Steven Ross | November 11, 2016 - November 20, 2016 | ~~[Pending](https://lists.boost.org/Archives/boost/2016/11/231544.php)~~ +[Accepted](https://lists.boost.org/Archives/boost/2016/11/231732.php) | +| Process | Klemens Morgenstern | Antony Polukhin | October 27, 2016 - November 5, 2016 | ~~[Pending](https://lists.boost.org/boost-announce/2016/10/0476.php)~~ +[Accepted -- Added in 1.64](https://lists.boost.org/boost-announce/2016/11/0477.php) | +| Boost 1.62.0 Released | | Rene Rivera | September 28, 2016 | [Notes](https://www.boost.org/users/history/version_1_62_0.html) | +| Fiber (mini-review) | Oliver Kowalke | Nat Goodspeed | May 23, 2016 - June 2, 2016 | ~~[Pending](https://lists.boost.org/boost-announce/2016/05/0473.php)~~ +[Accepted -- Added in 1.62](https://lists.boost.org/boost-announce/2016/06/0474.php) | +| Review Wizard Status Report | | Ronald Garcia | May 19, 2016 | [Report](https://lists.boost.org/boost-announce/2016/05/0471.php) | +| Boost 1.61.0 Released | | Rene Rivera | May 13, 2016 | [Notes](https://www.boost.org/users/history/version_1_61_0.html) | +| Fit | Paul Fultz | Vicente Botet | March 2, 2016 - March 13, 2016 | ~~[Ongoing](https://lists.boost.org/Archives/boost/2016/03/228107.php)~~ +[Rejected](https://lists.boost.org/Archives/boost/2016/04/228770.php) | +| Quaternions, Vectors, Matrices (QVM) | Emil Dotchevski | Adam Wulkiewicz | December 7, 2015 - December 23, 2015 | ~~[Ongoing](https://lists.boost.org/boost-announce/2015/12/0458.php)~~ +[Accepted -- Added in 1.62](https://lists.boost.org/Archives/boost/2016/01/227027.php) | +| Boost 1.60.0 Released | | Marshall Clow | December 17, 2015 | [Notes](https://www.boost.org/users/news/version_1_60_0) | +| Fiber (mini-review) | Oliver Kowalke | Nat Goodspeed | September 4, 2015 - September 13, 2015 | ~~[Pending](https://lists.boost.org/boost-announce/2015/09/0453.php)~~ +[Continuing Conditionally Accepted](https://lists.boost.org/boost-announce/2015/10/0456.php) | +| Asynchronous File I/O | Niall Douglas and + Paul Kirth | Ahmed Charles | August 21, 2015 - August 31, 2015 | ~~[Pending](https://lists.boost.org/boost-announce/2015/08/0451.php)~~ + Rejected (no result posted) + | +| Boost 1.59.0 Released | | Marshall Clow | August 13, 2015 | [Notes](https://www.boost.org/users/news/version_1_59_0) | +| Http | Vinícius dos Santos Oliveira | Bjorn Reese | August 7, 2015 - August 16, 2015 | ~~[Pending](https://lists.boost.org/boost-announce/2015/08/0449.php)~~ +[Rejected](https://lists.boost.org/boost-announce/2015/08/0452.php) | +| DLL | Antony Polukhin | Vladimir Prus | June 29, 2015 - July 12, 2015 | ~~[Pending](https://lists.boost.org/Archives/boost/2015/07/223995.php)~~ +[Accepted -- Added in 1.61](https://lists.boost.org/boost-announce/2015/07/0448.php) | +| Hana | Louis Dionne | Glen Fernandes | June 10, 2015 - June 24, 2015 | [Accepted -- Added in 1.61](https://lists.boost.org/boost-announce/2015/07/0443.php) | +| Metaparse | Abel Sinkovics | Christophe Henry | May 25, 2015 - June 7, 2015 | ~~[Pending](https://lists.boost.org/Archives/boost/2015/05/222478.php)~~ +[Accepted -- Added in 1.61](https://lists.boost.org/boost-announce/2015/07/0446.php) | +| Boost 1.58.0 Released | | Marshall Clow | April 17, 2015 | [Notes](https://www.boost.org/users/news/version_1_58_0) | +| Endian Mini-Review | Beman Dawes | Joel Falcou | January 23, 2015 - February 1, 2015 | ~~[Ongoing](https://lists.boost.org/boost-announce/2015/01/0428.php)~~ +[Accepted -- Added in 1.58](https://lists.boost.org/Archives/boost/2015/02/220090.php) | +| Review Wizard Status Report | | Ronald Garcia | January 22, 2015 | [Report](https://lists.boost.org/boost-announce/2015/01/0427.php) | +| Compute | Kyle Lutz | Antony Polukhin | December 15, 2014 - December 30, 2014 | ~~[Ongoing](https://lists.boost.org/boost-announce/2014/12/0423.php)~~ [Accepted -- Added in 1.61](https://lists.boost.org/boost-announce/2015/01/0425.php) | +| Sort | Steven Ross | Edward Diener | November 10, 2014 - November 19, 2014 | ~~[Pending](https://lists.boost.org/boost-announce/2014/11/0421.php)~~ [Accepted + -- Added in 1.58](https://lists.boost.org/boost-announce/2014/11/0422.php) | +| Boost 1.57.0 Released | | Marshall Clow | November 3, 2014 | [Notes](https://www.boost.org/users/news/version_1_57_0) | +| Review Wizard Status Report | | Ronald Garcia | August 30, 2014 | [Report](https://lists.boost.org/boost-announce/2014/08/0414.php) | +| Variadic Macro Data | Edward Diener | Steven Watanabe | August 21, 2014 - August 30, 2014 | ~~[Pending](https://lists.boost.org/boost-announce/2014/08/0413.php)~~ +[Accepted -- Added in 1.60](https://lists.boost.org/boost-announce/2015/02/0432.php) | +| Boost 1.56.0 Released | | Marshall Clow | August 7, 2014 | [Notes](https://www.boost.org/users/news/version_1_56_0) | +| Convert | Vladimir Batov | Edward Diener | May 12, 2014 - May 25, 2014 | ~~[Pending](https://lists.boost.org/boost-announce/2014/05/0403.php)~~ +[Accepted](https://lists.boost.org/boost-announce/2014/06/0406.php) | +| TypeIndex Mini-Review | Antony Polukhin | Niall Douglas | April 21, 2014 - April 30, 2014 | ~~[Pending](https://lists.boost.org/boost-announce/2014/04/0399.php)~~ +[Accepted + -- Added in 1.56](https://lists.boost.org/boost-announce/2014/05/0402.php) | +| Align | Glen Fernandes | Ahmed Charles | April 11, 2014 - April 20, 2014 | ~~[Pending](https://lists.boost.org/boost-announce/2014/04/0398.php)~~ +[Accepted + -- Added in 1.56](https://lists.boost.org/boost-announce/2014/04/0400.php) | +| Fiber | Oliver Kowalke | Nat Goodspeed | January 6, 2014 - January 15, 2014 | ~~[Pending](https://lists.boost.org/boost-announce/2014/01/0392.php)~~ +[Conditionally + Accepted](https://lists.boost.org/boost-announce/2014/01/0393.php) | +| TypeIndex | Antony Polukhin | Niall Douglas | November 11, 2013 - November 20, 2013 | ~~[Conditionally + Accepted](https://lists.boost.org/boost-announce/2013/11/0389.php)~~ | +| Boost 1.55.0 Released | | Marshall Clow | November 11, 2013 | [Notes](https://www.boost.org/users/news/version_1_55_0) | +| Boost 1.54.0 Released | | Marshall Clow | July 1, 2013 | [Notes](https://www.boost.org/users/news/version_1_54_0) | +| Review Wizard Status Report | | Ronald Garcia | March 14, 2013 | [Report](https://lists.boost.org/boost-announce/2013/03/0378.php) | +| Boost 1.53.0 Released | | Marshall Clow | February 4, 2013 | [Notes](https://www.boost.org/users/news/version_1_53_0) | +| Review Wizard Status Report | | Ronald Garcia | November 10, 2012 | [Report](https://lists.boost.org/boost-announce/2012/11/0374.php) | +| Boost 1.52.0 Released | | Marshall Clow | October 5, 2012 | [Notes](https://www.boost.org/users/news/version_1_52_0) | +| Review Wizard Status Report | | Ronald Garcia | September 27, 2012 | [Report](https://lists.boost.org/boost-announce/2012/09/0370.php) | +| ODEint | Karsten Ahnert and + Mario Mulansky | Steven Watanabe | September 19, 2012 - September 28, 2012 | ~~[Pending](https://lists.boost.org/boost-announce/2012/09/0369.php)~~ +[Accepted + -- Added in 1.53](https://lists.boost.org/boost-announce/2012/10/0371.php) | +| Coroutine | Oliver Kowalke | Hartmut Kaiser | September 3, 2012 - September 12, 2012 | ~~[Pending](https://lists.boost.org/boost-announce/2012/09/0366.php)~~ +[Accepted + -- Added in 1.53](https://lists.boost.org/boost-announce/2012/11/0375.php) | +| Contract | Lorenzo Caminiti | Dave Abrahams | August 22, 2012 - August 31, 2012 | ~~[Pending](https://lists.boost.org/boost-announce/2012/08/0362.php)~~ +[Accepted -- Added in 1.67](https://lists.boost.org/boost-announce/2012/09/0368.php) | +| Boost 1.51.0 Released | | Marshall Clow | August 20, 2012 | [Notes](https://www.boost.org/users/news/version_1_51_0) | +| Review Wizard Status Report | | Ronald Garcia | August 15, 2012 | [Report](https://lists.boost.org/boost-announce/2012/08/0360.php) | +| Type Erasure | Steven Watanabe | Lorenzo Caminiti | July 18, 2012 - July 27, 2012 | ~~[Pending](https://lists.boost.org/boost-announce/2012/07/0357.php)~~ +[Accepted + -- Added in 1.54](https://lists.boost.org/boost-announce/2012/08/0364.php) | +| Review Wizard Status Report | | Ronald Garcia | July 13, 2012 | [Report](https://lists.boost.org/boost-announce/2012/07/0355.php) | +| Boost 1.50.0 Released | | Beman Dawes | June 28, 2012 | [Notes](https://www.boost.org/users/news/version_1_50_0) | +| Multiprecision Arithmetic | John Maddock | Jeffrey Hellrung | June 8, 2012 - June 17, 2012 | ~~[Pending](https://lists.boost.org/boost-announce/2012/06/0353.php)~~ +[Accepted + -- Added in 1.53](https://lists.boost.org/boost-announce/2012/08/0359.php) | +| Boost 1.49.0 Released | | Beman Dawes | February 24, 2012 | [Notes](https://www.boost.org/users/news/version_1_49_0) | +| Predef | Rene Rivera | Joel Falcou | February 20, 2012 - February 29, 2012 | ~~[Pending](https://lists.boost.org/boost-announce/2012/02/0349.php)~~ +[Accepted + -- Added in 1.55](https://lists.boost.org/boost-announce/2013/04/0379.php) | +| Review Wizard Status Report | | Ronald Garcia | January 10, 2012 | [Report](https://lists.boost.org/boost-announce/2012/01/0344.php) | +| Context (mini-review) | Oliver Kowalke | Giovanni Deretta | January 2, 2012 - January 11, 2012 | ~~[Pending](https://lists.boost.org/boost-announce/2012/01/0343.php)~~ +[Accepted + -- Added in 1.51.0](https://lists.boost.org/boost-announce/2012/01/0348.php) | +| Boost 1.48.0 Released | | Beman Dawes | November 16, 2011 | [Notes](https://www.boost.org/users/news/version_1_48_0) | +| Local | Lorenzo Caminiti | Jeffrey Hellrung | November 10, 2011 - November 19, 2011 | ~~[Pending](https://lists.boost.org/boost-announce/2011/11/0338.php)~~ +[Accepted + -- Added in 1.50](https://lists.boost.org/boost-announce/2011/12/0340.php) | +| Atomic | Helge Bahmann | Tim Blechmann | October 17, 2011 - October 26, 2011 | [Accepted + -- Added in 1.53](https://lists.boost.org/boost-announce/2011/11/0337.php) | +| Algorithm | Marshall Clow | Dave Abrahams | September 22, 2011 - October 1, 2011 | ~~[Pending](https://lists.boost.org/boost-announce/2011/09/0333.php)~~ +[Accepted + -- Added in 1.50](https://lists.boost.org/boost-announce/2011/12/0341.php) | +| Endian | Beman Dawes | Joel Falcou | September 5, 2011 - September 14, 2011 | [Conditionally + Accepted](https://lists.boost.org/boost-announce/2011/11/0336.php) | +| Conversion | Vicente Botet | Gordon Woodhull | August 20, 2011 - August 29, 2011 | ~~[Pending](https://lists.boost.org/boost-announce/2011/08/0330.php)~~ +[Rejected](https://lists.boost.org/boost-announce/2012/07/0356.php) | +| Containers | Ion Gaztañaga | John Maddock | August 3, 2011 - August 12, 2011 | ~~[Pending](https://lists.boost.org/boost-announce/2011/08/0329.php)~~ +[Accepted -- Added in 1.48.0](https://lists.boost.org/Archives/boost/2011/08/184936.php) | +| Lockfree | Tim Blechmann | Hartmut Kaiser | July 18, 2011 - July 27, 2011 | [~~Pending~~](https://lists.boost.org/boost-announce/2011/07/0324.php) +[Accepted + -- Added in 1.53](https://lists.boost.org/boost-announce/2011/08/0331.php) | +| Boost 1.47.0 Released | | Beman Dawes | July 12, 2011 | [Notes](https://www.boost.org/users/news/version_1_47_0) | +| Type Traits Introspection | Edward Diener | Joel Falcou | July 1, 2011 - July 10, 2011 | ~~[Pending](https://lists.boost.org/boost-announce/2011/06/0320.php)~~ +~~[Pending](https://lists.boost.org/boost-announce/2011/07/0322.php)~~ +[Accepted + -- Added in 1.54](https://lists.boost.org/boost-announce/2011/08/0328.php) | +| Assign v2 | Erwann Rogard, + Thorsten Ottosen | John Bytheway | June 15, 2011 - June 24, 2011 | ~~[Pending](https://lists.boost.org/boost-announce/2011/06/0315.php)~~ +~~[Pending](https://lists.boost.org/boost-announce/2011/06/0319.php)~~ +[Rejected](https://lists.boost.org/boost-announce/2011/07/0321.php) | +| Heaps | Tim Blechmann | Andrew Sutton | May 30, 2011 - June 8, 2011 | ~~[Pending](https://lists.boost.org/boost-announce/2011/05/0314.php)~~ +[Accepted + -- Added in 1.49](https://lists.boost.org/boost-announce/2011/06/0316.php) | +| Review Wizard Status Report | | Ronald Garcia | May 23, 2011 | [Report](https://lists.boost.org/boost-announce/2011/05/0311.php) | +| AutoIndex (Tool) | John Maddock | Daniel James | May 5, 2011 - May 14, 2011 | ~~[Pending](https://lists.boost.org/boost-announce/2011/05/0308.php)~~ +[Accepted + -- Added in 1.48.0](https://lists.boost.org/boost-announce/2011/05/0312.php) | +| Convert | Vladimir Batov | Edward Diener | April 23, 2011 - May 2, 2011- | ~~[Pending](https://lists.boost.org/boost-announce/2011/04/0302.php)~~ +[Withdrawn](https://lists.boost.org/boost-announce/2011/05/0307.php) +[(Report)](https://lists.boost.org/boost-announce/2011/05/0309.php) | +| Locale | Artyom Beilis | Chad Nelson | April 7, 2011 - April 16, 2011 | ~~[Pending](https://lists.boost.org/boost-announce/2011/04/0298.php)~~ +~~[Pending](https://lists.boost.org/boost-announce/2011/04/0303.php)~~ +[Accepted + -- Added in 1.48.0](https://lists.boost.org/boost-announce/2011/04/0304.php) | +| Context | Oliver Kowalke | Vicente Botet | March 21, 2011 - March 30, 2011 | ~~[Pending](https://lists.boost.org/boost-announce/2011/03/0296.php)~~ +~~[Accepted + Provisionally](https://lists.boost.org/boost-announce/2011/05/0310.php)~~ +[Accepted + -- Added in 1.51.0](https://lists.boost.org/boost-announce/2012/01/0348.php) | +| Type Traits Extensions (Fast-Track) | Frédéric Bron | Joel Falcou | March 14, 2011 - March 18, 2011 | [Accepted + -- Added in 1.48.0](https://lists.boost.org/boost-announce/2011/03/0297.php) | +| Boost 1.46.1 Released | | Beman Dawes | March 21, 2011 | [Notes](https://www.boost.org/users/news/version_1_46_1) | +| Review Wizard Status Report | | Ronald Garcia | March 4, 2011 | [Report](https://lists.boost.org/boost-announce/2011/03/0289.php) | +| XInt | Chad Nelson | Vladimir Prus | March 2, 2011 - March 12, 2011 | ~~[Pending](https://lists.boost.org/boost-announce/2011/03/0288.php)~~ +[Rejected](https://lists.boost.org/boost-announce/2011/04/0305.php) | +| Boost 1.46 Released | | Beman Dawes | February 21, 2011 | [Notes](https://www.boost.org/users/news/version_1_46_0) | +| Phoenix (mini-review) | Joel de Guzmann | Hartmut Kaiser | February 20, 2011 - March 2, 2011 | [Accepted + -- Added in 1.47.0](https://lists.boost.org/boost-announce/2011/03/0291.php) | +| Process | Boris Schaeling | Marshall Clow | February 7. 2011 - February 16, 2011 | [Rejected](https://lists.boost.org/boost-announce/2011/03/0292.php) | +| GIL.IO | Christian Henning | Mateusz Loskot | December 1, 2010 - December 10, 2010 | [Accepted + -- Added in 1.68.0](https://lists.boost.org/boost-announce/2011/01/0281.php) | +| Boost 1.45 Released | | Beman Dawes | November 20, 2010 | [Notes](https://lists.boost.org/boost-announce/2010/11/0272.php) | +| Chrono | Vicente Botet | Anthony Williams | November 6, 2010 - November 15, 2010 | [Accepted + -- Added in 1.47.0](https://lists.boost.org/boost-announce/2011/01/0280.php) | +| Ratio | Vicente Botet | Anthony Williams | October 2, 2010 - October 11, 2010 | [Accepted + -- Added in 1.47.0](https://lists.boost.org/boost-announce/2010/10/0270.php) | +| Boost 1.44 Released | | Beman Dawes | August 17, 2010 | [Notes](https://lists.boost.org/boost-announce/2010/08/0264.php) | +| Boost.Assign Extensions (Mini-Review) | Erwann Rogard | Thorsten Ottosen | June 13, 2010 - June 19, 2010 | [Rejected](https://lists.boost.org/boost-announce/2010/10/0269.php) | +| Review Wizard Status Report | | Ronald Garcia | May 26, 2010 | [Report](https://lists.boost.org/boost-announce/2010/05/0262.php) | +| Move | Ion Gaztañaga | ~~OvermindDL1~~ + Michael Caisse + | May 10, 2010 - May 24, 2010 | [Accepted + -- Added in 1.48.0](https://lists.boost.org/boost-announce/2011/02/0283.php) | +| Boost 1.43 Released | | Beman Dawes | May 6, 2010 | [Notes](https://lists.boost.org/boost-announce/2010/05/0258.php) | +| Log | Andrey Semashev | Vladimir Prus | March 8, 2010 - March 17, 2010 | ~~[Accepted + Provisionally](https://lists.boost.org/boost-announce/2010/03/0256.php)~~ + Accepted -- Added in 1.54 + | +| Interval Containers | Joachim Faulhaber | Hartmut Kaiser | February 18, 2010 - February 27, 2010 | [Accepted + -- Added in 1.46](https://lists.boost.org/boost-announce/2010/04/0257.php) | +| Boost 1.42 Released | | Beman Dawes | February 2, 2010 | [Notes](https://lists.boost.org/boost-announce/2010/02/0250.php) | +| Review Wizard Status Report | | John Phillips | December 7, 2009 | [Report](../development/report-dec-2009.html) | +| Meta State Machine (MSM) | Christophe Henry | Dave Abrahams | November 23, 2009 - December 13, 2009 | [Accepted -- Added in 1.44](https://lists.boost.org/Archives/boost/2010/01/160812.php) | +| Boost 1.41 Released | | Beman Dawes | November 18, 2009 | [Notes](https://lists.boost.org/boost-announce/2009/11/0241.php) | +| Geometry | Barend Gehrels, + Bruno Lalande, + and Mateusz Loskot | Hartmut Kaiser | November 5, 2009 - November 22, 2009 | [Accepted + -- Added in 1.47.0](https://lists.boost.org/boost-announce/2009/11/0245.php) | +| Boost 1.40 Released | | Beman Dawes | August 27, 2009 | [Notes](https://lists.boost.org/boost-announce/2009/08/0235.php) | +| Polygon | Lucanus Simonson | Fernando Cacciola | August 24, 2009 - September 2, 2009 | [Accepted + -- Added in 1.44](https://lists.boost.org/boost-announce/2009/11/0239.php) | +| Review Wizard Status Report | | Ronald Garcia | June 4, 2009 | [Report](../development/report-jun-2009.html) | +| Boost 1.39 Released | | Beman Dawes | May 3, 2009 | [Notes](https://lists.boost.org/boost-announce/2009/05/0232.php) | +| Polynomial | Paweł Kieliszczyk | John Maddock | March 10, 2009 - March 19, 2009 | [Rejected](https://lists.boost.org/boost-announce/2009/04/0228.php) | +| Boost.Range (Update) | Neil Groves | Thorsten Ottosen | February 20, 2009 - March 3, 2009 | [Accepted + -- Added in 1.43](https://lists.boost.org/boost-announce/2009/04/0231.php) | +| Boost 1.38 Released | | Beman Dawes | February 9, 2009 | [Notes](https://lists.boost.org/boost-announce/2009/02/0223.php) | +| Futures (2 candidates) | 1. Braddock Gaskill +2. Anthony Williams + | Tom Brinkman | January 5, 2009 - January 20, 2009 | [Williams + Accepted -- Added in 1.41 + Gaskill Rejected](https://lists.boost.org/boost-announce/2009/04/0229.php) | +| Constrained Value | Robert Kawulak | ~~Jeff Garland~~ + Gordon Woodhull + | December 1, 2008 - December 10, 2008 | ~~[Accepted](https://lists.boost.org/boost-announce/2010/09/0265.php)~~ + Orphaned + | +| Review Wizard Status Report | | John Phillips | November 25, 2008 | [Report](../development/report-nov-2008.html) | +| Globally Unique Identifier (mini-review) (now + UUID) | Andy Tompkins | Hartmut Kaiser | November 23, 2008 - November 29, 2008 | [Accepted + -- Added in 1.42](https://lists.boost.org/boost-announce/2009/01/0221.php) | +| Boost 1.37 Released | | Beman Dawes | November 3, 2008 | [Notes](https://lists.boost.org/boost-announce/2008/11/0209.php) | +| Thread-Safe Signals (now Signals2) | Frank Hess | Stjepan Rajko | November 1, 2008 - November 10, 2008 | [Accepted + -- Added in 1.39](https://lists.boost.org/boost-announce/2008/11/0211.php) | +| Phoenix | Joel de Guzman | Hartmut Kaiser | September 21, 2008 - September 30, 2008 | [~~Accepted Conditionally~~](https://lists.boost.org/boost-announce/2008/10/0205.php) +[~~Under Development~~](https://lists.boost.org/Archives/boost/2010/05/167128.php) +[Accepted + -- Added in 1.47.0](https://lists.boost.org/boost-announce/2011/03/0291.php) | +| DataFlow Signals | Stjepan Rajko | Jaakko Järvi | September 1, 2008 - September 10, 2008 | [Rejected](https://lists.boost.org/Archives/boost/2008/09/142198.php) | +| Boost 1.36 Released | | Beman Dawes | August 14, 2008 | [Notes](https://lists.boost.org/boost-announce/2008/08/0196.php) | +| Finite State Machines | Andrey Semashev | Martin Vuille | August 11, 2008 - August 27, 2008 | [Rejected](https://lists.boost.org/boost-announce/2008/09/0202.php) ([Notes](https://lists.boost.org/boost-announce/2008/09/0203.php)) + | +| Review Wizard Status Report | | John Phillips | 2008 May 16 | [Report](../development/report-may-2008.html) | +| Egg | Shunsuke Sogame | Dan Marsden | March 31, 2008 - April 13, 2008 | [Rejected](https://lists.boost.org/boost-announce/2008/05/0192.php) | +| Boost 1.35 Released | | Beman Dawes | March 29, 2007 | [Notes](https://lists.boost.org/boost-announce/2008/03/0183.php) | +| Proto | Eric Niebler | Hartmut Kaiser | March 1, 2008 - March 14, 2008 | [Accepted -- Added in 1.37](https://lists.boost.org/boost-announce/2008/04/0187.php) | +| Floating Point Utilities | Johan Råde | John Maddock | February 18, 2008 - February 27, 2008 | [Accepted -- Added in 1.??](https://lists.boost.org/boost-announce/2008/03/0179.php) | +| Logging | John Torjo | Gennadiy Rozental | February 4, 2008 - February 13, 2008 | [Rejected](https://lists.boost.org/boost-announce/2008/03/0181.php) | +| Flyweight | Joaquín Mª López Muñoz | Ion Gaztañaga | January 21, 2008 - January 30, 2008 | [Accepted -- Added in 1.38](https://lists.boost.org/boost-announce/2008/02/0174.php) | +| Singleton (fast-track) | Tobias Schwinger | John Torjo | January 14, 2008 - January 18, 2008 | [Rejected](https://lists.boost.org/boost-announce/2008/01/0171.php) | +| Switch | Steven Watanabe | Stejpan Rajko | January 5, 2008 - January 13, 2008 | ~~[Accepted Provisionally](https://lists.boost.org/boost-announce/2008/01/0166.php)~~ Orphaned + | +| Factory (fast-track) | Tobias Schwinger | John Torjo | December 17, 2007 - December 21, 2007 | [Accepted -- Added in 1.43](https://lists.boost.org/boost-announce/2007/12/0161.php) | +| Unordered Containers | Daniel James | Ion Gaztañaga | December 7, 2007 - December 16, 2007 | [Accepted -- Added in 1.36](https://lists.boost.org/boost-announce/2007/12/0158.php) | +| Forward (fast-track) | Tobias Schwinger | John Torjo | December 3, 2007 - December 7, 2007 | [Accepted -- Added in 1.43](https://lists.boost.org/boost-announce/2007/12/0153.php) | +| Review Wizard Status Report | | Ronald Garcia | 2007 November 16 | [Report](../development/report-nov-2007.html) | +| Exception | Emil Dotchevski | Tobias Schwinger | September 27, 2007 - October 7, 2007 | [Accepted + -- Added in 1.36](https://lists.boost.org/boost-users/2007/11/31912.php) | +| Review Wizard Status Report | | Ronald Garcia | 2007 September 14 | [Report](../development/report-sep-2007.html) | +| Scope Exit | Alexander Nasonov | ~~Jody Hagins~~ + John R. Phillips + | August 13, 2007 - August 22, 2007- | [Accepted -- Added in 1.38](https://lists.boost.org/boost-announce/2008/05/0190.php) | +| Time Series | Eric Niebler | John R. Phillips | July 30, 2007 - August 13, 2007 | [~~Accepted~~](https://lists.boost.org/boost-announce/2007/08/0142.php) +[Orphaned](https://lists.boost.org/Archives/boost/2010/05/167128.php) | +| Boost 1.34.1 Released | | Thomas Witt | July 24, 2007 | [Notes](https://lists.boost.org/boost-announce/2007/07/0135.php) | +| Boost 1.34.0 Released | | Thomas Witt | May 12, 2007 | [Notes](https://lists.boost.org/boost-announce/2007/05/0131.php) | +| Globally Unique Identifier | Andy Tompkins | Hartmut Kaiser | April 30, 2007 - May 10, 2007 | ~~[Accepted Provisionally](https://lists.boost.org/boost-announce/2007/05/0134.php)~~ +[Accepted -- Added in 1.42](https://lists.boost.org/boost-announce/2009/01/0221.php) | +| Math Toolkit | John Maddock | Matthias Schabel | April 11, 2007 - April 27, 2007 | [Accepted -- Added in 1.35](https://lists.boost.org/boost-announce/2007/05/0129.php) | +| Quantitative Units | Matthias Schabel | John R. Phillips | March 26, 2007 - April 4, 2007 | [Accepted -- Added in 1.36](https://lists.boost.org/boost-announce/2007/04/0126.php) | +| Intrusive Containers | Ion Gaztañaga | Joaquín Mª López Muñoz | March 12, 2007 - March 21, 2007 | [Accepted -- Added in 1.35](https://lists.boost.org/boost-announce/2007/04/0122.php) | +| Bimap | Matias Capeletto | Ion Gaztañaga | February 15 2007- March 2, 2007 | [Accepted -- Added in 1.35](https://lists.boost.org/Archives/boost/2007/03/117351.php) | +| Accumulators | Eric Niebler | John R. Phillips | January 29, 2007 - February 7, 2007 | [Accepted -- Added in 1.36](https://lists.boost.org/boost-announce/2007/02/0114.php) | +| Function Types (Re-review) | Tobias Schwinger | Tom Brinkman | 2006 November 6 - 2006 November 17 | [Accepted -- Added in 1.35](https://lists.boost.org/boost-announce/2006/11/0106.php) | +| Generic Image Library | Lubomir Bourdev | Tom Brinkman | 2006 October 5 - 2006 October 25 | [Accepted -- Added in 1.35](https://lists.boost.org/Archives/boost/2006/11/112896.php) | +| Message Passing | Doug Gregor | Jeremy Siek | 2006 September 6 - 2006 September 15 | [Accepted -- Added in 1.35](https://lists.boost.org/boost-announce/2006/09/0099.php) | +| Physical Quantities System | Andy Little | Fred Bertsch | 2006 May 31 - 2006 June 9 | [Rejected](https://lists.boost.org/boost-announce/2006/06/0096.php) | +| Pimpl Pointer | Asger Mangaard | Rene Rivera | 2006 May 15 - 2006 May 24 | [Rejected](https://lists.boost.org/boost-announce/2006/10/0104.php) | +| Fusion | Joel de Guzman | Ronald Garcia | 2006 May 1 - 2006 May 10 | [Accepted -- Added in 1.35](https://lists.boost.org/boost-announce/2006/06/0094.php) | +| Property Tree | Marcin Kalicinski | Thorsten Ottosen | 2006 April 18 - 2006 April 30 | [Accepted -- Added in 1.41](https://lists.boost.org/boost-announce/2006/05/0092.php) | +| Promotion Traits (fast-track) | Alexander Nasonov | Tobias Schwinger | 2006 April 1 - 2006 April 9 | [Accepted -- Added in 1.35](https://lists.boost.org/boost-announce/2006/04/0086.php) | +| Review Wizard Status Report | | Tom Brinkman | 2006 March 30 | [Report](../development/report-apr-2006.html) | +| Shmem (now Interprocess) | Ion Gaztañaga | Fred Bertsch | 2006 February 6 - 2006 February 15 | [Accepted -- Added in 1.35](https://lists.boost.org/boost-announce/2006/02/0083.php) | +| Fixed Strings | Reece Dunn | Harmut Kaiser | 2006 January 19 - 2006 February 5 | [Rejected](https://lists.boost.org/boost-announce/2006/02/0081.php) | +| Review Wizard Status Report | | Ronald Garcia | 2006 January 19 | [Report](../development/report-jan-2006.html) | +| asio | Christopher Kohlhoff | Jeff Garland | 2005 December 10 - + 2005 December 30 | [Accepted -- Added in 1.35](https://lists.boost.org/Archives/boost/2006/03/102287.php) | +| Boost 1.33.1 Released | | Doug Gregor | 2005 December 5 | [Notes](https://lists.boost.org/boost-announce/2005/12/0077.php) | +| Review Wizard Status Report | | Ronald Garcia | 2005 December 1 | [Report](https://lists.boost.org/boost-announce/2005/12/0076.php) | +| Logging Library | John Torjo | Hartmut Kaiser | 2005 November 7 - 2005 November 16th | [Rejected](https://lists.boost.org/boost-announce/2005/11/0075.php) | +| Boost 1.33.1 Beta Released | | Doug Gregor | 2005 November 9 | [Notes](https://lists.boost.org/boost-announce/2005/11/0073.php) | +| binary\_int | Scott Schurr and + Matt Calabrese | Pavel Vozenilek | 2005 October 13 - 2005 October 20 | [Accepted -- Added in 1.37.](https://lists.boost.org/boost-announce/2006/01/0078.php) | +| TR1 | John Maddock | Beman Dawes | 2005 September 24 - 2005 October 5 | Accepted -- Added in 1.34 | +| Xpressive | Eric Niebler | Thomas Witt | 2005 September 8 - 2005 September 18 | Accepted -- Added in 1.34 | +| Boost 1.33.0 Released | | Doug Gregor | 17 August 2005 | [Notes](https://lists.boost.org/boost-announce/2005/08/0067.php) | +| Function Types | Tobias Schwinger | John Maddock | 2005-Jun-6 to 2005-June-16 | ~~[Accepted Provisionally](https://lists.boost.org/boost-announce/2005/06/0066.php)~~, + [Accepted -- Added in 1.35](https://lists.boost.org/boost-announce/2006/11/0106.php) | +| Typeof | Arkadiy Vertleyb and + Peder Holt | Andy Little | 2005 May 20 - 2005 May 30 | Accepted -- Added in 1.34 | +| Singleton | Jason Hise | Pavel Vozenilek | 2005 May 5 - 2005 May 15 | [Rejected](https://lists.boost.org/boost-announce/2005/05/0062.php) | +| FOREACH Macro | Eric Niebler | Gennadiy Rozental | 2005 April 25 - 2005 May 1 | Accepted -- Added in 1.34 | +| Hash | Daniel James | Thorsten Ottosen | 2005 Mar 21 - 2005 March 12 | Accepted -- Added in 1.33 | +| State Chart | Andreas Huber | Pavel Vozenilek | 2005 Feb 23 - 2005 March 9 | Accepted -- Added in 1.34 | +| Wave | Hartmut Kaiser | Tom Brinkman | 2005 Feb 7 - 2005 Feb 20 | Accepted -- Added in 1.33 | +| Pointer Containers | Thorsten Ottosen | Pavol Droba | 2004 Sept 26 - Oct 5 | Accepted -- Added in 1.33 | +| Named Params | David Abrahams & + Daniel Wallin | Doug Gregor | 2004 Nov 1 - 2004 Nov 20 | Accepted -- Added in 1.33 | +| Output Formatters | Reece Dunn | John Torjo | 2004 Sept 11 - Sept 25 | [Rejected](https://lists.boost.org/Archives/boost/2004/10/74535.php) | +| Iostreams | Jonathan Turkanis | Jeff Garland | 2004 Aug 28 - Sep 11 | Accepted -- Added in 1.33 | +| More IO | Daryle Walker | Tom Brinkman | 2004 Aug 21 - 28 | Rejected | +| Tribool | Douglas Gregor | Thomas Witt | 2004 May 19-29 | Accepted -- Added in 1.32 | +| Assignment | Thorsten Ottosen | Tom Brinkman | 2004 Apr 1 - 11 | Accepted -- Added in 1.32 | +| Serialization (re-review) | Robert Ramey | Jeff Garland | 2004 Apr 13 - 26 | Accepted -- Added in 1.32 | +| Container Traits (now Range) | Thorsten Ottosen | Hartmut Kaiser | 2004 Apr 28 - May 7 | Accepted -- Added in 1.32 | +| Indexed Set (now MultiIndex) | Joaquín Mª López Muñoz | Pavel Vozenilek | 2004 Mar 20 - 30 | [Accepted -- Added in 1.32](https://lists.boost.org/Archives/boost/2004/04/63582.php) | +| Circular Buffer | Jan Gaspar | Pavel Vozenilek | 2004 Mar 5 - 15 | Accepted -- Added in 1.35 | +| enable\_if | Jaakko Järvi & + Jeremiah Willcock & + Andrew Lumsdaine | (fasttrack) | Dec 2003 | Accepted -- added in 1.31 | +| FC++ | Brian McNamara & Yannis Smaragdakis | Mat Marcus | 2004 Feb 14 - Mar 1 | Rejected | +| Numeric Conversions Library | Fernando Cacciola | Thorsten Ottosen | 8 - 22 Dec 2003 | Accepted -- added in 1.32 | +| String Algorithm Library | Pavol Droba | Thorsten Ottosen | 17 - 30 Oct 2003 | Accepted -- added in 1.32 | +| Shifted Pointer | Philippe A. Bouchard | Doug Gregor | 24 - 30 Sep 2003 | Rejected | +| Fixed-Point Decimal | Bill Seymour | Jens Maurer | 11 - 21 Jul 2003 | Rejected | +| Math Constants | Paul A. Bristow | Jaap Suter | 06 - 15 Jun 2003 | Rejected | +| Command Line & Config | Vladimir Prus | Aleksey Gurtovoy | 21 May - 03 Jun 2003 | Accepted -- added in 1.32 | +| I/O Manipulators and Adaptors | Daryle Walker | Ed Brey | 27 Feb - 11 Mar 2003 | - | +| Variant | Eric Friedman & Itay Maman | Jeff Garland | 16 - 25 Feb 2003 | Accepted -- added in 1.31 | +| Optional | Fernando Cacciola | Douglas Gregor | 09 - 18 Dec 2002 | Accepted -- added in 1.30 | +| Serialization | Robert Ramey | Dave Abrahams | 02 - 11 Nov 2002 | Rejected | +| Spirit | Joel de Guzman | John Maddock | 11 - 20 Oct 2002 | Accepted -- added in 1.30 | +| Minmax | Hervé Bronnimann | Thomas Witt | 28 Sep - 07 Oct 2002 | Accepted -- added in 1.32 | +| Filesystem | Beman Dawes | William Kempf | 14 - 23 Sep 2002 | Accepted -- added in 1.30 | +| Interval Arithmetic Library | Hervé Bronnimann & + Guillaume Melquiond & + Sylvain Pion | Beman Dawes | 31 Aug - 09 Sep 2002 | Accepted -- added in 1.30 | +| Template Meta Programming Library MPL | Aleksey Gurtovoy | Douglas Gregor | 15 - 29 Jul 2002 | Accepted -- added in 1.30 | +| uBLAS | Joerg Walter & Mathias Koch | Ed Brey | 21 Jun - 01 Jul 2002 | Accepted -- added in 1.29 | +| Dynamic Bitset | Chuck Alison & Jeremy Siek | Mat Marcus | 08 - 17 Jun 2002 | Accepted -- added in 1.29 | +| Date / Time | Jeff Garland | Darin Adler | 15 - 24 Apr 2002 | Accepted -- added in 1.29 | +| Lambda | Jaakko Järvi & Gary Powell | Aleksey Gurtovoy | 08 - 20 Mar 2002 | Accepted and added | +| Signals | Douglas Gregor | William Kempf | 18 - 27 Feb 2002 | Accepted -- added in 1.29 | +| I/O State Saver | Daryle Walker | Beman Dawes | 06 - 16 Feb 2002 | Accepted and added | +| printf-like formatting for iostreams | Samuel Krempp | Jens Maurer | 13 - 23 Jan 2002 | Accepted -- added in 1.29 | +| Multi-array | Ron Garcia | John Maddock | 02 - 12 Jan 2002 | Accepted -- added in 1.29 | +| Unit Test Library | Gennadiy Rozental | Jeremy Siek | 01 - 13 Dec 2001 | Accepted and added | +| GCD Library plus integer additions | Daryle Walker | Dave Abrahams | 17 - 26 Sep 2001 | - | +| Thread Library | Bill Kempf | Ed Brey | Aug 30 - Sep 8 | Accepted and added | +| Config System | John Maddock | Doug Gregor | Aug 20 - 29 | Accepted and added | +| Bind Library | Peter Dimov | Darin Adler | Aug 10 - 19 | Accepted and added | +| Base from Member Library | Daryle Walker | Beman Dawes | Jul 30 - Aug 9 | - | +| Coding Guidelines | Dave Abrahams | Aleksey Gurtovoy | Jul 20 - 29 | - | +| Preprocessor Library | Vesa Karvonen | Jeremy Siek | Jun 28 - Jul 9 | Accepted and added | +| Tuples Library | Jaakko Järvi | Beman Dawes | Jun 17 - 26 | Accepted and added | +| Function Library | Doug Gregor | John Maddock | Jun 6 - 16 | Accepted and added | +| Tokenizer | John Bandela | Doug Gregor | May 28 - Jun 6 | Accepted and added | +| Special Functions | Hubert Holin | Jens Maurer | May 18 - 27 | Accepted and added | + +Review Managers +--------------- + + +In order for a review to proceed, a Boost member must + volunteer to manage the review. This should be someone with + experience with the review process and knowledge of the + library's domain. If you would like to volunteer to become a + review manager, please contact Mateusz Loskot + (mateusz at loskot dot net) or John Phillips + (johnphillipsithaca at gmail dot com). + + + + + + + + + diff --git a/community/reviews.html b/community/reviews.html new file mode 100644 index 0000000..97b9b70 --- /dev/null +++ b/community/reviews.html @@ -0,0 +1,373 @@ +--- +title: Boost Formal Review Process +copyright: Beman Dawes, 2000. +revised: +--- + + +Boost Formal Review Process + + + +Boost Formal Review Process +=========================== + +Before Requesting a Formal Review +--------------------------------- + + +**Read and follow the Boost [submission + process](/development/submissions.html).** There are several steps a library author + must take before a formal review is requested. + +* [Introduction](#Introduction) +* [What to include in Review Comments](#Comments) +* [Results](#Results) +* [Notes for Review Managers](#Review_Manager) +* [Notes for Library Submitters](#Submitters) +* [Library Maintainer's Rights and + Responsibilities](#Maintainer) +* [Review Wizard](#Wizard) +* [Fast Track Reviews](#Fast-Track) + + +Introduction +------------ + + +Proposed libraries are accepted into Boost only after + undergoing a formal review, where Boost mailing list members + comment on their evaluation of the library. + + +The final "accept" or "reject" decision is made by the + [Review Manager](#Review_Manager), based on the + review comments received from boost mailing list members. + + +Boost mailing list members are encouraged to submit Formal + Review comments: + + +* Publicly on the mailing list. +* Privately to the Review Manager. + + +Private comments to a library submitter may be helpful to + her or him, but won't help the Review Manager reach a decision, + so the other forms are preferred. + + +The review period will normally last for 10 days. + + +What to include in + Review Comments +----------------------------------- + + +Your comments may be brief or lengthy, but the + Review Manager needs your evaluation of the library. If you + identify problems along the way, please note if they are minor, + serious, or showstoppers. + + +The goal of a Boost library review is to improve the library + through constructive criticism, and at the end a decision must + be made: is the library good enough at this point to accept + into Boost? If not, we hope to have provided enough + constructive criticism for it to be improved and accepted at a + later time. The Serialization library is a good example of how + constructive criticism resulted in revisions resulting in an + excellent library that was accepted in its second review. + + +Here are some questions you might want to answer in your + review: + + +* What is your evaluation of the design? +* What is your evaluation of the implementation? +* What is your evaluation of the documentation? +* What is your evaluation of the potential usefulness of + the library? +* Did you try to use the library? With what compiler? Did + you have any problems? +* How much effort did you put into your evaluation? A + glance? A quick reading? In-depth study? +* Are you knowledgeable about the problem domain? + + +And finally, every review should answer this question: + + +* Do you think the library should be accepted as a Boost + library? Be sure to say this explicitly so that your other + comments don't obscure your overall opinion. + + +Many reviews include questions for library authors. Authors + are interested in defending their library against your + criticisms; otherwise, they would not have brought their library + up for review. If you don't get a response to your question + quickly, be patient; if it takes too long or you don't get an + answer you feel is sufficient, ask again or try to rephrase the + question. Do remember that English is not the native language + for many Boosters, and that can cause misunderstandings. + + +E-mail is a poor communication medium, and even if messages + rarely get lost in transmission, they often get drowned in the + deluge of other messages. Don't assume that an unanswered + message means you're being ignored. Given constructively, + criticism will be taken better and have more positive effects, + and you'll get the answers you want. + + +Results +------- + + +Within a reasonable time after the conclusion of the comment + period, the Review Manager will post a message to the mailing + list saying if the library has been accepted or rejected. A + rationale is also helpful, but its extent is up to the Review + Manager. If there are suggestions, or conditions that must be + met before final inclusion, they should be stated. Concerns + about the timeliness or quality of the review report should be + brought to the Review Wizards off-list. + + +Notes for + Review Managers +-------------------------- + + +Before a library can be scheduled for formal review, an + active boost member not connected with the library submission + must volunteer to be the "Review Manager" for the library. + Members may contact a library author on- or off-list to express + interest in managing the review. The library author has to accept + a person as a review manager. + + +The Review Manager: + + +* Checks the submission to make sure it really is complete + enough to warrant formal review. See the [Boost Library Requirements + and Guidelines](/development/requirements.html). If necessary, work with the submitter to + verify the code compiles and runs correctly on several + compilers and platforms. +* Finalizes the schedule with the Review Wizard and the submitter. +* Posts a notice of the review schedule on both the regular + **[boost mailing list](mailto:boost@lists.boost.org)** and the + **[boost-announce](mailto:boost-announce@lists.boost.org) mailing list**. + + The notice should include a brief description of the + library and what it does, to let readers know if the + library is one they are interested in reviewing. + + If the library is known to fail with certain + compilers, please mention them in the review notice so + reviewers with those compilers won't waste time + diagnosing known problems. + + It is advised to send the notice to each mailing list + in a separate e-mail, otherwise online e-mail to news + gateways could get confused. +* Inspects the Boost [library catalogue](/doc/libs/release/libs/libraries.htm) + for libraries which may interact with the new submission. + These potential interactions should be pointed out in the + review announcement, and the author(s) of these libraries + should be privately notified and urged to participate in the + review. +* Urges people to do reviews if they aren't forthcoming. +* Follows review discussions regarding the library, + moderating or answering questions as needed. +* Asks the [review wizard](#Wizard) for + permission to extend the review schedule if it appears that + too few reviews will be submitted during the review period. +* Decides if there is consensus to accept the library and + if there are any conditions attached. Consensus is not the + same as a vote. The Review Manager has discretion to weigh + opinions based on authority or thoughtfulness. +* Posts a notice of the [review + results](#Results) on the regular **[boost](mailto:boost@lists.boost.org)** mailing + list, the **[boost-users](mailto:boost-users@lists.boost.org)** + mailing list, and the **[boost-announce](mailto:boost-announce@lists.boost.org)** + mailing list. + + +In other words, it is the Review Manager's responsibility to + make sure the review process works smoothly. + + +Although the review manager is also allowed to review the library, + they are expected to serve the interests of the Boost users. + Since the review manager may have a (strong) opinion about the library, + it is recommended as a matter of principle they do not share their opinion + until the very end of the review. Possibly, until the summary of reviews. + The review manager will make the final choice and announcing an opinion early + in the process could negatively affect the review process. + + +Notes for Library + Submitters +----------------------------- + + +See [Submission + Process](/development/submissions.html) for a description of the steps a library developer + goes through to get a library accepted by Boost. + + +First, the library author should accept a review manager. + If they feel, for whatever reason, a candidate for a review manager + is not competent or fair, they should not accept such candidate. + + +A proposed library should remain stable during the review + period; it will just confuse and irritate reviewers if there + are numerous changes. It is, however, useful to upload fixes + for serious bugs right away, particularly those which prevent + reviewers from fully evaluating the library. Post a notice of + such fixes on the mailing list. + + +Library improvements suggested by reviewers should normally + be held until after the completion of review period. If the + suggested changes might affect the reviewer's judgments, post a + notice of the pending change on the mailing list. + + +Library + Maintainer's Rights and Responsibilities +------------------------------------------------- + + +By submitting a library to boost, you accept responsibility + for maintaining your library or finding a qualified volunteer + to serve as maintainer. You must be willing to put your library + and documentation under a Boost-compatible license. + + +You will be expected to respond to reasonable bug reports + and questions on time and to participate as needed + in discussions of your library on the boost mailing lists. + + +You are free to change your library in any way you wish, and + you are encouraged to actively make improvements. However, peer + review is an important part of the Boost process and as such + you are also encouraged to get feedback from the boost + community before making substantial changes to the interface of + an accepted library. + + +If at some point you no longer wish to serve as maintainer + of your library, it is your responsibility to make this known + to the boost community and to find another individual to take + your place. + + +Libraries which have been abandoned will be put in care of + the [Community + Maintenance Team](https://svn.boost.org/trac/boost/wiki/CommunityMaintenance). + + +Review Wizards +-------------- + + +The Review Wizards coordinate the formal review + schedule: + + +* When a formal review is requested for a library: + + Approve the review manager based on initial acceptance + by the library submitter, their participation in the Boost + community, including the mailing list, previous reviews, + and other forums. + + Suggest a schedule, after checking (via private + email) the availability of the review manager and library + author. + + Finalize the schedule, once the review manager + verifies the library is ready for review. + + Resolve schedule slips or other issues with review + managers and submitters. +* Maintains a schedule of both past and pending reviews, in + the form of the [Review + Schedule](review_schedule.html) web page. +* Resolves questions from review managers and library + submitters, who sometimes want a third opinion on questions + such as "Should we extend the review period because + ...?" +* Monitors the general review process, and makes minor + adjustments as needed, or queries the list about possible + major adjustments. + + +The role of Boost Review Wizard is currently played by: + + +* Mateusz Loskot (mateusz at loskot dot net) +* John Phillips (johnphillipsithaca at gmail dot com) + + +Past Review Wizards (we thank you for your service): + + +* Ronald Garcia +* Tom Brinkman +* Thomas Witt + + +Fast Track + Reviews +------------------- + + +To qualify for fast track review: + + +* The component must be small. +* The technique must be already in use in Boost libraries + and the new component provides a common implementation. +* A full Boost-conformant implementation is available in + the sandbox. +* The Review Wizard determines that the proposal qualifies + for fast track review. + + +Procedure: + + +* The Boost Review Wizard posts a review announcement to + the main Boost developer's list. The fast track review period will + normally last for 5 days. No two fast-track reviews will run + in parallel. Fast track reviews may run during full reviews, + though generally, this is to be avoided. +* After the review period ends, the submitter will post a + review summary containing proposed changes to the reviewed + implementation. +* The Review Wizard will accept or reject the proposed + library and proposed changes. +* After applying the proposed changes, the component is + checked into the repository like any other library. + + +Mini-Reviews +------------ + + +If a review results in conditions on acceptance, the review + manager may request a Mini-Review to determine if the + conditions have been met. The Mini-Review is usually conducted + by the same review manager. + + + + + + + + + diff --git a/community/sandbox.html b/community/sandbox.html new file mode 100644 index 0000000..2937ba5 --- /dev/null +++ b/community/sandbox.html @@ -0,0 +1,72 @@ +--- +title: Boost Sandbox +copyright: Rene Rivera 2007. +revised: +--- + + +Boost Sandbox + + + +Boost Sandbox +============= + +When boost was developed using subversion, the Boost Sandbox + contained unreviewed code that is intended to eventually become + a part of the Boost libraries. New libraries should be + developed separately as [git + modules](https://svn.boost.org/trac/boost/wiki/ModularBoost), and existing projects should be [moved to + GitHub](https://svn.boost.org/trac/boost/wiki/ExtractSandbox). The sandbox remains as a historical record. + + +Accessing the Boost Sandbox +--------------------------- + + +The Boost Sandbox lives at + within the old Boost Subversion repository. + + +Organization +------------ + + +Because there were typically many projects in the sandbox at + any one time (in various stages of development), the sandbox + should have been organized by project. Each project should have + had its own subdirectory inside sandbox. For example, + an XML library would reside in sandbox/xml. Inside + that project-specific subdirectory, the project would be + organized like any other Boost library, with a boost + subdirectory (for headers) and libs subdirectory (for + source code, build files, and documentation). Our hypothetical + XML project would likely have had the following structure: + + +* sandbox/xml/ + + boost/ - Contains xml.hpp, which + includes all of the headers from xml/ + - xml/ - Contains Boost.XML headers + + libs/ + - xml/ + * build/ - Contains Jamfiles + to build Boost.XML + * doc/ - Contains documentation for + Boost.XML + * src/ - Contains Boost.XML compiled + source files + + +Many existing projects in the sandbox didn't follow this + structure, opting to place headers in sandbox/boost + and supporting files in sandbox/libs. + + + + + + + + + diff --git a/development/_template_.html b/development/_template_.html new file mode 100644 index 0000000..3e170a2 --- /dev/null +++ b/development/_template_.html @@ -0,0 +1,24 @@ +--- +title: Boost C++ Libraries +copyright: Rene Rivera 2007. +revised: +--- + + +Boost C++ Libraries + + + +Boost C++ Libraries +=================== + +{stuff} + + + + + + + + + diff --git a/development/borland_cpp.html b/development/borland_cpp.html new file mode 100644 index 0000000..62d3c2b --- /dev/null +++ b/development/borland_cpp.html @@ -0,0 +1,405 @@ +--- +title: Portability Hints: Borland C++ 5.5.1 +copyright: +revised: 2007-10-22 22:55:52 +0100 +--- + + +Portability Hints: Borland C++ 5.5.1 + + + +Portability Hints: Borland C++ 5.5.1 +==================================== + +It is a general aim for boost libraries to be [portable](/development/requirements.html#Portability). The + primary means for achieving this goal is to adhere to ISO + Standard C++. However, ISO C++ is a broad and complex standard + and most compilers are not fully conformant to ISO C++ yet. In + order to achieve portability in the light of this restriction, + it seems advisable to get acquainted with those language + features that some compilers do not fully implement yet. + + +This page gives portability hints on some language features + of the Borland C++ version 5.5.1 compiler. Furthermore, the + appendix presents additional problems with Borland C++ version + 5.5. Borland C++ 5.5.1 is a freely available command-line + compiler for Win32 available at . + + +Each entry in the following list describes a particular + issue, complete with sample source code to demonstrate the + effect. Most sample code herein has been verified to compile + with gcc 2.95.2 and Comeau C++ 4.2.44. + + +Preprocessor symbol +------------------- + + +The preprocessor symbol `__BORLANDC__` is defined + for all Borland C++ compilers. Its value is the version number + of the compiler interpreted as a hexadecimal number. The + following table lists some known values. + +| Compiler | `__BORLANDC__` value | +| --- | --- | +| Borland C++ Builder 4 | 0x0540 | +| Borland C++ Builder 5 | 0x0550 | +| Borland C++ 5.5 | 0x0550 | +| Borland C++ 5.5.1 | 0x0551 | +| Borland C++ Builder 6 | 0x0560 | + + +Core Language +------------- + + +### [using-directive] Mixing `using`-declarations + and `using`-directives + + +Mixing `using`-directives (which refer to whole + namespaces) and namespace-level `using`-declarations + (which refer to individual identifiers within foreign + namespaces) causes ambiguities where there are none. The + following code fragment illustrates this: +``` + +namespace N { + int x(); +} + +using N::x; +using namespace N; + +int main() +{ + &x; // Ambiguous overload +} + +``` + +### [using template] `using`-declarations for class + templates + + +Identifiers for class templates can be used as arguments to + `using`-declarations as any other identifier. + However, the following code fails to compile with Borland + C++: +``` + +template +class X { }; + +namespace N +{ + // "cannot use template 'X' without specifying specialization parameters" + using ::X; +}; + +``` + +### [template const arg] Deduction of constant arguments to + function templates + + +Template function type deduction should omit top-level + constness. However, this code fragment instantiates "f(int)": +``` + +template +void f(T x) +{ + x = 1; // works + (void) &x; + T y = 17; + y = 20; // "Cannot modify a const object in function f(int)" + (void) &y; +} + +int main() +{ + const int i = 17; + f(i); +} + +``` + +### [function address] Resolving addresses of overloaded + functions + + +Addresses of overloaded functions are not in all contexts + properly resolved (std:13.4 [over.over]); here is a small + example: +``` + +template +void f( void(\*g)(Arg) ); + +void h(int); +void h(double); + +template +void h2(T); + +int main() +{ + void (\*p)(int) = h; // this works (std:13.4-1.1) + void (\*p2)(unsigned char) = h2; // this works as well (std:13.4-1.1) + f(h2); // this also works (std:13.4-1.3) + + // "Cannot generate template specialization from h(int)", + // "Could not find a match for f(void (\*)(int))" + f(h); // should work (std:13.4-1.3) + + f( (void(\*)(double))h); // C-style cast works (std:13.4-1.6 with 5.4) + + // "Overloaded 'h' ambiguous in this context" + f(static\_cast(h)); // should work (std:13.4-1.6 with 5.2.9) +} + +``` + +**Workaround:** Always use C-style casts when + determining addresses of (potentially) overloaded + functions. + + +### [string conversion] Converting `const char *` to + `std::string` + + +Implicitly converting `const char *` parameters + to `std::string` arguments fails if template + functions are explicitly instantiated (it works in the usual + cases, though): +``` + +#include + +template +void f(const std::string & s) +{} + +int main() +{ + f("hello"); // "Could not find a match for f(char \*)" +} + + +``` + +**Workaround:** Avoid explicit template + function instantiations (they have significant problems with + Microsoft Visual C++) and pass default-constructed unused dummy + arguments with the appropriate type. Alternatively, if you wish + to keep to the explicit instantiation, you could use an + explicit conversion to `std::string` or declare the + template function as taking a `const char *` + parameter. + + +### [template value defaults] Dependent default arguments for + template value parameters + + +Template value parameters which default to an expression + dependent on previous template parameters don't work: +``` + +template +struct A +{ + static const bool value = true; +}; + +// "Templates must be classes or functions", "Declaration syntax error" +template::value> +struct B {}; + +int main() +{ + B x; +} + + +``` + +**Workaround:** If the relevant non-type + template parameter is an implementation detail, use inheritance + and a fully qualified identifier (for example, + ::N::A::value). + + +### [function partial ordering] Partial ordering of function + templates + + +Partial ordering of function templates, as described in + std:14.5.5.2 [temp.func.order], does not work: +``` + +#include + +template struct A {}; + +template +void f(const A &) +{ + std::cout << "f(const A&)\n"; +} + +template +void f(T) +{ + std::cout << "f(T)\n"; +} + +int main() +{ + A a; + f(a); // output: f(T) (wrong) + f(1); // output: f(T) (correct) +} + +``` + +**Workaround:** Declare all such functions + uniformly as either taking a value or a reference + parameter. + + +### [instantiate memfun ptr] Instantiation with member function + pointer + + +When directly instantiating a template with some member + function pointer, which is itself dependent on some template + parameter, the compiler cannot cope: +``` + +template class C { }; +template +class A +{ + static const int v = C::value; +}; + +``` + +**Workaround:** Use an intermediate + `typedef`: +``` + +template class C { }; +template +class A +{ + typedef void (T::\*my\_type)(); + static const int v = C::value; +}; + +``` + +(Extracted from e-mail exchange of David Abrahams, Fernando + Cacciola, and Peter Dimov; not actually tested.) + + +Library +------- + + +### [cmath.abs] Function `double std::abs(double)` + missing + + +The function `double std::abs(double)` should be + defined (std:26.5-5 [lib.c.math]), but it is not: +``` + +#include + +int main() +{ + double (\*p)(double) = std::abs; // error +} + +``` + +Note that `int std::abs(int)` will be used + without warning if you write `std::abs(5.1)`. + + +Similar remarks apply to seemingly all of the other standard + math functions, where Borland C++ fails to provide + `float` and `long double` overloads. + + +**Workaround:** Use `std::fabs` + instead if type genericity is not required. + + +Appendix: Additional issues with Borland C++ version + 5.5 +--------------------------------------------------------- + + +These issues are documented mainly for historic reasons. If + you are still using Borland C++ version 5.5, you are strongly + encouraged to obtain an upgrade to version 5.5.1, which fixes + the issues described in this section. + + +### [inline friend] Inline friend functions in template + classes + + +If a friend function of some class has not been declared + before the friend function declaration, the function is + declared at the namespace scope surrounding the class + definition. Together with class templates and inline + definitions of friend functions, the code in the following + fragment should declare (and define) a non-template function + "bool N::f(int,int)", which is a friend of class + N::A. However, Borland C++ v5.5 expects the function + f to be declared beforehand: +``` + +namespace N { +template +class A +{ + // "f is not a member of 'N' in function main()" + friend bool f(T x, T y) { return x < y; } +}; +} + +int main() +{ + N::A a; +} + +``` + +This technique is extensively used in boost/operators.hpp. + Giving in to the wish of the compiler doesn't work in this + case, because then the "instantiate one template, get lots of + helper functions at namespace scope" approach doesn't work + anymore. Defining BOOST\_NO\_OPERATORS\_IN\_NAMESPACE (a define + BOOST\_NO\_INLINE\_FRIENDS\_IN\_CLASS\_TEMPLATES would match this + case better) works around this problem and leads to another + one, see [using-template]. + + + + + + +html) + + diff --git a/development/bugs.html b/development/bugs.html new file mode 100644 index 0000000..eb54030 --- /dev/null +++ b/development/bugs.html @@ -0,0 +1,50 @@ +--- +title: Bugs +copyright: +> Lorem ipsum dolor sit amet, consectetuer adipiscing elit. +> Duis ligula lorem, consequat eget, tristique nec, auctor +> quis, purus. Vivamus ut sem. Fusce aliquam nunc vitae purus. +> Aenean viverra malesuada libero. Fusce ac quam. Donec neque. +> Nunc venenatis enim nec quam. Cras faucibus, justo vel +> accumsan aliquam, tellus dui fringilla quam, in condimentum +> augue lorem non tellus. Pellentesque id arcu non sem placerat +> iaculis. Curabitur posuere, pede vitae lacinia accumsan, enim +> nibh elementum orci, ut volutpat eros sapien nec sapien. +> Suspendisse neque arcu, ultrices commodo, pellentesque sit +> amet, ultricies ut, ipsum. Mauris et eros eget erat dapibus +> mollis. Mauris laoreet posuere odio. Nam ipsum ligula, +> ullamcorper eu, fringilla at, lacinia ut, augue. Nullam +> nunc. +> +> +> + + +The Boost pages avoid the use of tables as a layout + mechanism. This helps, and hurts, in a variety of ways. The + most important benefit is the wider semantic access of the + content. It means that the largest set of browsers will + interpret tables as what they are; tabular content. The + following convenient sample comes from the helpful [HTML4 W3 standard](http://www.w3.org/TR/html4/struct/tables.html#h-11.5): + + + CODE-PAGE SUPPORT IN MICROSOFT WINDOWS + +| Code-Page ID | Name | ACP | OEMCP | Windows NT 3.1 | Windows NT 3.51 | Windows 95 | +| --- | --- | --- | --- | --- | --- | --- | +| 1200 | Unicode (BMP of ISO/IEC-10646) | | | X | X | \* | +| 1250 | Windows 3.1 Eastern European | X | | X | X | X | +| 1251 | Windows 3.1 Cyrillic | X | | X | X | X | +| 1252 | Windows 3.1 US (ANSI) | X | | X | X | X | +| 1253 | Windows 3.1 Greek | X | | X | X | X | +| 1254 | Windows 3.1 Turkish | X | | X | X | X | +| 1255 | Hebrew | X | | | | X | +| 1256 | Arabic | X | | | | X | +| 1257 | Baltic | X | | | | X | +| 1361 | Korean (Johab) | X | | | \*\* | X | +| 437 | MS-DOS United States | | X | X | X | X | +| 708 | Arabic (ASMO 708) | | X | | | X | +| 709 | Arabic (ASMO 449+, BCON V4) | | X | | | X | +| 710 | Arabic (Transparent Arabic) | | X | | | X | +| 720 | Arabic (Transparent ASMO) | | X | | | X | + + +###### Heading 6 + + +One of the most important elements of HTML is the hypertext + link. In the Boost pages all [links](/) are treated + in a similar, consistent, manner regardless of context as much + as possible. Stylistic variations are present to account for + color contrast differences in the context. For example the + links in the header, and footer use different colors to match + the text color and contrast as much as possible with the + respective backgrounds. Within section content, like here, the + links also provide differing look & feel based on wether + they target the [Boost web site](/), or some + [external web + site [class="external"]](http://www.google.com/). Since most of the time links are + internal, that is the default semantic. External links need to + be decorated with [class="external"]. + + +* One +--- + + +This a "directory" unordered list [ul + class="directory"]. It is styled to show a list of short + items in as compact a form as possible. Currently that + means the items are arrayed in two columns and items are + packed to read left-to-right and top-to-bottom. +* Two +--- + + +Even though this an unordered list, one can also arrange + any block elements in this way. The top container needs to + be a [class="directory"] and the interior items + [class="directory-item"]. + + +Unordered Lists [ul] +-------------------- + + +This type of list is one of the most commonly used + structural elements used. It's used for directory listing, + history listings, table of contests, and many more. The goal is + to classify the various lists by type with a + [class="type-here"] attribute on the list [ul]. Please resist + the urge to use a classification just because it has the + particular look you want. As at some future point the look will + change and you will have no say in the effect of the particular + context. + + +### Default [ul] + + +* Item 1 + + Subitem 1a + - Subitem 1a1 + - Subitem 1a2 + + Subitem 1b +* Item 2 + + Subitem 2a + + Subitem 2b + + +### Directory [ul class="directory"] + + +* Item 1 + + Subitem 1a + - Subitem 1a1 + - Subitem 1a2 + + Subitem 1b +* Item 2 + + Subitem 2a + + Subitem 2b + + +### Table of contents [ul class="toc"] + + +* [Item 1](#) + + [Subitem 1a](#) + + [Subitem 1b](#) +* [Item 2](#) + + [Subitem 2a](#) + + [Subitem 2b](#) + + +### History [ul class="history"] + + +* Item 1 + + Subitem 1a + + Subitem 1b +* Item 2 + + Subitem 2a + + Subitem 2b + + +### Menus [ul class="menu"] + + +* [Item 1](#) +* [Item 2](#) + + +### Tree [ul class="tree"] + + +* Item 1 + + Subitem 1a + - Subitem 1a1 + - Subitem 1a2 + + Subitem 1b +* Item 2 + + Subitem 2a + + Subitem 2b + + +Preformatted [pre] +------------------ + + +This is often used to show code examples, or more accurately + fixed examples. For example the [Boost Software License](/users/license.html): +``` +``` + + + + + + + + diff --git a/development/header.html b/development/header.html new file mode 100644 index 0000000..a1f67cc --- /dev/null +++ b/development/header.html @@ -0,0 +1,108 @@ +--- +title: Boost Header policy +copyright: Beman Dawes 1998. +revised: 2007-10-22 22:55:52 +0100 +--- + + +Boost Header policy + + + +Boost Header policy +=================== + +Header files are the place where a library comes into + contact with user code and other libraries. To co-exist + peacefully and productively, headers must be "good + neighbors". + + +Here are the standards for boost headers. Many of these are + also reasonable guidelines for general use. + + +* Header filenames should have a .hpp (lowercase) + extension. +* Unless multiple inclusion is intended, wrap the header in + #ifndef guards. Use a naming convention that minimizes the + chance of clashes with macro names from other's code. The + [sample header](#SampleHeader) uses the Boost + convention of all uppercase letters, with the header name + prefixed by the namespace name, and suffixed with HPP, + separated by underscores. +* Wrap the header contents in a namespace to prevent global + namespace pollution. The namespace approach to pollution + control is strongly preferred to older approaches such as + adding funny prefixes to global names. Libraries which are + designed to work well with other Boost libraries should be + placed in namespace boost. +* Make sure that a translation unit consisting of just the + contents of the header file will compile successfully. +* Place the header file in a sub-directory to prevent + conflict with identically named header files in other + libraries. The parent directory is added to the compiler's + include search path. Then both your code and user code + specifies the sub-directory in #include directives. + Thus the header [sample header](#SampleHeader) + would be included by #include + . (Note, including from current + file directory using #include "furball.hpp" syntax + is discouraged .) +* The preferred ordering for class definitions is public + members, protected members, and finally private members. +* Include the boost/config.hpp [configuration + header](/doc/libs/release/libs/config/config.htm) if there is a need to deal with compiler or + platform configuration issues. + + +Sample + Header +-------------- +``` + +// Boost general library furball.hpp header file ---------------------------// + + < *html) > + +// See https://www.boost.org/ for latest version. + +#ifndef BOOST\_FURBALL\_HPP +#define BOOST\_FURBALL\_HPP + +namespace boost { + +// Furball class declaration -----------------------------------------------// + + class furball + { + public: + void throw\_up(); + private: + int whatever; + }; // furball + +} // namespace + +#endif // include guard + +``` + +Coding Style +------------ + + +The alert reader will have noticed that the [sample header](#SampleHeader) employs a certain coding + style for indentation, positioning braces, commenting ending + braces, and similar formatting issues. These stylistic issues + are viewed as personal preferences and are not part of the + Boost Header Policy. + + + + + + + + + diff --git a/development/index.html b/development/index.html new file mode 100644 index 0000000..5551284 --- /dev/null +++ b/development/index.html @@ -0,0 +1,71 @@ +--- +title: Boost Development +copyright: Rene Rivera 2007. +revised: +--- + + +Boost Development + + +/\* div { + background: transparent !important; + } + #content .section .openhub table { + background: transparent !important; + clear: none !important; + border-spacing: 0em !important; + margin-bottom: 0.25em !important; + } + #content .section .openhub table tr td { + border: none !important; + } + #content .section #openhub-cost table tr td { + background: transparent !important; + border-bottom: 1px #DDD solid !important; + } + #content .section .openhub img { + border: none !important; + padding: 0em !important; + } + /\*]]>\*/ + + + +Development +=========== + +Boost sources are on + [GitHub](https://github.com/boostorg). + + +Boost developers constitute a wide array of people + throughout much of the world. Over the years much work has gone + into the quantity and quality of the C++ libraries and tools + that make up Boost. There are many ways to become part of the + Boost developer community, all starting with getting involved + in the development discussion. But if you are looking for an + "easy" place to get your feet wet is to volunteer [testing](testing.html) resources. The wonderful people at + [Black Duck + Open Hub](http://www.openhub.net/) provide a peek into what goes into Boost: + + +* +* + +Release Schedule +================ + +Below is a community maintained calendar of Boost related + events. The release managers try to keep the release related + portion of the calendar up to date. + + + + + + + + + diff --git a/development/int_const_guidelines.html b/development/int_const_guidelines.html new file mode 100644 index 0000000..bceb5d5 --- /dev/null +++ b/development/int_const_guidelines.html @@ -0,0 +1,423 @@ +--- +title: Coding Guidelines for Integral Constant Expressions +copyright: Dr John Maddock 2001. +revised: 2007-10-22 22:55:52 +0100 +--- + + +Coding Guidelines for Integral Constant Expressions + + + +Coding Guidelines for Integral Constant Expressions +=================================================== + +Integral Constant Expressions are used in many places in + C++; as array bounds, as bit-field lengths, as enumerator + initialisers, and as arguments to non-type template parameters. + However many compilers have problems handling integral constant + expressions; as a result of this, programming using non-type + template parameters in particular can be fraught with + difficulty, often leading to the incorrect assumption that + non-type template parameters are unsupported by a particular + compiler. This short article is designed to provide a set of + guidelines and workarounds that, if followed, will allow + integral constant expressions to be used in a manner portable + to all the compilers currently supported by boost. Although + this article is mainly targeted at boost library authors, it + may also be useful for users who want to understand why boost + code is written in a particular way, or who want to write + portable code themselves. + + +What is an Integral Constant Expression? +---------------------------------------- + + +Integral constant expressions are described in section 5.19 + of the standard, and are sometimes referred to as "compile time + constants". An integral constant expression can be one of the + following: + + +1. A literal integral value, for example `0u` or + `3L`. +2. An enumerator value. +3. Global integral constants, for example: + +``` + +const int my\_INTEGRAL\_CONSTANT = 3; + +``` +4. Static member constants, for example: + +``` + +struct myclass +{ static const int value = 0; }; + +``` +5. Member enumerator values, for example: + +``` + +struct myclass +{ enum{ value = 0 }; }; + +``` +6. Non-type template parameters of integral or enumerator + type. +7. The result of a `sizeof` expression, for + example: + +``` + +sizeof(foo(a, b, c)) + +``` +8. The result of a `static_cast`, where the + target type is an integral or enumerator type, and the + argument is either another integral constant expression, or a + floating-point literal. +9. The result of applying a binary operator to two integral + constant expressions: + +``` + +INTEGRAL\_CONSTANT1 op INTEGRAL\_CONSTANT2 + +``` +provided that the operator is not an assignment operator, or comma +operator. +10. The result of applying a unary operator to an integral + constant expression: + +``` + +op INTEGRAL\_CONSTANT1 + +``` +provided that the operator is not the increment or decrement operator. + + +Coding Guidelines +----------------- + + +The following guidelines are declared in no particular order + (in other words you need to obey all of them - sorry!), and may + also be incomplete, more guidelines may be added as compilers + change and/or more problems are encountered. + + +### When declaring constants that are class members always use + the macro `BOOST_STATIC_CONSTANT.` +``` + +template +struct myclass +{ + BOOST\_STATIC\_CONSTANT(int, value = sizeof(T)); +}; + +``` + +Rationale: not all compilers support inline initialisation + of member constants, others treat member enumerators in strange + ways (they're not always treated as integral constant + expressions). The BOOST\_STATIC\_CONSTANT macro uses the most + appropriate method for the compiler in question. + + +### Don't declare integral constant expressions whose type is + wider than int. + + +Rationale: while in theory all integral types are usable in + integral constant expressions, in practice many compilers limit + integral constant expressions to types no wider than + `int`. + + +### Don't use logical operators in integral constant + expressions; use template meta-programming instead. + + +The header `` + contains a number of workaround templates, that fulfil the role + of logical operators, for example instead of: +``` + +INTEGRAL\_CONSTANT1 || INTEGRAL\_CONSTANT2 + +``` + +Use: +``` + +::boost::type\_traits::ice\_or::value + +``` + +Rationale: A number of compilers (particularly the Borland + and Microsoft compilers), tend to not to recognise integral + constant expressions involving logical operators as genuine + integral constant expressions. The problem generally only shows + up when the integral constant expression is nested deep inside + template code, and is hard to reproduce and diagnose. + + +### Don't use any operators in an integral constant expression + used as a non-type template parameter + + +Rather than: +``` + +typedef myclass mytypedef; + +``` + +Use: +``` + +typedef myclass< some\_symbol> + mytypedef; + +``` + +Where `some_symbol` is the symbolic name of a an + integral constant expression whose value is + `(INTEGRAL_CONSTANT1 == INTEGRAL_CONSTANT2).` + + +Rationale: the older EDG based compilers (some of which are + used in the most recent version of that platform's compiler), + don't recognise expressions containing operators as non-type + template parameters, even though such expressions can be used + as integral constant expressions elsewhere. + + +### Always use a fully qualified name to refer to an integral + constant expression. + + +For example: +``` + +typedef myclass< ::boost::is\_integral::value> mytypedef; + +``` + +Rationale: at least one compiler (Borland's), doesn't + recognise the name of a constant as an integral constant + expression unless the name is fully qualified (which is to say + it starts with `::`). + + +### Always leave a space after a '`<`' and before + '`::`' + + +For example: +``` + +typedef myclass< ::boost::is\_integral::value> mytypedef; + ^ + ensure there is space here! + +``` + +Rationale: `<:` is a legal digraph in it's own + right, so `<::` is interpreted as the same as + `[:`. + + +### Don't use local names as integral constant expressions + + +Example: +``` + +template +struct foobar +{ + BOOST\_STATIC\_CONSTANT(int, temp = computed\_value); + typedef myclass mytypedef; // error +}; + +``` + +Rationale: At least one compiler (Borland's) doesn't accept + this. + + +Although it is possible to fix this by using: +``` + +template +struct foobar +{ + BOOST\_STATIC\_CONSTANT(int, temp = computed\_value); + typedef foobar self\_type; + typedef myclass<(self\_type::temp)> mytypedef; // OK +}; + +``` + +This breaks at least one other compiler (VC6), it is better + to move the integral constant expression computation out into a + separate traits class: +``` + +template +struct foobar\_helper +{ + BOOST\_STATIC\_CONSTANT(int, value = computed\_value); +}; + +template +struct foobar +{ + typedef myclass< ::foobar\_helper::value> mytypedef; // OK +}; + +``` + +### Don't use dependent default parameters for non-type + template parameters. + + +For example: +``` + +template ::value> // Error can't deduce value of I in some cases. +struct foobar; + +``` + +Rationale: this kind of usage fails for Borland C++. Note + that this is only an issue where the default value is dependent + upon a previous template parameter, for example the following + is fine: +``` + +template // OK, default value is not dependent +struct foobar; + +``` + +Unresolved Issues +----------------- + + +The following issues are either unresolved or have fixes + that are compiler specific, and/or break one or more of the + coding guidelines. + + +### Be careful of numeric\_limits + + +There are three issues here: + + +1. The header may be absent - it is + recommended that you never include directly + but use instead. This header + includes the "real" header if it is available, + otherwise it supplies it's own std::numeric\_limits + definition. Boost also defines the macro BOOST\_NO\_LIMITS if + is absent. +2. The implementation of std::numeric\_limits may be defined + in such a way that its static-const members may not be usable + as integral constant expressions. This contradicts the + standard but seems to be a bug that affects at least two + standard library vendors; boost defines + BOOST\_NO\_LIMITS\_COMPILE\_TIME\_CONSTANTS in + when this is the case. +3. There is a strange bug in VC6, where the members of + std::numeric\_limits can be "prematurely evaluated" in + template code, for example: +``` + +template +struct limits\_test +{ + BOOST\_STATIC\_ASSERT(::std::numeric\_limits::is\_specialized); +}; + +``` + +This code fails to compile with VC6 even though no instances + of the template are ever created; for some bizarre reason + `::std::numeric_limits::is_specialized` + always evaluates to false, irrespective of what the template + parameter T is. The problem seems to be confined to expressions + which depend on std::numeric\_limts: for example if you replace + `::std::numeric_limits::is_specialized` + with `::boost::is_arithmetic::value`, then + everything is fine. The following workaround also works but + conflicts with the coding guidelines: +``` + +template +struct limits\_test +{ + BOOST\_STATIC\_CONSTANT(bool, check = ::std::numeric\_limits::is\_specialized); + BOOST\_STATIC\_ASSERT(check); +}; + +``` + +So it is probably best to resort to something like this: +``` + +template +struct limits\_test +{ +#ifdef BOOST\_MSVC + BOOST\_STATIC\_CONSTANT(bool, check = ::std::numeric\_limits::is\_specialized); + BOOST\_STATIC\_ASSERT(check); +#else + BOOST\_STATIC\_ASSERT(::std::numeric\_limits::is\_specialized); +#endif +}; + +``` + +### Be careful how you use the sizeof operator + + +As far as I can tell, all compilers treat sizeof expressions + correctly when the argument is the name of a type (or a + template-id), however problems can occur if: + + +1. The argument is the name of a member-variable, or a local + variable (code may not compile with VC6). +2. The argument is an expression which involves the creation + of a temporary (code will not compile with Borland C++). +3. The argument is an expression involving an overloaded + function call (code compiles but the result is a garbage + value with Metroworks C++). + + +### Don't use boost::is\_convertible unless you have to + + +Since is\_convertible is implemented in terms of the sizeof + operator, it consistently gives the wrong value when used with + the Metroworks compiler, and may not compile with the Borland's + compiler (depending upon the template arguments used). + + + + + + + + + diff --git a/development/library_metadata.html b/development/library_metadata.html new file mode 100644 index 0000000..28fd557 --- /dev/null +++ b/development/library_metadata.html @@ -0,0 +1,212 @@ +--- +title: Library Metadata - Boost C++ Libraries +copyright: Beman Dawes, David Abrahams, 1998-2005. Rene Rivera 2004-2005. +revised: 2005-12-17 14:32:46 -0500 +--- + + +Library Metadata - Boost C++ Libraries + + + +Library Metadata +================ + +A module can contain an optional file which describes the + libraries that it contains. This is located at + `meta/libraries.json`. It either contains a single + json object for a single library, or a list or json objects for + any number of libraries. + + +For example, for a single library: +``` + +{ + "key": "unordered", + "name": "Unordered", + "authors": [ "Daniel James" ], + "maintainers": [ "Daniel James " ], + "description": "Unordered associative containers.", + "category": [ + "Containers" + ] +} + + +``` + +An example for multiple libraries: +``` + +[ + { + "key": "functional", + "name": "Functional", + "authors": [ "Mark Rodgers" ], + "description": "The Boost.Function library contains a family of class templates that are function object wrappers.", + "category": [ + "Function-objects" + ] + }, + { + "key": "functional/factory", + "name": "Functional/Factory", + "authors": [ "Tobias Schwinger" ], + "maintainers": [ "Tobias Schwinger " ], + "description": "Function object templates for dynamic and static object creation", + "documentation": "factory/", + "category": [ + "Function-objects" + ] + }, +] + + +``` + +Json fields +----------- + + +### key + + +This is a unique identifier for the library, typically the + path to it from the `libs` directory. + + +### name + + +Human readable name of the library + + +### status + + +Used for libraries with special statuses, currently can have + value `deprecated` for deprecated libraries, and + `hidden` for libraries which shouldn't be displayed to + the user. + + +### authors + + +Either a string, or a list of strings, containing the names + of the authors + + +### description + + +A brief description of what the library does + + +### category + + +A list of categories that the library belongs to, the full + list is below. + + +### documentation + + +Path to the documentation, defaults to the root of the + module. + + +### cxxstd + + +The minimum C++ standard compilation level at which + all, or the large majority, of the functionality in + the library is usable. The possible values are: + + +* 98 = C++98 +* 03 = C++98/C++03 +* 11 = C++11 +* 14 = C++14 +* 17 = C++17 +* 20 = C++20 + + +The level only indicates the minimum level, which + means that the functionality of the library can be + used when compiling at that level or at a higher + level. There may be some functionality in the library + which will need a higher C++ standard compilation + level than is indicated by this value, but the + information about that specific functionality will be + provided for the end-user within the documentation for + that library. If a library does not have this field it + indicates that the end-user will have to read the + library documentation to understand what C++ standard + compilation level is needed to use the library. + + +Available categories +-------------------- +String +String and text processing +Containers +Containers +Iterators +Iterators +Algorithms +Algorithms +Function-objects +Function objects and higher-order programming +Generic +Generic Programming +Metaprogramming +Template Metaprogramming +Preprocessor +Preprocessor Metaprogramming +Concurrent +Concurrent Programming +Math +Math and numerics +Correctness +Correctness and testing +Error-handling +Error handling and recovery +Data +Data structures +Domain +Domain Specific +Image-processing +Image processing +IO +Input/Output +Inter-language +Inter-language support +Emulation +Language Features Emulation +Memory +Memory +Parsing +Parsing +Patterns +Patterns and Idioms +Programming +Programming Interfaces +State +State Machines +System +System +Miscellaneous +Miscellaneous +workarounds +Broken compiler workarounds + + + + + + + + diff --git a/development/report-apr-2006.html b/development/report-apr-2006.html new file mode 100644 index 0000000..c00a0df --- /dev/null +++ b/development/report-apr-2006.html @@ -0,0 +1,257 @@ +--- +title: Review Wizard Status Report for April 2006 +copyright: +revised: +--- + + +Review Wizard Status Report for April 2006 + + + +Review Wizard Status Report for April 2006 +========================================== + +News +---- + + +April 1, 2006 -- The "Promotion Traits" Review Begins + (Fast-Track) Proposal to add promote, integral\_promotion and + floating\_point\_promotion class templates to type\_traits + library. + + +April 6, 2006 -- The "Function Types" Review Begins + (Fast-Track) This library provides a metaprogramming facility + to classify, decompose and synthesize function-, function + pointer-, function reference- and member function pointer + types. + + +March 22, 2006 -- Asio Accepted Announcement: + + +February 17, 2006 - Shared Memory Library Accepted + Announcement: + + +February 5, 2006 - Fixed String Library Rejected + Announcement: + + +We need experienced review managers. Please take a look at + the list of libraries in need of managers and check out their + descriptions. If you can serve as review manager for any of + them, email Ron Garcia or Tom Brinkman "garcia at cs dot + indiana dot edu" and "reportbase at gmail dot com" + respectively. + + +A link to this report will be posted to www.boost.org. If + you would like us to make any modifications or additions to + this report before we do that, please email Ron or Tom. + + +If you're library author and plan on submitting a library + for review in the next 3-6 months, send Ron or Tom a short + description of your library and we'll add it to the Libraries + Under Construction below. We know that there are many libaries + that are near completion, but we have hard time keeping track + all of them. Please keep us informed about your progress. + + +Review + Queue +------------- + + +* Promotion Traits - April 1, 2006 (fast-track) +* Function Types - April 6, 2006 (fast-track) +* Fusion +* Pimpl Pointer +* Property Tree +* Physical Quantities System +* Intrusive Containers + +--- + + +### Function Types + (mini-re-review) + + +| Author: | Tobias Schwinger | +| Review Manager: | Tom Brinkman | +| Download: | | +| Description: | This library provides a + metaprogramming facility to classify, decompose and + synthesize function-, function pointer-, function + reference- and member function pointer types. For the + purpose of this documentation, these types are + collectively referred to as function types (this + differs from the standard definition and redefines the + term from a programmer's perspective to refer to the + most common types that involve functions). +The classes introduced by this library shall conform + to the concepts of the Boost Metaprogramming library + (MPL). + +The Function Types library enables the user + to: + +* test an arbitrary type for being a function + type of specified kind, +* inspect properties of function types, +* view and modify sub types of an encapsulated + function type with MPL Sequence operations, + and +* synthesize function types. + +This library supports variadic + functions and can be configured to support non-default + calling conventions. | + + +### Promotion Traits + + +| Author: | Alexander Nasonov | +| Review Manager: | Tobias Schwinger | +| Download: | | +| Description: | Proposal to add promote, + integral\_promotion and floating\_point\_promotion class + templates to type\_traits library. +Alexander tried it on different compilers with + various success: GNU/Linux (gentoo-hardened): gcc 3.3 + and 3.4, Intel 7, 8 and 9 Windows: VC7 free compiler + Sparc Solaris: Sun C++ 5.3 and 5.7 +See comments at the beginning of + promote\_enum\_test.cpp for what is broken. | + + +### Intrusive Containers + + +| Author: | Olaf Krzikalla | +| Review Manager: | Thorsten Ottosen | +| Download: | | +| Description: | While intrusive containers were + and are widely used in C, they became more and more + forgotten in the C++-world due to the presence of the + standard containers, which don't support intrusive + techniques. Boost.Intrusive not only reintroduces this + technique to C++, but also encapsulates the + implementation in STL-like interfaces. Hence anyone + familiar with standard containers can use intrusive + containers with ease. | + + +### Fusion + + +| Author: | Joel de Guzman | +| Review Manager: | Ron Garcia | +| Download: | + | +| Description: | Fusion is a library of heterogenous + containers and views and algorithms. A set of + heterogenous containers (vector, list, set and map) is + provided out of the box along with view classes that + present various composable views over the data. The + containers and views follow a common sequence concept + with an underlying iterator concept that binds it all + together, suitably making the algorithms fully generic + over all sequence types. +The architecture is somewhat modeled + after MPL which in turn is modeled after STL. It is + code-named "fusion" because the library is the "fusion" + of compile time metaprogramming with runtime + programming. | + + +### Pimpl + Pointer + + +| Author: | Asger Mangaard | +| Review Manager: | Need Volunteer | +| Download: | Boost Sandbox () + under pimpl\_ptr. | +| Description: | The pimpl idiom is widely used to + reduce compile times and disable code coupling. It does + so by moving private parts of a class from the .hpp file + to the .cpp file. However, it's implementation can be + tricky, and with many pitfalls (especially regarding + memory management). The pimpl\_ptr library is a single + header file, implementing a special policy based smart + pointer to greately ease the implementation of the pimpl + idiom. | + + +### Property + Tree + + +| Author: | Marcin Kalicinski | +| Review Manager: | Need Volunteer | +| Download: | Boost Sandbox Vault - + property\_tree\_rev4.zip | +| Description: | Property tree is a data structure + - a tree of (key, value) pairs. It differs from its + cousin, "usual" property map, because it is hierarchical, + not linear. Thus, it is more like a minimalistic Document + Object Model, but not bound to any specific file format. + It can store contents of XML files, windows registry, + JSON files, INI files, even command line parameters. The + library contains parsers for all these formats, and + more. | + + +### Physical Quantities + System + + +| Author: | Andy Little | +| Review Manager: | Need Volunteer | +| Download: | | +| Description: | PQS (Physical Quantities System) + is used for modelling physical-quantities in C++ + programs. The advantages over using built-in types in the + role include: trapping errors in dimensional analysis, + detailed semantic specifications for reliable and + repeatable conversions between units and + self-documentation of source code. PQS is based around + the principles and guidelines of the International System + of Units (SI). The library predefines a large number of + quantities, physical and maths constants using a common + syntax. The library also includes (or will soon include) + classes for manipulating quantities algebraically, for + example angles (radians, steradians, + degrees,minutes,seconds) and vectors, matrices and + quaternions for more advanced modelling of physical + systems. | + + +Libraries under + development +---------------------------- + + +Geometry Library - Author - Andy Little (?) + + +C2\_functions Library - Author - Marcus Mendenhall + + +Please let us know of any libraries you are currently + developing that you intend to submit for review. + + + + + + + + + diff --git a/development/report-dec-2009.html b/development/report-dec-2009.html new file mode 100644 index 0000000..50d1dbc --- /dev/null +++ b/development/report-dec-2009.html @@ -0,0 +1,565 @@ +--- +title: Review Wizard Status Report for December 2009 +copyright: +revised: +--- + + +Review Wizard Status Report for December 2009 + + + +Review Wizard Status Report for December 2009 +============================================= + +News +---- + + +Polygon Library Accepted +Boost 1.40 Released +New Libraries: None +Revised Libraries: Accumulators, Asio, Circular Buffer, Filesystem, Foreach, Function, Fusion, Hash, Interprocess, Intrusive, MPL, Program Options, Proto, Python, Serialization, Unordered, Xpressive + +Geometry Library Accepted +Boost 1.41 Released +New Libraries: Property Tree +Revised Libraries: DateTime, Filesystem, Iostreams, Math, Multi-index Containers, Proto, Python, Regex, Spirit, System, Thread, Unordered, Utility, Wave, Xpressive + +MSM Library Review Underway + + +Constrained Value Review - Review Result still Pending + +Older Issues +============ + + +The Time Series Library, accepted in August 2007, has not yet been +submitted to SVN. + + +The Floating Point Utilities Library, has not yet been submitted to +SVN. It is slated to be integrated with the Boost.Math library. + + +The Switch Library, accepted provisionally in January 2008, +has not yet been submitted for mini-review and full acceptance. + + +The Phoenix Library, accepted provisionally in September 2008, +has not yet been submitted for mini-review and full acceptance. + + +For libraries that are still waiting to get into SVN, please get them +ready and into the repository. The developers did some great work +making the libraries, so don't miss the chance to share that work with +others. + +General Announcements +===================== + + +As always, we need experienced review managers. The review queue has +been growing substantially but we have had few volunteers, so manage +reviews if possible and if not please make sure to watch the review +schedule and participate. Please take a look at the list of libraries +in need of managers and check out their descriptions. In general +review managers are active boost participants or library +contributors. If you can serve as review manager for any of them, +email Ron Garcia or John Phillips, "garcia at osl dot iu dot edu" +and "phillips at mps dot ohio-state dot edu" respectively. + + +We are also suffering from a lack of reviewers. While we all +understand time pressures and the need to complete paying work, the +strength of Boost is based on the detailed and informed reviews +submitted by you. A recent effort is trying to secure at least five +people who promise to submit reviews as a precondition to starting +the review period. Consider volunteering for this and even taking the +time to create the review as early as possible. No rule says you can +only work on a review during the review period. + + +A link to this report will be posted to www.boost.org. If you would +like us to make any modifications or additions to this report before +we do that, please email Ron or John. + + +If you're a library author and plan on submitting a library for review +in the next 3-6 months, send Ron or John a short description of your +library and we'll add it to the Libraries Under Construction below. We +know that there are many libraries that are near completion, but we +have hard time keeping track all of them. Please keep us informed +about your progress. + + +The included review queue isn't a classic queue. It is more an unordered list of the libraries awaiting review. As such, any library in the queue can be reviewed once the developer is ready and a review manager works with the wizards and the developer to schedule a review. It is not FIFO. + +Review Queue +============ + + +* Lexer +* Shifted Pointer +* Logging +* Log +* Join +* Pimpl +* Task +* Endian +* Conversion +* Sorting +* GIL.IO +* AutoBuffer +* String Convert +* Move +* Containers +* Interval Containers +* Type Traits Extensions +* Interthreads +* Bitfield +* Lockfree + +--- +Lexer +----- + + +| Author: | Ben Hanson | +| Review Manager: | Eric Neibler | +| Download: | [Boost Vault](http://boost-consulting.com/vault/index.php?action=downloadfile&filename=boost.lexer.zip&directory=Strings%20-%20Text%20Processing) | +| Description: | A programmable lexical analyser generator inspired by 'flex'. +Like flex, it is programmed by the use of regular expressions +and outputs a state machine as a number of DFAs utilising +equivalence classes for compression. | + +Shifted Pointer +--------------- + + +| Author: | Phil Bouchard | +| Review Manager: | Needed | +| Download: | [Boost Vault](http://www.boost-consulting.com/vault/index.php?&direction=0&order=&directory=Memory) | +| Description: | Smart pointers are in general optimized for a specific resource +(memory usage, CPU cycles, user friendliness, ...) depending on +what the user need to make the most of. The purpose of this smart +pointer is mainly to allocate the reference counter (or owner) and +the object itself at the same time so that dynamic memory management +is simplified thus accelerated and cheaper on the memory map. | + +Logging +------- + + +| Author: | John Torjo | +| Review Manager: | Gennadiy Rozental | +| Download: | | +| Description: | Used properly, logging is a very powerful tool. Besides aiding +debugging/testing, it can also show you how your application is +used. The Boost Logging Library allows just for that, supporting +a lot of scenarios, ranging from very simple (dumping all to one +destination), to very complex (multiple logs, some enabled/some +not, levels, etc). It features a very simple and flexible +interface, efficient filtering of messages, thread-safety, +formatters and destinations, easy manipulation of logs, finding +the best logger/filter classes based on your application's +needs, you can define your own macros and much more! | + +Log +--- + + +| Author: | Andrey Semashev | +| Review Manager: | Needed | +| Download: | [Boost Vault](http://tinyurl.com/cm9lum) | +| Description: | The library is aimed to help adding logging features to +applications. It provides out-of-box support for many widely used +capabilities, such as formatting and filtering based on attributes, +sending logs to a syslog server or to Windows Event Log, or simply +storing logs into files. It also provides basic support for the +library initialization from a settings file. The library can also be +used for a wider range of tasks and implement gathering and processing +statistical information or notifying user about application events. | + +Join +---- + + +| Author: | Yigong Liu | +| Review Manager: | Needed | +| Download: | | +| Description: | Join is an asynchronous, message based C++ concurrency +library based on join calculus. It is applicable both to +multi-threaded applications and to the orchestration of asynchronous, +event-based applications. It follows Comega's design and +implementation and builds with Boost facilities. It provides a high +level concurrency API with asynchronous methods, synchronous methods, +and chords which are "join-patterns" defining the synchronization, +asynchrony, and concurrency. | + +Pimpl +----- + + +| Author: | Vladimir Batov | +| Review Manager: | Needed | +| Download: | +[Boost Vault](http://www.boost-consulting.com/vault/index.php?action=downloadfile&filename=Pimpl.zip&directory=&) + (documentation) + | +| Description: | The Pimpl idiom is a simple yet robust technique to +minimize coupling via the separation of interface and implementation +and then implementation hiding. This library provides a convenient +yet flexible and generic deployment technique for the Pimpl idiom. +It's seemingly complete and broadly applicable, yet minimal, simple +and pleasant to use. | + +Task +---- + + +| Author: | Oliver Kowalke | +| Review Manager: | Needed | +| Download: | [Boost Vault](http://www.boostpro.com/vault/index.php?action=downloadfile&filename=boost-threadpool.2.tar.gz&directory=Concurrent%20Programming) | +| Description: | Formerly called Thread Pool +The library provides: +\* thread creation policies: + +* determines the management of worker threads: +* fixed set of threads in pool +* create workerthreads on demand (depending on context) +* let worker threads ime out after certain idle time + + +* channel policies: manages access to queued tasks: + + + bounded channel with high and low watermark for queuing tasks + + unbounded channel with unlimited number of queued tasks + + rendezvous syncron hand-over between producer and consumer threads +* queueing policy: determines how tasks will be removed from channel: + + + FIFO + + LIFO + + priority queue (attribute assigned to task) + + smart insertions and extractions (for instance remove oldest task with + certain attribute by newest one) +* tasks can be chained and lazy submit of taks is also supported (thanks to +Braddocks future library). +* returns a task object from the submit function. The task it self can +be interrupted if its is cooperative (means it has some interruption points +in its code -> this\_thread::interruption\_point() ). + | + +Endian +------ + + +| Author: | Beman Dawes | +| Review Manager: | Needed | +| Download: | | +| Description: | | + +Conversion +---------- + + +| Author: | Vicente Botet | +| Review Manager: | Needed | +| Download: | [Boost Vault](http://www.boostpro.com/vault/index.php?action=downloadfile&filename=conversion.zip&directory=Utilities&) | +| Description: | Generic explicit conversion between unrelated types. + +Boost.Conversion provides: +* a generic convert\_to function which can be specialized by the user to +make explicit conversion between unrelated types. +* a generic assign\_to function which can be specialized by the user to +make explicit assignation between unrelated types. +* conversion between std::complex of explicitly convertible types. +* conversion between std::pair of explicitly convertible types. +* conversion between boost::optional of explicitly convertible types. +* conversion between boost::rational of explicitly convertible types. +* conversion between boost::interval of explicitly convertible types. +* conversion between boost::chrono::time\_point and boost::ptime. +* conversion between boost::chrono::duration and boost::time\_duration. + | + +Sorting +------- + + +| Author: | Steven Ross | +| Review Manager: | Needed | +| Download: | [Boost Vault](http://www.boostpro.com/vault/index.php?action=downloadfile&filename=algorithm_sorting.zip) | +| Description: | A grouping of 3 templated hybrid radix/comparison-based sorting +algorithms that provide superior worst-case and average-case +performance to std::sort: integer\_sort, which sorts fixed-size data +types that support a rightshift (default of >>) and a comparison +(default of <) operator. float\_sort, which sorts standard +floating-point numbers by safely casting them to integers. +string\_sort, which sorts variable-length data types, and is optimized +for 8-bit character strings. +All 3 algorithms have O(n(k/s + s)) runtime where k is the number of +bits in the data type and s is a constant, and limited memory overhead +(in the kB for realistic inputs). In testing, integer\_sort varies +from 35% faster to 8X as fast as std::sort, depending on processor, +compiler optimizations, and data distribution. float\_sort is roughly +7X as fast as std::sort on x86 processors. string\_sort is roughly 2X +as fast as std::sort. | + +GIL.IO +------ + + +| Author: | Christian Henning | +| Review Manager: | Needed | +| Download: | [GIL Google Code Vault](http://gil-contributions.googlecode.com/files/rc2.zip) | +| Description: | I/O extension for boost::gil which allows reading and +writing of/in various image formats ( tiff, jpeg, png, etc ). This +review will also include the Toolbox extension which adds some common +functionality to gil, such as new color spaces, algorithms, etc. | + +AutoBuffer +---------- + + +| Author: | Thorsten Ottosen | +| Review Manager: | Needed | +| Download: | [Here](http://www.cs.aau.dk/~nesotto/boost/auto_buffer.zip) | +| Description: | Boost.AutoBuffer provides a container for efficient dynamic, local buffers. +Furthermore, the container may be used as an alternative to std::vector, +offering greater flexibility and sometimes better performance. | + +String Convert +-------------- + + +| Author: | Vladimir Batov | +| Review Manager: | Needed | +| Download: | [Boost Vault](http://www.boostpro.com/vault/index.php?action=downloadfile&filename=boost-string-convert.zip) | +| Description: | The library takes the approach of boost::lexical\_cast in the area of +string-to-type and type-to-string conversions, builds on the past +boost::lexical\_cast experience and advances that conversion +functionality further to additionally provide: + +* throwing and non-throwing conversion-failure behavior; +* support for the default value to be returned when conversion fails; +* two types of the conversion-failure check -- basic and better/safe; +* formatting support based on the standard I/O Streams and the standard +(or user-defined) I/O Stream-based manipulators +(like std::hex, std::scientific, etc.); +* locale support; +* support for boost::range-compliant char and wchar\_t-based string containers; +* no DefaultConstructibility requirement for the Target type; +* consistent framework to uniformly incorporate any type-to-type conversions. +It is an essential tool with applications making extensive use of +configuration files or having to process/prepare considerable amounts +of data in, say, XML, etc. | + +Move +---- + + +| Author: | Ion Gaztanaga | +| Review Manager: | Needed | +| Download: | and online documentation at | +| Description: | In C++0x, move semantics are implemented with the introduction of +rvalue references. They allow us to implement move() without verbosity +or runtime overhead. Boost.Move is a library that offers tools to +implement those move semantics not only in compilers with rvalue +references but also in compilers conforming to C++03. | + +Containers +---------- + + +| Author: | Ion Gaztanaga | +| Review Manager: | Needed | +| Download: | .zip&directory=Containers& | +| Documentation: | | +| Description: | Boost.Container library implements several well-known containers, +including STL containers. The aim of the library is to offers advanced +features not present in standard containers or to offer the latest +standard draft features for compilers that comply with C++03. | + +Interval Containers Library +--------------------------- + + +| Author: | Joachim Faulhaber | +| Download: | | +| Documentation: | | +| Review Manager: | Needed | +| Description: | The Interval Template Library (Itl) provides intervals +and two kinds of interval containers: Interval\_sets and +interval\_maps. Interval\_sets and maps can be used just +as sets or maps of elements. Yet they are much more +space and time efficient when the elements occur in +contiguous chunks: intervals. This is obviously the case +in many problem domains, particularly in fields that deal +with problems related to date and time. +Interval containers allow for intersection with interval\_sets +to work with segmentation. For instance you might want +to intersect an interval container with a grid of months +and then iterate over those months. +Finally interval\_maps provide aggregation on +associated values, if added intervals overlap with +intervals that are stored in the interval\_map. This +feature is called aggregate on overlap. It is shown by +example: + +``` + +typedef set guests; +interval\_map party; +guests mary; mary.insert("Mary"); +guests harry; harry.insert("Harry"); +party += make\_pair(intervaldoc/index.html + + + +``` + +### Naming consistency + + +As library developers and users have gained experience with + Boost, the following consistent naming approach has come to be + viewed as very helpful, particularly for larger libraries that + need their own header subdirectories and namespaces. + + +Here is how it works. The library is given a name that + describes the contents of the library. Cryptic abbreviations + are strongly discouraged. Following the practice of the C++ + Standard Library, names are usually singular rather than + plural. For example, a library dealing with file systems might + chose the name "filesystem", but not "filesystems", "fs" or + "nicecode". + + +* The library's primary directory (in parent + boost-root/libs) is given that same name. For + example, boost-root/libs/filesystem. +* The library's primary header directory (in + boost-root/libs/name/include) is given that same + name. For example, + boost-root/libs/filesystem/boost/filesystem. +* The library's primary namespace (in parent + *::boost*) is given that same name, except when + there's a component with that name (e.g., + *boost::tuple*), in which case the namespace name is + pluralized. For example, *::boost::filesystem*. + + +When documenting Boost libraries, follow these conventions + (see also the following section of this document): + + +* The library name is set in roman type. +* The library name is capitalized. +* A period between "Boost" and the library name (e.g., + Boost.Bind) is used if and only if the library name is not + followed by the word "library". +* The word "library" is not part of the library name and is + therefore lowercased. + + +Here are a few examples of how to apply these + conventions: + + +* Boost.Bind was written by Peter Dimov. +* The Boost Bind library was written by Peter Dimov. +* I regularly use Bind, a Boost library written by Peter + Dimov. + + +### Documentation + + +Even the simplest library needs some documentation; the + amount should be proportional to the need. The documentation + should assume the readers have a basic knowledge of C++, but + are not necessarily experts. + + +The format for documentation should be HTML, and should not + require an advanced browser or server-side extensions. Style + sheets are acceptable. ECMAScript/JavaScript is discouraged. + The documentation entry point should always be a file named + index.html; see [Redirection](#Redirection). + + +There is no single right way to do documentation. HTML + documentation is often organized quite differently from + traditional printed documents. Task-oriented styles differ from + reference oriented styles. In the end, it comes down to the + question: Is the documentation sufficient for the mythical + "average" C++ programmer to use the library successfully? + + +Appropriate topics for documentation often include: + + +* General introduction to the library. The introduction + particularly needs to include: + + A very high-level overview of what the library is + good for, and perhaps what it isn't good for, + understandable even by those with no prior knowledge of + the problem domain. + + The simplest possible ("hello world") example of + using the library. +* Tutorial covering basic use cases. +* Reference documentation: + + Description of each class. + + Relationship between classes. + + For each function, as applicable, description, + requirements (preconditions), effects, post-conditions, + returns, and throws. + + Discussion of error detection and recovery + strategy. +* How to compile and link. +* How to test. +* Version or revision history. +* Rationale for design decisions. See [Rationale rationale](#Rationale). +* Acknowledgements. See [Acknowledgments rationale.](#Acknowledgements) + + +If you need more help with how to write documentation you + can check out the article on [Writing + Documentation for Boost](../doc/libs/release/more/writingdoc/index.html). + + +Rationale +--------- + + +Rationale for some of the requirements and guidelines + follows. + + +### Exception-specification + rationale + + +Exception specifications [ISO 15.4] are sometimes coded to + indicate what exceptions may be thrown, or because the + programmer hopes they will improve performance. But consider + the following member from a smart pointer: +``` + +T& operator\*() const throw() { return \*ptr; } + +``` + +This function calls no other functions; it only manipulates + fundamental data types like pointers Therefore, no runtime + behavior of the exception-specification can ever be invoked. + The function is completely exposed to the compiler; indeed it + is declared inline Therefore, a smart compiler can easily + deduce that the functions are incapable of throwing exceptions, + and make the same optimizations it would have made based on the + empty exception-specification. A "dumb" compiler, however, may + make all kinds of pessimizations. + + +For example, some compilers turn off inlining if there is an + exception-specification. Some compilers add try/catch blocks. + Such pessimizations can be a performance disaster which makes + the code unusable in practical applications. + + +Although initially appealing, an exception-specification + tends to have consequences that require **very** + careful thought to understand. The biggest problem with + exception-specifications is that programmers use them as though + they have the effect the programmer would like, instead of the + effect they actually have. + + +A non-inline function is the one place a "throws nothing" + exception-specification may have some benefit with some + compilers. + + +### Naming conventions + rationale + + +The C++ standard committee's Library Working Group discussed + this issue in detail, and over a long period of time. The + discussion was repeated again in early boost postings. A short + summary: + + +* Naming conventions are contentious, and although several + are widely used, no one style predominates. +* Given the intent to propose portions of boost for the + next revision of the C++ standard library, boost decided to + follow the standard library's conventions. +* Once a library settles on a particular convention, a vast + majority of stakeholders want that style to be consistently + used. + + +### Source code fonts + rationale + + +Dave Abrahams comments: An important purpose (I daresay the + primary purpose) of source code is communication: the + documentation of intent. This is a doubly important goal for + boost, I think. Using a fixed-width font allows us to + communicate with more people, in more ways (diagrams are + possible) right there in the source. Code written for + fixed-width fonts using spaces will read reasonably well when + viewed with a variable-width font, and as far as I can tell + every editor supporting variable-width fonts also supports + fixed width. I don't think the converse is true. + + +### Tabs rationale + + +Tabs are banned because of the practical problems caused by + tabs in multi-developer projects like Boost, rather than any + dislike in principle. See [mailing list archives](../community/groups.html#archive). + Problems include maintenance of a single source file by + programmers using tabs and programmers using spaces, and the + difficulty of enforcing a consistent tab policy other than just + "no tabs". Discussions concluded that Boost files should either + all use tabs, or all use spaces, and thus the decision to stick + with spaces for indentation. + + +### Directory and + File Names rationale + + +1. Some legacy file systems require + single-case names. Single-case names eliminate casing mistakes + when moving from case-insensitive to case-sensitive file + systems. + + +2. This is the lowercase portion of + the POSIX portable filename character set. To quote the POSIX + standard, "Filenames should be constructed from the portable + filename character set because the use of other characters can + be confusing or ambiguous in certain contexts." + + +3. Strict implementations of ISO + 9660:1999 and some legacy operating systems prohibit dots in + directory names. The need for this restriction is fading, and + it will probably be removed fairly soon. + + +4. POSIX has special rules for names + beginning with a period. Windows prohibits names ending in a + period. + + +5. Would be too confusing or + ambiguous in certain contexts. + + +6. We had to draw the line + somewhere, and so the limit imposed by a now obsolete Apple + file system was chosen years ago. It still seems a reasonable + limit to aid human comprehension. + + +7. ISO 9660:1999. + + +### ECMAScript/JavaScript rationale + + +Before the 1.29.0 release, two Boost libraries added + ECMAScript/JavaScript documentation. Controversy followed (see + [mailing list + archives](../community/groups.html#archive)), and the developers were asked to remove the + ECMAScript/JavaScript. Reasons given for banning included: + + +* Incompatible with some older browsers and some text based + browsers. +* Makes printing docs pages difficult. +* Often results in really bad user interface design. +* "It's just annoying in general." +* Would require Boost to test web pages for + ECMAScript/JavaScript compliance. +* Makes docs maintenance by other than the original + developer more difficult. + + +Please conside those reasons if you decide that JavaScript + is something you must use. In particular please keep in mind + that the Boost community is not responsible for testing your + use of JavaScript. And hence it is up to you to ensure that the + above issues are fully resolved in your use case. + + +ECMAScript/JavaScript use is allowed but discouraged for the + reasons above. + + +### Rationale rationale + + +Rationale is defined as "The fundamental reasons for + something; basis" by the American Heritage Dictionary. + + +Beman Dawes comments: Failure to supply contemporaneous + rationale for design decisions is a major defect in many + software projects. Lack of accurate rationale causes issues to + be revisited endlessly, causes maintenance bugs when a + maintainer changes something without realizing it was done a + certain way for some purpose, and shortens the useful lifetime + of software. + + +Rationale is fairly easy to provide at the time decisions + are made, but very hard to accurately recover even a short time + later. + + +### Acknowledgements rationale + + +As a library matures, it almost always accumulates + improvements suggested to the authors by other boost members. + It is a part of the culture of boost.org to acknowledge such + contributions, identifying the person making the suggestion. + Major contributions are usually acknowledged in the + documentation, while minor fixes are often mentioned in + comments within the code itself. + + + + + + + diff --git a/development/reuse.html b/development/reuse.html new file mode 100644 index 0000000..a530f27 --- /dev/null +++ b/development/reuse.html @@ -0,0 +1,87 @@ +--- +title: Boost Library Reuse +copyright: Beman Dawes 2000. +revised: 2007-10-22 22:55:52 +0100 +--- + + +Boost Library Reuse + + + +Boost Library reuse: cost versus benefit trade-offs +=================================================== + +A Boost library **should not** use libraries + other than Boost or the C++ Standard Library. + + +A Boost library **should** use other Boost + Libraries or the C++ Standard Library, but only when the + benefits outweigh the costs. + + +The benefits of using components from other libraries may + include clearer, more understandable code, reduced development + and maintenance costs, and the assurance which comes from + reusing well-known and trusted building blocks. + + +The costs may include undesirable coupling between + components, and added compilation and runtime costs. If the + interface to the additional component is complex, using it may + make code less readable, and thus actually increase development + and maintenance costs. + + +Negative effects of coupling become obvious when one library + uses a second library which uses a third, and so on. The worst + form of coupling requires the user understand each of the + coupled libraries. Coupling may also reduce the portability of + a library - even in case when all used libraries are + self-sufficient (see example of questionable usage of + library below). + + +**Example where another boost component should + certainly be used:** boost::noncopyable (in [boost/utility.hpp](/doc/libs/release/boost/utility.hpp)) + has considerable benefits; it simplifies code, improves + readability, and signals intent. Costs are low as coupling is + limited; noncopyable itself uses no other classes and its + header includes only the lightweight headers + and . There are no + runtime costs at all. With costs so low and benefits so high, + other boost libraries should use boost::noncopyable when the + need arises except in exceptional circumstances. + + +**Example where a standard library component might + possibly be used:** Providing diagnostic output as a + debugging aid can be a nice feature for a library. Yet using + Standard Library can involve a lot of + additional cost, particularly if is unlikely + to be used elsewhere in the application. In certain GUI or + embedded applications, coupling to would be a + disqualification. Consider redesign of the boost library in + question so that the user supplies the diagnostic output + mechanism. + + +**Example where another boost component should not be + used:** The boost dir\_it library has considerable + coupling and runtime costs, not to mention portability issues + for unsupported operating systems. While completely appropriate + when directory iteration is required, it would not be + reasonable for another boost library to use dir\_it just to + check that a file is available before opening. C++ Standard + Library file open functionality does this at lower cost. Don't + use dir\_it just for the sake of using a boost library. + + + + + + + + + diff --git a/development/running_regression_tests.html b/development/running_regression_tests.html new file mode 100644 index 0000000..3d11940 --- /dev/null +++ b/development/running_regression_tests.html @@ -0,0 +1,299 @@ +--- +title: Running Boost Regression Tests +copyright: Rene Rivera 2007. MetaCommunications, Inc. 2004-2007. +revised: +--- + + +Running Boost Regression Tests + + + +Running Boost Regression Tests +============================== + +Running Regression Tests Locally +-------------------------------- + +***It's easy to run regression tests on your Boost + clone.*** + + +To run a library's regression tests, run Boost's + [b2](/build/) utility from the + **/libs/**/test directory. To run a + single test, specify its name (as found in + **/libs/**/test/Jamfile.v2) on the + command line. + + +See the [Getting + Started guide](/doc/libs/release/more/getting_started/index.html) for help building or downloading + bjam for your platform, and navigating your Boost + distribution. + + +To run every library's regression tests, run b2 + from **/status directory. + + +To run Boost.Build's regression tests, run "python + test\_all.py" from **/tools/build/v2/test + directory. (Python 2.3 ≤ version < 3.0 required.) + +Running Boost's Automated Regression and Reporting +-------------------------------------------------- + +This runs all Boost regression tests and reports the results back to + the Boost community. + + +### Requirements + + +* Python (2.3 ≤ version < 3.0). +* Git (recent version). +* At least 5 gigabytes of disk space per compiler to be + tested. + + +### Step by step instructions + + +1. Create a new directory for the branch you want to + test. +2. Download the [run.py](https://raw.githubusercontent.com/boostorg/regression/develop/testing/src/run.py) script into that directory: + +> +> 1. Open [run.py](https://raw.githubusercontent.com/boostorg/regression/develop/testing/src/run.py) script in your browser. +> 2. Click the ***Raw*** button. +> 3. Save as run.py in the directory you just created. +> +> +> + +4. Run "`python run.py options... [commands]`" + **with these three required options**, plus any others you wish to employ: + + + * --runner= - Your choice of name that + identifies your results in the reports [1](#runnerid1), [2](#runnerid2). + * --toolsets= - The toolset(s) you want to test + with [3](#toolsets). + * --tag= - The tag (i.e. branch) you want to test. + The only tags that currently make sense are + develop and master.For example: + +python run.py --runner=Metacomm + --toolsets=gcc-4.2.1,msvc-8.0 --tag=develop + + +**Note**: If you are behind a firewall/proxy + server, everything should still "just work". In the rare cases + when it doesn't, you can explicitly specify the proxy server + parameters through the --proxy option, e.g.: +``` +python run.py ... **--proxy=http://www.someproxy.com:3128** + +``` + +### Options +``` +commands: cleanup, collect-logs, get-source, get-tools, patch, regression, +setup, show-revision, test, test-boost-build, test-clean, test-process, test- +run, update-source, upload-logs + +Options: + -h, --help show this help message and exit + --runner=RUNNER runner ID (e.g. 'Metacomm') + --comment=COMMENT an HTML comment file to be inserted in the reports + --tag=TAG the tag for the results + --toolsets=TOOLSETS comma-separated list of toolsets to test with + --libraries=LIBRARIES + comma separated list of libraries to test + --incremental do incremental run (do not remove previous binaries) + --timeout=TIMEOUT specifies the timeout, in minutes, for a single test + run/compilation + --bjam-options=BJAM\_OPTIONS + options to pass to the regression test + --bjam-toolset=BJAM\_TOOLSET + bootstrap toolset for 'bjam' executable + --pjl-toolset=PJL\_TOOLSET + bootstrap toolset for 'process\_jam\_log' executable + --platform=PLATFORM + --user=USER Boost SVN user ID + --local=LOCAL the name of the boost tarball + --force-update do an SVN update (if applicable) instead of a clean + checkout, even when performing a full run + --have-source do neither a tarball download nor an SVN update; used + primarily for testing script changes + --ftp=FTP FTP URL to upload results to. + --proxy=PROXY HTTP proxy server address and port + (e.g.'http://www.someproxy.com:3128') + --ftp-proxy=FTP\_PROXY + FTP proxy server (e.g. 'ftpproxy') + --dart-server=DART\_SERVER + the dart server to send results to + --debug-level=DEBUG\_LEVEL + debugging level; controls the amount of debugging + output printed + --send-bjam-log send full bjam log of the regression run + --mail=MAIL email address to send run notification to + --smtp-login=SMTP\_LOGIN + STMP server address/login information, in the + following form: :@[:] + --skip-tests do not run bjam; used for testing script changes + +``` + +To test develop use "`--tag=develop`", + and to test master use + "`--tag=master`". Or substitute any Boost + tree of your choice. + + +### Details + + +The regression run procedure will: + + +* Download the most recent regression scripts. +* Download the designated testing tool sources including + Boost.Jam, Boost.Build, and the various regression + programs. +* Download the most recent from the [Boost Git Repository](/users/download/#repository) + into the subdirectory boost. +* Build b2 and process\_jam\_log if + needed. (process\_jam\_log is a utility, which + extracts the test results from the log file produced by + Boost.Build). +* Run regression tests, process and collect the + results. +* Upload the results to a common FTP server. + + +The report merger process running continuously will merge + all submitted test runs and publish them at [various locations](testing.html#RegressionTesting). + + +### Advanced use + + +### Providing detailed information about your environment + + +Once you have your regression results displayed in the + Boost-wide reports, you may consider providing a bit more + information about yourself and your test environment. This + additional information will be presented in the reports on a + page associated with your runner ID. + + +By default, the page's content is just a single line coming + from the comment.html file in your run.py + directory, specifying the tested platform. You can put online a + more detailed description of your environment, such as your + hardware configuration, compiler builds, and test schedule, by + simply altering the file's content. Also, please consider + providing your name and email address for cases where Boost + developers have questions specific to your particular set of + results. + + +### Incremental runs + + +You can run run.py in [incremental mode](#incremental) by simply passing it an + identically named command-line flag: +``` +python run.py ... **--incremental** + +``` + +### Patching Boost sources + + +You might encounter an occasional need to make local + modifications to the Boost codebase before running the tests, + without disturbing the automatic nature of the regression + process. To implement this under regression.py: + + +1. Codify applying the desired modifications to the sources + located in the ./boost\_root subdirectory in a single + executable script named patch\_boost + (patch\_boost.bat on Windows). +2. Place the script in the run.py directory. + + +The driver will check for the existence of the + patch\_boost script, and, if found, execute it after + obtaining the Boost sources. + + +### Feedback + + +Please send all comments/suggestions regarding this document + and the testing procedure itself to the [Boost Testing list](/community/groups.html#testing). + + +### Notes + + +[1] If you are + running regressions interlacingly with a different set of + compilers (e.g. for Intel in the morning and GCC at the end of + the day), you need to provide a *different* runner id + for each of these runs, e.g. your\_name-intel, and + your\_name-gcc. + + +[2] The limitations + of the reports' format/medium impose a direct dependency + between the number of compilers you are testing with and the + amount of space available for your runner id. If you are + running regressions for a single compiler, please make sure to + choose a short enough id that does not significantly disturb + the reports' layout. You can also use spaces in the runner ID + to allow the reports to wrap the name to fit. + + +[3] If + --toolsets option is not provided, the script will try + to use the platform's default toolset (gcc for most + Unix-based systems). + + +[4] By default, + the script runs in what is known as *full mode*: on each + run.py invocation all the files that were left in + place by the previous run — including the binaries for + the successfully built tests and libraries — are deleted, + and everything is rebuilt once again from scratch. By contrast, + in *incremental mode* the already existing binaries are + left intact, and only the tests and libraries which source + files has changed since the previous run are re-built and + re-tested. + + +The main advantage of incremental runs is a significantly + shorter turnaround time, but unfortunately they don't always + produce reliable results. Some type of changes to the codebase + (changes to the b2 testing subsystem in particular) often + require switching to a full mode for one cycle in order to + produce trustworthy reports. + + +As a general guideline, if you can afford it, testing in + full mode is preferable. + + + + + + + + + diff --git a/development/separate_compilation.html b/development/separate_compilation.html new file mode 100644 index 0000000..1312e51 --- /dev/null +++ b/development/separate_compilation.html @@ -0,0 +1,536 @@ +--- +title: Guidelines for Authors of Boost Libraries Containing Separate Source +copyright: John Maddock 1998. +revised: 2007-10-22 22:55:52 +0100 +--- + + +Guidelines for Authors of Boost Libraries Containing Separate + Source + + + +Guidelines for Authors of Boost Libraries Containing + Separate Source +===================================================================== + +These guidelines are designed for the authors of Boost + libraries which have separate source that need compiling in + order to use the library. Throughout, this guide refers to a + fictitious "whatever" library, so replace all occurrences of + "whatever" or "WHATEVER" with your own library's name when + copying the examples. + + +Contents +-------- +[Changes Affecting Source + Code](#source_changes) + + +[Preventing Compiler ABI + Clashes](#abi) +[Static or Dymanic + Libraries](#static_or_dynamic) +[Supporting Windows Dll's](#dlls) +[Automatic Library Selection and + Linking with auto\_link.hpp](#auto-link) + + +[Changes Affecting the Build + System](#build_changes) + + +[Creating the Library + Jamfile](#jamfile) +[Testing Auto-linking](#testing) + + +[Copyright](#copyright) + +Changes + Affecting Source Code +------------------------------ + + +### Preventing Compiler ABI + Clashes + + +There are some compilers (mostly Microsoft Windows compilers + again!), which feature a range of compiler switches that alter + the ABI of C++ classes and functions. By way of example, + consider Borland's compiler which has the following + options: +``` + +-b (on or off - effects enum sizes). +-Vx (on or off - empty members). +-Ve (on or off - empty base classes). +-aX (alignment - 5 options). +-pX (Calling convention - 4 options). +-VmX (member pointer size and layout - 5 options). +-VC (on or off, changes name mangling). +-Vl (on or off, changes struct layout). + +``` + +These options are provided in addition to those affecting + which runtime library is used (more on which later); the total + number of combinations of options can be obtained by + multiplying together the individual options above, so that + gives 2\*2\*2\*5\*4\*5\*2\*2 = 3200 combinations! + + +The problem is that users often expect to be able to build + the Boost libraries and then just link to them and have + everything just plain work, no matter what their project + settings are. Irrespective of whether this is a reasonable + expectation or not, without some means of managing this issue, + the user may well find that their program will experience + strange and hard to track down crashes at runtime unless the + library they link to was built with the same options as their + project (changes to the default alignment setting are a prime + culprit). One way to manage this is with "prefix and suffix" + headers: these headers invoke compiler specific #pragma + directives to instruct the compiler that whatever code follows + was built (or is to be built) with a specific set of compiler + ABI settings. + + +Boost.config provides the macro BOOST\_HAS\_ABI\_HEADERS which + is set whenever there are prefix and suffix headers available + for the compiler in use, typical usage in a header like + this: +``` + +#ifndef BOOST\_WHATEVER\_HPP +#define BOOST\_WHATEVER\_HPP + +#include + +// this must occur after all of the includes and before any code appears: +#ifdef BOOST\_HAS\_ABI\_HEADERS +# include BOOST\_ABI\_PREFIX +#endif +// +// this header declares one class, and one function by way of examples: +// +class whatever +{ + // details. +}; + +whatever get\_whatever(); + +// the suffix header occurs after all of our code: +#ifdef BOOST\_HAS\_ABI\_HEADERS +# include BOOST\_ABI\_SUFFIX +#endif + +#endif + +``` + +You can include this code in your library source files as + well if you want, although you probably shouldn't need to: + + +* If you *don't* use these in the library source + files (but do in your library's headers) and the user + attempts to compile the library source with a non-default ABI + setting, then they will get compiler errors if there are any + conflicts. +* If you *do* include them in both the library's + headers and the library source files, then the code should + always compile no matter what the compiler settings used, + although the result might not match what the user was + expecting: since we've forced the ABI back into default + mode. + + +#### Rationale: + + +Without some means of managing this issue, users often + report bugs along the line of "Your silly library always + crashes when I try and call it" and so on. These issues can be + extremely difficult and time consuming to track down, only to + discover in the end that it's a compiler setting that's changed + the ABI of the class and/or function types of the program + compared to those in the pre-compiled library. The use of + prefix/suffix headers can minimize this problem, although + probably not remove it completely. + + +##### Counter Argument #1: + + +Trust the user, if they want 13-byte alignment (!) let them + have it. + + +##### Counter Argument #2: + + +Prefix/suffix headers have a tendency to "spread" to other + boost libraries - for example if boost::shared\_ptr<> + forms part of your class's ABI, then including prefix/suffix + headers in your code will be of no use unless shared\_ptr.hpp + also uses them. Authors of header-only boost libraries may not + be so keen on this solution - with some justification - since + they don't face the same problem. + + +### Static or Dynamic Libraries + + +When the users runtime is dynamically linked the Boost + libraries can be built either as dynamic libraries (.so's on + Unix platforms, .dll's on Windows) or as static libraries (.a's + on Unix, .lib's on Windows). So we have a choice as to which is + supported by default: + + +* On Unix platforms it typically makes no difference to the + code: the user just selects in their makesfile which library + they prefer to link to. +* On Windows platforms, the code has to be specially + annotated to support DLL's, so we need to pick one option as + the default and one as an alternative. +* On Windows platforms, we can inject special code to + automatically select which library variant to link against: + so again we need to decide which is to be the default (see + the section on auto-linking below). + + +The recomendation is to pick static linking by default. + + +#### Rationale: + + +There is no one policy that fits all here. + + +The rationale for the current behaviour was inherited from + Boost.Regex (and it's ancestor regex++): this library + originally used dynamic linking by default whenever the runtime + was dynamic. It's actually safer that way should you be using + regex from a dll for example. However, this behavior brought a + persistent stream of user complaints: mainly about deployment, + all asking if static linking could be the default. After regex + changed behavior the complaints stopped, and the author hasn't + had one complaint about static linking by default being the + wrong choice. + + +Note that other libraries might need to make other choices: + for example libraries that are intended to be used to implement + dll pluggin's would like need to use dynamic linking in almost + all cases. + + +### Supporting Windows Dll's + + +On most Unix-like platforms no special annotations of source + code are required in order for that source to be compiled as a + shared library because all external symbols are exposed. + However the majority of Windows compilers require that symbols + that are to be imported or exported from a dll, be prefixed + with \_\_declspec(dllimport) or \_\_declspec(dllexport). Without + this mangling of source code, it is not possible to correctly + build shared libraries on Windows (historical note - originally + these declaration modifiers were required on 16-bit Windows + where the memory layout for exported classes was different from + that of "local" classes - although this is no longer an issue, + there is still no way to instruct the linker to "export + everything", it also remains to be seen whether 64-bit Windows + will resurrect the segmented architecture that led to this + problem in the first place. Note also that the mangled names of + exported symbols are different from non-exported ones, so + \_\_declspec(dllimport) is required in order to link to code + within a dll). + + +In order to support the building of shared libraries on MS + Windows your code will have to prefix all the symbols that your + library exports with a macro (lets call it BOOST\_WHATEVER\_DECL) + that your library will define to expand to either + \_\_declspec(dllexport) or \_\_declspec(dllimport) or nothing, + depending upon how your library is being built or used. Typical + usage would look like this: +``` + +#ifndef BOOST\_WHATEVER\_HPP +#define BOOST\_WHATEVER\_HPP + +#include + +#ifdef BOOST\_HAS\_DECLSPEC // defined in config system +// we need to import/export our code only if the user has specifically +// asked for it by defining either BOOST\_ALL\_DYN\_LINK if they want all boost +// libraries to be dynamically linked, or BOOST\_WHATEVER\_DYN\_LINK +// if they want just this one to be dynamically liked: +#if defined(BOOST\_ALL\_DYN\_LINK) || defined(BOOST\_WHATEVER\_DYN\_LINK) +// export if this is our own source, otherwise import: +#ifdef BOOST\_WHATEVER\_SOURCE +# define BOOST\_WHATEVER\_DECL \_\_declspec(dllexport) +#else +# define BOOST\_WHATEVER\_DECL \_\_declspec(dllimport) +#endif // BOOST\_WHATEVER\_SOURCE +#endif // DYN\_LINK +#endif // BOOST\_HAS\_DECLSPEC +// +// if BOOST\_WHATEVER\_DECL isn't defined yet define it now: +#ifndef BOOST\_WHATEVER\_DECL +#define BOOST\_WHATEVER\_DECL +#endif + +// +// this header declares one class, and one function by way of examples: +// +class BOOST\_WHATEVER\_DECL whatever +{ + // details. +}; + +BOOST\_WHATEVER\_DECL whatever get\_whatever(); + +#endif + +``` +And then in the source code for this library one would use: + +``` + + +// +// define BOOST\_WHATEVER SOURCE so that our library's +// setup code knows that we are building the library (possibly exporting code), +// rather than using it (possibly importing code): +// +#define BOOST\_WHATEVER\_SOURCE +#include + +// class members don't need any further annotation: +whatever::whatever() { } +// but functions do: +BOOST\_WHATEVER\_DECL whatever get\_whatever() +{ + return whatever(); +} + +``` + +#### Importing/exporting dependencies + + +As well as exporting your main classes and functions (those + that are actually documented), Microsoft Visual C++ will warn + loudly and often if you try to import/export a class whose + dependencies are not also exported. Dependencies include: any + base classes, any user defined types used as data members, plus + all of the dependencies of your dependencies and so on. This + causes particular problems when a dependency is a template + class, because although it is technically possible to export + these, it is not at all easy, especially if the template itself + has dependencies which are implementation-specific details. In + most cases it's probably better to simply suppress the warnings + using: +``` + +#ifdef BOOST\_MSVC +# pragma warning(push) +# pragma warning(disable : 4251 4231 4660) +#endif + +// code here + +#ifdef BOOST\_MSVC +#pragma warning(pop) +#endif + +``` + +This is safe provided that there are no dependencies that + are (template) classes with non-constant static data members, + these really do need exporting, otherwise there will be + multiple copies of the static data members in the program, and + that's really really bad. + + +Historical note: on 16-bit Windows you really did have to + export all dependencies or the code wouldn't work, however + since the latest Visual Studio .NET supports the import/export + of individual member functions, it's a reasonably safe bet that + Windows compilers won't do anything nasty - like changing the + class's ABI - when importing/exporting a class. + + +#### Rationale: + + +*Why bother - doesn't the import/export mechanism take up + more code that the classes themselves?* + + +A good point, and probably true, however there are some + circumstances where library code must be placed in a shared + library - for example when the application consists of multiple + dll's as well as the executable, and more than one those dll's + link to the same Boost library - in this case if the library + isn't dynamically linked and it contains any global data (even + if that data is private to the internals of the library) then + really bad things can happen - even without global data, we + will still get a code bloating effect. Incidentally, for larger + applications, splitting the application into multiple dll's can + be highly advantageous - by using Microsoft's "delay load" + feature the application will load only those parts it really + needs at any one time, giving the impression of a much more + responsive and faster-loading application. + + +*Why static linking by default?* + + +In the worked example above, the code assumes that the + library will be statically linked unless the user asks + otherwise. Most users seem to prefer this (there are no + separate dll's to distribute, and the overall distribution size + is often significantly smaller this way as well: i.e. you pay + for what you use and no more), but this is a subjective call, + and some libraries may even only be available in dynamic + versions (Boost.threads for example). + + +### Automatic Library + Selection and Linking with [auto\_link.hpp](/doc/libs/release/boost/config/auto_link.hpp) + + +Many Windows compilers ship with multiple runtime libraries + - for example Microsoft Visual Studio .NET comes with 6 + versions of the C and C++ runtime. It is essential that the + Boost library that the user links to is built against the same + C runtime as the program is built against. If that is not the + case, then the user will experience linker errors at best, and + runtime crashes at worst. The Boost build system manages this + by providing different build variants, each of which is build + against a different runtime, and gets a slightly different + mangled name depending upon which runtime it is built against. + For example the regex libraries get named as follows when built + with Visual Studio .NET 2003: +``` + +boost\_regex-vc71-mt-1\_31.lib +boost\_regex-vc71-mt-gd-1\_31.lib +libboost\_regex-vc71-mt-1\_31.lib +libboost\_regex-vc71-mt-gd-1\_31.lib +libboost\_regex-vc71-mt-s-1\_31.lib +libboost\_regex-vc71-mt-sgd-1\_31.lib +libboost\_regex-vc71-s-1\_31.lib +libboost\_regex-vc71-sgd-1\_31.lib + +``` + +The difficulty now is selecting which of these the user + should link his or her code to. + + +In contrast, most Unix compilers typically only have one + runtime (or sometimes two if there is a separate thread safe + option). For these systems the only choice in selecting the + right library variant is whether they want debugging info, and + possibly thread safety. + + +Historically Microsoft Windows compilers have managed this + issue by providing a #pragma option that allows the header for + a library to automatically select the library to link to. This + makes everything automatic and extremely easy for the end user: + as soon as they include a header file that has separate source + code, the name of the right library build variant gets embedded + in the object file, and as long as that library is in the + linker search path, it will get pulled in by the linker without + any user intervention. + + +Automatic library selection and linking can be enabled for a + Boost library by including the header + , after first defining + BOOST\_LIB\_NAME and, if applicable, BOOST\_DYN\_LINK. +``` + +// +// Automatically link to the correct build variant where possible. +// +#if !defined(BOOST\_ALL\_NO\_LIB) && !defined(BOOST\_WHATEVER\_NO\_LIB) && !defined(BOOST\_WHATEVER\_SOURCE) +// +// Set the name of our library, this will get undef'ed by auto\_link.hpp +// once it's done with it: +// +#define BOOST\_LIB\_NAME boost\_whatever +// +// If we're importing code from a dll, then tell auto\_link.hpp about it: +// +#if defined(BOOST\_ALL\_DYN\_LINK) || defined(BOOST\_WHATEVER\_DYN\_LINK) +# define BOOST\_DYN\_LINK +#endif +// +// And include the header that does the work: +// +#include +#endif // auto-linking disabled + +``` + +The library's user documentation should note that the + feature can be disabled by defining either BOOST\_ALL\_NO\_LIB or + BOOST\_WHATEVER\_NO\_LIB: + + +If for any reason you need to debug this feature, the header + will output some helpful + diagnostic messages if you first define + BOOST\_LIB\_DIAGNOSTIC. + + +Changes + Affecting the Build System +----------------------------------- + + +### Creating the library Jamfile + + +The Jamfile for building library "whatever" typically lives + in boost-root/libs/whatever/build, the only extra step required + is to add a requirement to the library target so + that your code knows whether it's building a dll or static + library, a typical Jamfile would like like this: +``` + +lib boost\_regex : ../src/whatever.cpp : + shared:BOOST\_WHATEVER\_DYN\_LINK=1 ; + + +``` + +### Testing + Auto-linking + + +Testing the auto-link feature is somewhat convoluted, and + requires access to a compiler that supports the feature: refer + to [libs/config/test/link/test/Jamfile.v2](/doc/libs/release/libs/config/test/link/test/Jamfile.v2) + for an example. + + + + + + + + + diff --git a/development/submissions.html b/development/submissions.html new file mode 100644 index 0000000..2ba811d --- /dev/null +++ b/development/submissions.html @@ -0,0 +1,344 @@ +--- +title: Boost Library Submission Process +copyright: Beman Dawes, 2000. +revised: +--- + + +Boost Library Submission Process + + + +Boost Library Submission Process +================================ + +This page describes the process a library developer goes + through to get a library accepted by Boost. + + +See the [Boost Library + Requirements and Guidelines](requirements.html) page for issues of content. + + +### Steps for getting a library accepted by Boost: + + +* [1. Learn about Boost](#Learn) +* [2. Determine interest](#interest) +* [3. Start Development](#Development) +* [4. Refinement](#Refinement) +* [5. Getting seconded for review](#Seconded) +* [6. Seek a Review Manager](#Seeking) +* [7. Formal Review](#Review) +* [8. Web site posting](#SitePosting) +* [9. People page](#People) +* [10. Lifecycle](#Lifecycle) + + +1. Learn about Boost +-------------------- + + +Follow posts on the [main + developers mailing list](/community/groups.html#main) for a while, or look through the + [archives](/community/groups.html#archive). Explore + the [web site](/). Learn the [Requirements](requirements.html). Read the rest of this + page to learn about the process. Search the web to get an idea + of the commitment required to get a library into Boost. + + + +There is a culture associated with Boost, aimed at + encouraging high quality libraries by a process of discussion + and refinement. Some libraries get past community review + in less than two years from first concept, but most take longer, + sometimes a lot longer. Five to ten years to get a library past + review and into Boost is not unheard of, and you should prepare + yourself for the personal investment required. + + +2. Determine + interest +---------------------- + + +While participation in reviews for other submissions is not a + prerequisite for submitting a library to Boost, it is highly + recommended; it will acquaint you with the process and the + emotional demands of a formal review. There's nothing that quite + deflates the ego like having brilliant members of the C++ + community critiquing your work, but, alas, it's worth it! + + +Potential library submitters should be careful to + research the prior art before beginning to design a + new library. Unfortunately, now and then folks arrive at Boost + with a new library into which they have invested many hours, only + to find that Boost already has that functionality, and sometimes + has had it for years. Candidates should also research libraries being + developed by others intended for Boost - if you have an itch + to scratch, often so have had others and collaboration + developing their library is usually considerably more efficient + than going at it alone. + + +Potential library submitters should also be careful to + publicise, canvas for, and gauge interest in their library, + ideally before beginning it, but certainly before submitting it + for review. Even a superbly designed library can fail review if + there isn't enough interest in the subject matter; We can only + review libraries with enough appeal to form a viable peer + review. Ensuring that enough people are interested in your + potential library goes a long way to ensure that. + + +There are many places to publicise and canvas for a library. + The Boost developers [mailing + list](/community/groups.html) ought to be your first stop in gauging interest + in a possible new C++ library. Be prepared to pivot your design + and focus until your proposed library finds traction. Other + places useful for gauging interest in a library might be [Reddit/r/cpp](https://www.reddit.com/r/cpp/). + + +A message to the Boost developers mailing list + might be as simple as "Is there any interest in a + library which solves Travelling Salesperson problems in linear + time?" + + +A bit of further description or snippet of code may be + helpful. By the way, the preferred format for messages on the + mailing list is plain text; not rich text, HTML, etc. + + +Avoid posting lengthy descriptions, documentation, + or code to the mailing list, and, please, no attachments. + The best place to provide lengthy material is via. a web link. + Project hosting services such as sourceforge, github, google + code, and bitbucket serve well for this purpose. + + +3. Start + Development +--------------------- + + +If response to an initial query indicates interest, then + by all means make your library publicly available if you haven't + already done so. + + +Please commit your code to a version control system such as + Git, and make your documentation available in HTML format on + a public website such as Github. An issue tracker such as the one + provided by Github is also highly recommended. + + +Your library should contain material as if it were on the + boost.org web site. The closer your library reflects the + final directory structure and format of the web site, the + better. This makes it possible for reviewers to simply copy + your code into the Boost distribution for testing. + + +Please verify that your library compiles and runs under + at least two compilers. This flushes out obvious portability + problems. + + +It is recommended that you release your code under the Boost + Software License; see the [Requirements](requirements.html) page for more + information. + + +4. Refinement +------------- + + +Discuss, refine, rewrite. Repeat until satisfied. + + +The exact details of this process varies a lot. Usually it + is public, on the mailing list, but frequently discussion + happens in private emails. For some libraries the process is + over quickly, but for others it goes on for months. It's + often challenging, and sometimes veers into completely + unexpected directions. + + +The [archive](/community/groups.html#archive) of + past messages is one way to see how this process worked for + other Boost libraries. + + +To get an idea of best practices with some samples of script + and code in existing Boost libraries, see the + [Best Practices Handbook](https://svn.boost.org/trac/boost/wiki/BestPracticeHandbook) on the Boost wiki. + + +5. Getting seconded + for review +------------------------------- + + +When you feel that your library is ready for entry into Boost, + you need to find at least one member (but preferably several) of + the Boost community who is willing to publicly endorse your + library for entry into Boost. A simple method of achieving this + is to post to [the Boost + developers mailing list](/community/groups.html) a short description of your + library, links to its github and documentation, and a request for + endorsements. + + +It is expected that those who endorse a library for review + will have performed at least a cursory check of the library's + suitability for Boost in terms of documentation, fit with + the rest of Boost and usefulness. A public endorsement of a + library for review means that from an initial glance, they + believe that the library has a reasonable chance to be accepted + during a formal review. The expectation is that these endorsers + will themselves review of the library during formal review + period, though this is not binding. + + +Once you have a list of people who have publicly endorsed + your library for review, email [the Review Wizards](/community/reviews.html#Wizard) + to request that your library be added to [the review queue](/community/review_schedule.html) + where the following information will be shown: + + +* Submission +* Submitter +* Links to Source (GitHub), Documentation (HTML website) + and any Incubator entry +* Names of members who endorse this submission for review +* Review Manager +* Review Dates + + +6. Seek a Review + Manager +------------------------- + + +In order to schedule a formal review, the author must find a + capable volunteer to manage the review. This should be someone + with knowledge of the library domain, and experience with the + review process. See [Formal + Review Process](/community/reviews.html) for the responsibilities of the review + manager. + + +Authors can find community members interested in managing + reviews through discussion of the library on the developer + list. If no one steps forward to volunteer to manage the + review, it is appropriate to contact an experienced Boost + member who showed interest in the library. Be considerate that + managing a review is a serious commitment; for this reason, + it's better to contact the member off-list. + + +If you cannot find a review manager after 3 weeks using the + means above, and your submission is targeting eventual + standardization, there is a list of Boost regulars who are also + WG21 committee members who have volunteered to act as review + managers in such cases. Please try them in the order listed. + They are: Zach Laine, Micheal Caisse, Matt Calabrese, Edward + Diener, Louis Dionne, Vinnie Falco, Glen Fernandes, and David + Sankel. + + +Once a potential review manager has been identified, [contact the + review wizards](/community/reviews.html#Wizard) for approval. The wizards approve review + managers based on their level of participation in the Boost + community. + + +The review wizards will coordinate with both the author and + review manager to schedule a date convenient for both. + + +See [Formal Review + Process](/community/reviews.html) for details. + + +7. Formal Review +---------------- + + +Before your formal review begins, double-, triple-, and + quadruple-check your library. Verify that every code example + works, that all unit tests pass on at least two compilers on at + least two major operating systems, and run your documentation + through a spelling and grammar checker. + + +Please do not modify your library on its master branch + during a review. Instead, modify a separate develop branch in + response to feedback and reviews. For bigger ticket items of + work, open issues on your issue tracker so interested people can + track the fixing of specific issues raised. + + +The review manager will consider all the reviews made by + members of the community and arrive at a decision on + whether your library is rejected, conditionally accepted or + unconditionally accepted. They will post a report summarising + the decision publicly. If conditions are attached to + acceptance, you will need to implement those conditions or + else undergo an additional formal review. + + +8. Boost web site + posting +-------------------------- + + +Once an accepted library is ready for inclusion on the Boost + web site, the submitter is typically given Boost repository + write access, and expected to check-in and maintain the library + there. Contact the moderators if you need write access or + direct use of the repository isn't possible for you. + + +9. People page +-------------- + + +If the boost.org web site doesn't already have your capsule + biography and picture (optional, with not-too-serious pictures + preferred!), please send them to the Boost webmaster. It is up + to you as to whether or not the biography includes your email + address or other contact information. The preferred picture + format is .jpg, but other common formats are acceptable. The + preferred image size is 500x375 but the webmaster has photo + editing software and can do the image preparation if + necessary. + + +10. Lifecycle +------------- + + +Libraries are software; they lose their value over time if + not maintained. Postings on the Boost developers or users + mailing lists can alert you to potential maintenance needs; + please plan to maintain your library over time. If you no + longer can or wish to maintain your library, please post a + message on the Boost developers mailing list asking for a new + maintainer to volunteer and then spend the time to help them + take over. + + +Orphaned libraries will be put in the care of the [Community + Maintenance Team](https://svn.boost.org/trac/boost/wiki/CommunityMaintenance). + + + + + + + + + diff --git a/development/template/template.html b/development/template/template.html new file mode 100644 index 0000000..769a07b --- /dev/null +++ b/development/template/template.html @@ -0,0 +1,24 @@ +--- +title: Boost C++ Libraries +copyright: Beman Dawes, David Abrahams, 1998-2005. Rene Rivera 2004-2005. +revised: 2005-12-17 14:32:46 -0500 +--- + + +Boost C++ Libraries + + + +Boost C++ Libraries +=================== + +{stuff} + + + + + + + + + diff --git a/development/test.html b/development/test.html new file mode 100644 index 0000000..3032191 --- /dev/null +++ b/development/test.html @@ -0,0 +1,127 @@ +--- +title: Boost Test Policies and Protocols +copyright: Beman Dawes 2001. +revised: +--- + + +Boost Test Policies and Protocols + + + +Boost Test Policies and Protocols +================================= + +The Boost libraries are intended to be both reliable and + portable. Every experienced programmer knows that means each + library must be tested against a suitable number of test cases, + on a wide range of platforms, and then tested again (regression + tested) every time a change is made and before every + release. + + +"Quality assurance based on a wide range of targeted tests" + as one of the key answers to C.A.R Hoare's question "How did + software get so reliable without proof." + + +Regression test +--------------- + + +Boost uses an automatic [regression + test suite](/doc/tools/regression/index.html) which generates HTML [compiler status + tables](/development/testing.html#RegressionTesting). + + +Test Policy +----------- + + +### Required + + +* Every Boost library should supply one or more suitable + test programs to be exercised by the Boost [regression + test suite](/doc/tools/regression/index.html). In addition to the usual compile-link-run + tests expecting successful completion, compile-only or + compile-and-link-only tests may be performed, and success for + the test may be defined as failure of the steps. +* Test program execution must report errors by returning a + non-zero value. They may also write to stdout or stderr, but + that output should be relatively brief. Regardless of other + output, a non-zero return value is the only way the + regression test framework will recognize an error has + occurred. Note that test programs to be included in the + status tables must compile, link, and run quickly since the + tests are executed many, many, times. +* Libraries with time consuming tests should be divided + into a fast-execution basic test program for the status + tables, and a separate full-coverage test program for + exhaustive test cases. The basic test should concentrate on + compilation issues so that the status tables accurately + reflect the library's likelihood of correct compilation on a + platform. +* If for any reason the usual test policies do not apply to + a particular library, an alternate test strategy must be + implemented. +* A [Jamfile](/doc/tools/regression/index.html#Adding_new_test) to drive the regression tests for the + library. + + +### Optional (but highly recommended) + + +The [Boost + Test Library](/doc/libs/release/libs/test/index.html) provides many useful components which ease the + construction of test programs. + + +* Use the library's [Test Tools](/doc/libs/release/libs/test/doc/html/boost_test/testing_tools.html) for the construction of simple test programs + that do not need much structure. +* Use the library's [Unit + Test Framework](/doc/libs/release/libs/test/doc/html/boost_test/tests_organization.html) for the construction of more complex test + programs that need to be structured into individual tests and + test suites. + + +Suggested Protocol for Fixing Bugs or Adding Features. +------------------------------------------------------ + + +* First, add regression test cases that detects the bug or + tests the feature. Sometimes adding one case suggests similar + untested cases, and they are added too. +* Second, for bugs, run the regression test and verify that + the bug is now detected. +* Third, then, and only then, fix the bug or add the + feature. +* Finally, rerun the full regression tests - sometimes the + change breaks something else. + + +History +------- + + +[See + Regression Test History](/doc/tools/regression/index.html#History). + + +Acknowledgements +---------------- + + +Written by Beman Dawes. Jens Maurer, Paul Moore, Gary Powell + and Jeremy Siek contributed helpful suggestions. + +--- + + + + + + + + + diff --git a/development/testing.html b/development/testing.html new file mode 100644 index 0000000..01b5dd3 --- /dev/null +++ b/development/testing.html @@ -0,0 +1,144 @@ +--- +title: Testing +copyright: Rene Rivera 2007. +revised: +--- + + +Testing + + +/\*\*/ + + + +Testing +======= + +* [Regression Tests](#RegressionTesting) +* [Snapshots](#Snapshots) +* [Inspection Reports](#Inspection) +* [More about regression + tests](#Introduction) + + +Regression Tests +---------------- + + +A group of volunteers donate CPU cycles and large amounts of + disk space to collectively produce the regression testing + result tables. Various Boost repository versions are tested for + the benefit of library developers and interested users: + +| Version | Developers | +| --- | --- | +| Develop branch | [Summary](tests/develop/developer/summary.html) | [Unresolved + Issues](tests/develop/developer/issues.html) | +| Master branch | [Summary](tests/master/developer/summary.html) | [Unresolved + Issues](tests/master/developer/issues.html) | + + +Snapshots +--------- + + +Snapshots are used for quality control checks.  The + Unix tarballs and Windows zipballs are identical except for the + line endings exported from Git. + + +Because the snapshots represent work-in-process, they may + not be suitable for production use. + +| Version | Download | Documentation | +| --- | --- | --- | +| Master branch | [Sourceforge](https://sourceforge.net/projects/boost/files/boost/snapshots/master/ "Boost master branch snapshots on sourceforge"), [JFrog.io](https://boostorg.jfrog.io/artifactory/main/master/ "Boost master branch snapshots on JFrog.io"). | [Documentation](/doc/libs/master/ "Boost master branch documentation snapshot") | +| Develop branch | [Sourceforge](https://sourceforge.net/projects/boost/files/boost/snapshots/develop/ "Boost develop branch snapshots on sourceforge"), [JFrog.io](https://boostorg.jfrog.io/artifactory/main/develop "Boost develop branch snapshots on JFrog.io"). | [Documentation](/doc/libs/develop/ "Boost develop branch documentation snapshot") | + + +The Git master branch can be checked out from . + + +Inspection + Reports +------------------- + + +The Boost snapshots are inspected daily to detect problems + such as missing copyrights or licenses. The Boost Inspection + Report tells all! + +| Version | +| --- | +| [Develop + branch](http://boost.cowic.de/rc/docs-inspect-develop.html) | +| [Master + branch](http://boost.cowic.de/rc/docs-inspect-master.html) | + + +More about + regression tests +---------------------------- + + +Will all Boost libraries work with your compiler?  + Unfortunately, the answer is "it depends". See the [regression testing results](#RegressionTesting) to see + exactly what works and what doesn't. + + +Boost libraries rely on modern C++ features such as + templates and the C++ Standard Library.  Most modern + compilers support those major features fairly well. But even + today, years after the adoption of the C++ Standard, some + compilers still don't support important minor features like + partial template specialization. + + +Boost library authors often expend a great deal of effort + trying to work around compiler deficiencies.  + Nevertheless, some libraries will not compile at all with + certain compilers or may have crippled functionality.  + Even if the current release of a compiler supports a boost + library, older versions of the compiler may not work + properly. + + +Boost releases are run through regression tests which + automatically generates compiler status tables for various + platforms. Unless otherwise indicated, the C++ Standard Library + implementation is the one shipped with the compiler. + + +### Warnings: + + +* These tables are not a good indication of a particular + compiler's compliance with the C++ Standard.  The Boost + libraries often contain workarounds which mask compiler + deficiencies. +* Some regression tests are run only occasionally, and so + are relatively out-of-date.  Check the date and revision + in the column heading. + + +The development code is being updated several times a day, + so it may contain bug fixes, compiler workarounds, new + features, and even whole new libraries. It may be unstable, + however. + + +A list of some of the organizations helping with testing is + listed on the [Acknowledgements + page](/community/acknowledgements.html#testing). + + + + + + + + + diff --git a/development/website_updating.html b/development/website_updating.html new file mode 100644 index 0000000..42ba258 --- /dev/null +++ b/development/website_updating.html @@ -0,0 +1,337 @@ +--- +title: Boost C++ Libraries - Updating Website +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Boost C++ Libraries - Updating Website + + + +Updating and Editing Website Content +==================================== + +* [Getting Content](#GettingContent) +* [Existing Page](#ExistingPage) +* [New Page](#NewPage) +* [Menus, Sidebars, and Index](#Menus) +* [Feeds](#Feeds) +* [Local Server](#Local_Server) + + +Getting + Content +---------------- + + +The website content lives in the [git repository](https://github.com/boostorg/website/). + + +In progress work is on the `beta` branch, the + live website is on the `master` branch. The website + is updated automatically from the git repo. If you want to + update the website, please create a pull request. + + +Existing + Page +-------------- + + +Large sections of the site are automatically generated, this + includes the release notes, the news pages and any files in the + generated directory. If you wish to edit these, see below. + + +The web content is structured to be as simple as possible to + make generic editing possible. At minimum only a text editor + and [HTML Tidy](http://tidy.sourceforge.net/) are needed to edit + content. The content uses [XHTML 1.0 Strict](http://www.w3.org/TR/xhtml1/) for various + reasons, the most important being to increase accessibility and + to enforce the separation of style from content. After getting + the content you want to edit as above, make the changes you + want and run the result through HTML Tidy with these + options: +``` + +tidy --tidy-mark no -i -wrap 78 -m -asxhtml --merge-divs no --merge-spans no --doctype strict *fname* + +``` + +Running HTML Tidy with a consistent set of options also + helps in keeping an accurate change history in the repository. + There are [examples](/development/exemplar.html) of + the kinds of styles supported either directly or through the + use of [class="*value*"] attributes for the + various XHTML tags. Please pay attention to any errors and + warnings that HTML Tidy mentions and strive to remove all of + them. + + +**NOTE:** The options for tidy are for + the latest version. In particular the --merge-\* + options may not be available in the version that comes as part + of many Unix/Linux distributions, and Windows utilities. + Removing the unavailable options is possible and will work. But + we recommend installing the latest tidy if possible. + You can obtain up to date Windows binaries, and sources from + the [HTML Tidy Library + Project](http://tidy.sourceforge.net/). + + +The pages should be viewable in most browsers. If possible + test you changes in as many as possible. Preferably at least + two modern browsers if you are on Windows. But if you are on another + platform testing with the "default" browser is best. + Normally viewing the page in outside of the web server context + will only show you the content and part of the footer. + This is because the site uses Server Side Includes (SSI) + which most browsers will not process. To look at the + complete content you will need to either run your own Apache + server, or commit the changes and view the changes online + at: + +| Site | URL | Branch | +| --- | --- | --- | +| Beta | | `beta` | +| This is the experimetal version of the + website. Development work should be done here first and + then merged to the live website. | +| Live | | `master` | +| The website the general public will + see. | + + +New Page +-------- + + +To make adding new pages easier there is a [template](/development/template/template.html) to get one + started. There are also `_template_.html` files in + the various site sections which already include the correct + sidebar menus. To start, copy the template to the section of + the website you want to add to and name the new file with a + reasonably clear name. The section is up to you but the + intended type of content for each is: +Introduction +Content to help new users understand what Boost is for + and what it is about. This is the one place where new + visitors are going to visit. Directory: /users +Community +For users who are interested in participating, or are + already participitating, this section describes how the Boost + community of users and developers functions. Directory: + /community +Development +Prospective or existing Boost developers make use of this + section to quickly get to the most frequetly used content. + This section is intended to hold the references to resources + or directly include content that changes frequently. Or + content that only pertains to library developers, although it + may be of more widespread interest as users become more + involved in the Boost community. Directory: + /development +Documentation +This section organizes documents specific to the Boost + libraries. This includes at minimum the library documentation + published with each of the Boost releases. Also included is + access to the community maintained Wiki. Directory: + /doc + +To provide the section user interface look and feel there + are some changes that need to be done to the template: + + +* Each section has a different CSS style reference + included in the head section. This reference needs + to change to one of: + + + + Introduction: + /style-v2/section-boost.css + + Community: + /style-v2/section-community.css + + Development: + /style-v2/section-development.css + + Support: /style-v2/section-support.css + + Documentation: + /style-v2/section-doc.css +* Each section displays a different context sensitive + sidebar menu through the use of SSI. The reference to the + sidebar to display needs to change in the sidebar + section to one of: + + + + Introduction: + /common/sidebar-boost.html + + Community: + /common/sidebar-community.html + + Development: + /common/sidebar-development.html + + Support: /common/sidebar-support.html + + Documentation: /common/sidebar-doc.htmlIn the sidebar section there are two menus + included the first is common to all the pages and contains + the download link and search box. Do not replace that + sidebar (/common/sidebar-common.html). It's the + second #include that should be changed to reflect + the current section. +* Since this is a new page, you will also need to insert + your own corresponding copyright in the footer. +* To insert the new content you need to insert it into the + section-body section. Replace the {stuff} + placeholder with the content you want. In addition you + might also want to change the title, in the head, + and in the section-title section. + + +In addition to the immediate content for the new page one + needs to add an entry to the page so it can be accessed from + the sidebar and index. See below... + + +Menus, Sidebars, and + Index +--------------------------- + + +The various navigation elements are structured to make + adding new entries easy and to keep all places where wuch + entries show consistent. To do this the site makes use of SSI + to reduce the locations that have those entries to + *one*. This means that changing it at the single common + place one doesn't have to worry about changing all the pages, + they all reflect the new content immediately. To add items to + the various section menus edit the corresponding menu file in + the website/common directory: + + +* Introduction: /common/menu-boost.html +* Community: /common/menu-community.html +* Development: /common/menu-development.html +* Documentation: /generated/menu-doc.html + + +Generated Pages +--------------- + + +There are various sections of the web site that are + generated by a php script from quickbook source files: the home + page, news, downloads, version history and feeds. The content + is not directly editable, but instead is generated from source + Quickbook documents. For example, to add a news item one + would: + + +1. Create a new file in the /feed/news directory, + say /feed/news/gui\_review\_ends.qbk. +2. In a shell, run the /site-tools/update.py + script. This will generate the page for the new news item, + regenerate the /feed/news.rss file to include it, + update pages which link to the new item and update the file + /site-tools/state/feed-pages.txt which tracks the + current state of generated files. +3. Add the new files to the SVN repository, and commit. + + +The same procedure applies to the other feeds, but keep in + mind that some feeds may combine entries from more than one + feed subdirectory. Currently this requires Quickbook and Python + in your path. + + +Local + Server +------------- + + +Even though the web site is designed so that one only needs + some basic tools and a web browser to make changes there are + some aspects that are dynamic and hence will not work without + an accompanying web server. To set up local web server for + doing changes to the dynamic content one needs to: + + +1. Install and get working [Apache 2.x.](http://httpd.apache.org/) and [PHP 5.3 or later](http://php.net/) (install PHP as an + Apache module, not as CGI). +2. Set up a symbolic host lookup in your hosts + file by adding "127.0.0.1 boost.localhost". +3. Add a virtual host in Apache to match the new local + host. A likely configuration to work is: +``` + + + ServerName boost.localhost + DocumentRoot "/path/to/boost/website" + + Options +MultiViews +Includes +ExecCGI +FollowSymLinks +Includes + AllowOverride All + Order allow,deny + Allow from all + # For apache 2.4: + # Require all granted + + + +``` +4. Create a local PHP configuration file for Boost specific + settings as + "/path/to/boost/website/common/code/boost\_config\_local.php" + that contains something like: +``` + + + +``` + +For a brief explanation of the settings see the + [common/code/boost\_config.php](https://github.com/boostorg/website/blob/master/common/code/boost_config.php) file. +5. In order to view the documentation, or the build + sub-site, you'll need to setup the appropriate directories. + /build needs to contain the [website + branch of Boost.Build](https://github.com/boostorg/build/tree/website). A soft link to another directory + can be used here (which is how it's done on the server). + STATIC\_DIR needs to be the location of unzipped + copies of the appropriate boost distribution to serve the + documentation. By default, boost\_config.php sets STATIC\_DIR + to $BOOST\_WEBSITE\_SHARED\_DIR/archives/live. Follow steps + similar to this, changing variables as necessary: +``` + +BOOST\_WEBSITE\_SHARED\_DIR=/home/www/shared +mkdir -p $BOOST\_WEBSITE\_SHARED\_DIR/archives/live +cd $BOOST\_WEBSITE\_SHARED\_DIR/archives/live +wget https://boostorg.jfrog.io/artifactory/main/release/1.74.0/source/boost\_1\_74\_0.tar.gz +tar -xvf boost\_1\_74\_0.tar.gz +``` + + +### Ubuntu setup + + +To setup the site on Ubuntu, I needed to do: +``` + +sudo apt-get install apache2 libapache2-mod-php5 +sudo a2enmod headers +sudo a2enmod rewrite +sudo a2enmod include +sudo a2dismod deflate +sudo service apache2 restart +``` + +I had to disable `deflate` because it interacts + badly with php's `virtual` function. + + + + + + + + + diff --git a/doc/_template_.html b/doc/_template_.html new file mode 100644 index 0000000..3e170a2 --- /dev/null +++ b/doc/_template_.html @@ -0,0 +1,24 @@ +--- +title: Boost C++ Libraries +copyright: Rene Rivera 2007. +revised: +--- + + +Boost C++ Libraries + + + +Boost C++ Libraries +=================== + +{stuff} + + + + + + + + + diff --git a/doc/index.html b/doc/index.html new file mode 100644 index 0000000..2827ed2 --- /dev/null +++ b/doc/index.html @@ -0,0 +1,57 @@ +--- +title: Boost C++ Libraries +copyright: Beman Dawes, David Abrahams, 1998-2005. Rene Rivera 2004-2005. +revised: +--- + + +Boost C++ Libraries + + +/\*\*/ + + + +Documentation +============= + +Much work goes into the documentation for the Boost + libraries and tools. The documentation included in the library + and tool release is also available here: + + +Additional information about the testing and release practices, + infrastructure and in progress developments is available on + our [Trac wiki](https://svn.boost.org/trac/boost/). + + +Translations +------------ + + +Boost doesn't have the resources to translate the + documentation itself, but there is at least one separate group + translating the documentation. If you have formed another, tell + us on the [documentation list](/community/groups.html#boostdocs) and + we'll add a link. + + +* [Chinese + translations](http://code.google.com/p/boost-doc-zh/) ([mailing + list](http://groups.google.com/group/boost_doc_translation)) + + + + + + + + + diff --git a/doc/libs/1_36_0/libs/test/docbook/img/boost.test.logo.png b/doc/libs/1_36_0/libs/test/docbook/img/boost.test.logo.png new file mode 100644 index 0000000..89467d9 Binary files /dev/null and b/doc/libs/1_36_0/libs/test/docbook/img/boost.test.logo.png differ diff --git a/doc/libs/1_53_0/libs/pool/doc/images/mb1.png b/doc/libs/1_53_0/libs/pool/doc/images/mb1.png new file mode 100644 index 0000000..b665e77 Binary files /dev/null and b/doc/libs/1_53_0/libs/pool/doc/images/mb1.png differ diff --git a/doc/libs/1_53_0/libs/pool/doc/images/mb2.png b/doc/libs/1_53_0/libs/pool/doc/images/mb2.png new file mode 100644 index 0000000..9ee3124 Binary files /dev/null and b/doc/libs/1_53_0/libs/pool/doc/images/mb2.png differ diff --git a/doc/libs/1_53_0/libs/pool/doc/images/mb3.png b/doc/libs/1_53_0/libs/pool/doc/images/mb3.png new file mode 100644 index 0000000..ffb1f18 Binary files /dev/null and b/doc/libs/1_53_0/libs/pool/doc/images/mb3.png differ diff --git a/doc/libs/1_53_0/libs/pool/doc/images/mb4.png b/doc/libs/1_53_0/libs/pool/doc/images/mb4.png new file mode 100644 index 0000000..74a50db Binary files /dev/null and b/doc/libs/1_53_0/libs/pool/doc/images/mb4.png differ diff --git a/doc/libs/1_53_0/libs/pool/doc/images/pc1.png b/doc/libs/1_53_0/libs/pool/doc/images/pc1.png new file mode 100644 index 0000000..61489b5 Binary files /dev/null and b/doc/libs/1_53_0/libs/pool/doc/images/pc1.png differ diff --git a/doc/libs/1_53_0/libs/pool/doc/images/pc2.png b/doc/libs/1_53_0/libs/pool/doc/images/pc2.png new file mode 100644 index 0000000..a33551c Binary files /dev/null and b/doc/libs/1_53_0/libs/pool/doc/images/pc2.png differ diff --git a/doc/libs/1_53_0/libs/pool/doc/images/pc3.png b/doc/libs/1_53_0/libs/pool/doc/images/pc3.png new file mode 100644 index 0000000..42f475b Binary files /dev/null and b/doc/libs/1_53_0/libs/pool/doc/images/pc3.png differ diff --git a/doc/libs/1_53_0/libs/pool/doc/images/pc4.png b/doc/libs/1_53_0/libs/pool/doc/images/pc4.png new file mode 100644 index 0000000..c0d65d4 Binary files /dev/null and b/doc/libs/1_53_0/libs/pool/doc/images/pc4.png differ diff --git a/doc/libs/1_53_0/libs/pool/doc/images/pc5.png b/doc/libs/1_53_0/libs/pool/doc/images/pc5.png new file mode 100644 index 0000000..f5978aa Binary files /dev/null and b/doc/libs/1_53_0/libs/pool/doc/images/pc5.png differ diff --git a/doc/libs/1_61_0/doc/html/boost_asio/async_op1.png b/doc/libs/1_61_0/doc/html/boost_asio/async_op1.png new file mode 100644 index 0000000..0de7991 Binary files /dev/null and b/doc/libs/1_61_0/doc/html/boost_asio/async_op1.png differ diff --git a/doc/libs/1_61_0/doc/html/boost_asio/async_op2.png b/doc/libs/1_61_0/doc/html/boost_asio/async_op2.png new file mode 100644 index 0000000..9b8d3c0 Binary files /dev/null and b/doc/libs/1_61_0/doc/html/boost_asio/async_op2.png differ diff --git a/doc/libs/1_61_0/doc/html/boost_asio/proactor.png b/doc/libs/1_61_0/doc/html/boost_asio/proactor.png new file mode 100644 index 0000000..a0653b0 Binary files /dev/null and b/doc/libs/1_61_0/doc/html/boost_asio/proactor.png differ diff --git a/doc/libs/1_61_0/doc/html/boost_asio/sync_op.png b/doc/libs/1_61_0/doc/html/boost_asio/sync_op.png new file mode 100644 index 0000000..1232463 Binary files /dev/null and b/doc/libs/1_61_0/doc/html/boost_asio/sync_op.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/alert.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/alert.png new file mode 100644 index 0000000..b4645bc Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/alert.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/blank.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/blank.png new file mode 100644 index 0000000..764bf4f Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/blank.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/1.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/1.png new file mode 100644 index 0000000..6003ad3 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/1.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/10.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/10.png new file mode 100644 index 0000000..0426f51 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/10.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/11.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/11.png new file mode 100644 index 0000000..821afc4 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/11.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/12.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/12.png new file mode 100644 index 0000000..7cec727 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/12.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/13.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/13.png new file mode 100644 index 0000000..5b41e02 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/13.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/14.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/14.png new file mode 100644 index 0000000..de5bdbd Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/14.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/15.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/15.png new file mode 100644 index 0000000..3fd6ac3 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/15.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/2.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/2.png new file mode 100644 index 0000000..f7c1578 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/2.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/3.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/3.png new file mode 100644 index 0000000..3ff0a93 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/3.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/4.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/4.png new file mode 100644 index 0000000..6aa29fc Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/4.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/5.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/5.png new file mode 100644 index 0000000..36e7858 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/5.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/6.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/6.png new file mode 100644 index 0000000..c943676 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/6.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/7.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/7.png new file mode 100644 index 0000000..20940de Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/7.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/8.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/8.png new file mode 100644 index 0000000..d8e34d4 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/8.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/9.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/9.png new file mode 100644 index 0000000..abe6360 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/callouts/9.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/caution.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/caution.png new file mode 100644 index 0000000..5b7809c Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/caution.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/draft.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/draft.png new file mode 100644 index 0000000..0084708 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/draft.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/home.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/home.png new file mode 100644 index 0000000..5584aac Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/home.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/important.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/important.png new file mode 100644 index 0000000..12c90f6 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/important.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/next.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/next.png new file mode 100644 index 0000000..59800b4 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/next.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/next_disabled.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/next_disabled.png new file mode 100644 index 0000000..10a8c59 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/next_disabled.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/note.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/note.png new file mode 100644 index 0000000..d0c3c64 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/note.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/prev.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/prev.png new file mode 100644 index 0000000..d88a40f Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/prev.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/prev_disabled.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/prev_disabled.png new file mode 100644 index 0000000..ab3c17e Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/prev_disabled.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/smiley.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/smiley.png new file mode 100644 index 0000000..30a77f7 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/smiley.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/tip.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/tip.png new file mode 100644 index 0000000..5c4aab3 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/tip.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/toc-blank.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/toc-blank.png new file mode 100644 index 0000000..6ffad17 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/toc-blank.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/toc-minus.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/toc-minus.png new file mode 100644 index 0000000..abbb020 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/toc-minus.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/toc-plus.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/toc-plus.png new file mode 100644 index 0000000..941312c Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/toc-plus.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/up.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/up.png new file mode 100644 index 0000000..17d9c3e Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/up.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/up_disabled.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/up_disabled.png new file mode 100644 index 0000000..e22bc87 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/up_disabled.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/warning.png b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/warning.png new file mode 100644 index 0000000..1c33db8 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/images/warning.png differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/logo.jpg b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/logo.jpg new file mode 100644 index 0000000..a658bbe Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/logo.jpg differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/phase_lattice_2d_0000.jpg b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/phase_lattice_2d_0000.jpg new file mode 100644 index 0000000..f98703e Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/phase_lattice_2d_0000.jpg differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/phase_lattice_2d_0100.jpg b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/phase_lattice_2d_0100.jpg new file mode 100644 index 0000000..7862839 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/phase_lattice_2d_0100.jpg differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/phase_lattice_2d_1000.jpg b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/phase_lattice_2d_1000.jpg new file mode 100644 index 0000000..e0ee037 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/phase_lattice_2d_1000.jpg differ diff --git a/doc/libs/1_61_0/libs/numeric/odeint/doc/html/solar_system.jpg b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/solar_system.jpg new file mode 100644 index 0000000..b89c3b3 Binary files /dev/null and b/doc/libs/1_61_0/libs/numeric/odeint/doc/html/solar_system.jpg differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/alert.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/alert.png new file mode 100644 index 0000000..101b5f7 Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/alert.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/1.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/1.png new file mode 100644 index 0000000..6003ad3 Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/1.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/10.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/10.png new file mode 100644 index 0000000..0426f51 Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/10.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/11.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/11.png new file mode 100644 index 0000000..821afc4 Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/11.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/12.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/12.png new file mode 100644 index 0000000..7cec727 Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/12.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/13.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/13.png new file mode 100644 index 0000000..5b41e02 Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/13.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/14.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/14.png new file mode 100644 index 0000000..de5bdbd Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/14.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/15.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/15.png new file mode 100644 index 0000000..3fd6ac3 Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/15.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/2.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/2.png new file mode 100644 index 0000000..f7c1578 Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/2.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/3.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/3.png new file mode 100644 index 0000000..3ff0a93 Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/3.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/4.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/4.png new file mode 100644 index 0000000..6aa29fc Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/4.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/5.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/5.png new file mode 100644 index 0000000..36e7858 Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/5.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/6.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/6.png new file mode 100644 index 0000000..c943676 Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/6.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/7.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/7.png new file mode 100644 index 0000000..20940de Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/7.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/8.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/8.png new file mode 100644 index 0000000..d8e34d4 Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/8.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/9.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/9.png new file mode 100644 index 0000000..abe6360 Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/callouts/9.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/caution.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/caution.png new file mode 100644 index 0000000..4be6d07 Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/caution.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/important.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/important.png new file mode 100644 index 0000000..994325e Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/important.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/note.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/note.png new file mode 100644 index 0000000..c425ecb Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/note.png differ diff --git a/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/tip.png b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/tip.png new file mode 100644 index 0000000..f5e5432 Binary files /dev/null and b/doc/libs/1_61_0/libs/spirit/repository/doc/html/images/tip.png differ diff --git a/doc/libs/1_62_0/doc/html/boost_asio/async_op1.png b/doc/libs/1_62_0/doc/html/boost_asio/async_op1.png new file mode 100644 index 0000000..0de7991 Binary files /dev/null and b/doc/libs/1_62_0/doc/html/boost_asio/async_op1.png differ diff --git a/doc/libs/1_62_0/doc/html/boost_asio/async_op2.png b/doc/libs/1_62_0/doc/html/boost_asio/async_op2.png new file mode 100644 index 0000000..9b8d3c0 Binary files /dev/null and b/doc/libs/1_62_0/doc/html/boost_asio/async_op2.png differ diff --git a/doc/libs/1_62_0/doc/html/boost_asio/proactor.png b/doc/libs/1_62_0/doc/html/boost_asio/proactor.png new file mode 100644 index 0000000..a0653b0 Binary files /dev/null and b/doc/libs/1_62_0/doc/html/boost_asio/proactor.png differ diff --git a/doc/libs/1_62_0/doc/html/boost_asio/sync_op.png b/doc/libs/1_62_0/doc/html/boost_asio/sync_op.png new file mode 100644 index 0000000..1232463 Binary files /dev/null and b/doc/libs/1_62_0/doc/html/boost_asio/sync_op.png differ diff --git a/doc/libs/1_77_0/libs/leaf/doc/html/index.html b/doc/libs/1_77_0/libs/leaf/doc/html/index.html new file mode 100644 index 0000000..18e5356 --- /dev/null +++ b/doc/libs/1_77_0/libs/leaf/doc/html/index.html @@ -0,0 +1,6596 @@ +--- +title: LEAF +copyright: © 2018-2021 Emil Dotchevski. Distributed under the Boost Software License, Version 1.0. +revised: +--- + +LEAF + +function switch\_style() +{ + var i, tag; + for( i=0, tag=document.getElementsByTagName("link"); i`](#tutorial-async_result) + - [Using Exception Handling](#tutorial-async_eh) + + [Classification of Failures](#tutorial-classification) + + [Converting Exceptions to `result`](#tutorial-exception_to_result) + + [Using `error_monitor` to Report Arbitrary Errors from C-callbacks](#tutorial-on_error_in_c_callbacks) + + [Diagnostic Information](#tutorial-diagnostic_information) + + [Working with `std::error_code`, `std::error_condition`](#tutorial-std_error_code) + - [Introduction](#_introduction) + - [Support in LEAF](#_support_in_leaf) + + [Boost Exception Integration](#tutorial-boost_exception_integration) +* [Examples](#example) +* [Synopsis](#synopsis) + + [Error Reporting](#synopsis-reporting) + - [`error.hpp`](#error.hpp) + - [`common.hpp`](#common.hpp) + - [`result.hpp`](#result.hpp) + - [`on_error.hpp`](#on_error.hpp) + - [`exception.hpp`](#exception.hpp) + - [`capture.hpp`](#_capture_hpp) + + [Error Handling](#tutorial-handling) + - [`context.hpp`](#context.hpp) + - [`handle_errors.hpp`](#handle_errors.hpp) + - [`pred.hpp`](#pred.hpp) +* [Reference: Functions](#functions) + + [`activate_context`](#activate_context) + + [`capture`](#capture) + + [`context_type_from_handlers`](#context_type_from_handlers) + + [`current_error`](#current_error) + + [`exception`](#exception) + + [`exception_to_result`](#exception_to_result) + + [`make_context`](#make_context) + + [`make_shared_context`](#make_shared_context) + + [`new_error`](#new_error) + + [`on_error`](#on_error) + + [`try_catch`](#try_catch) + + [`try_handle_all`](#try_handle_all) + + [`try_handle_some`](#try_handle_some) +* [Reference: Types](#types) + + [`context`](#context) + - [Constructors](#context::context) + - [`activate`](#context::activate) + - [`deactivate`](#context::deactivate) + - [`handle_error`](#context::handle_error) + - [`is_active`](#context::is_active) + - [`print`](#context::print) + - [`propagate`](#context::propagate) + + [`context_activator`](#context_activator) + + [`diagnostic_info`](#diagnostic_info) + + [`error_id`](#error_id) + - [Constructors](#error_id::error_id) + - [`is_error_id`](#is_error_id) + - [`load`](#error_id::load) + - [`operator==`, `!=`, `<`](#error_id::comparison_operators) + - [`operator bool`](#error_id::operator_bool) + - [`to_error_code`](#error_id::to_error_code) + - [`value`](#error_id::value) + + [`error_monitor`](#error_monitor) + + [`e_api_function`](#e_api_function) + + [`e_at_line`](#e_at_line) + + [`e_errno`](#e_errno) + + [`e_file_name`](#e_file_name) + + [`e_LastError`](#e_LastError) + + [`e_source_location`](#e_source_location) + + [`e_type_info_name`](#e_type_info_name) + + [`error_info`](#error_info) + + [`polymorphic_context`](#polymorphic_context) + + [`result`](#result) + - [Constructors](#result::result) + - [`error`](#result::error) + - [`load`](#result::load) + - [`operator=`](#result::operator_eq) + - [`operator bool`](#result::operator_bool) + - [`value`, `operator*`, `->`](#result::value) + + [`verbose_diagnostic_info`](#verbose_diagnostic_info) +* [Reference: Predicates](#predicates) + + [`catch_`](#catch_) + + [`if_not`](#if_not) + + [`match`](#match) + + [`match_member`](#match_member) + + [`match_value`](#match_value) +* [Reference: Traits](#traits) + + [`is_predicate`](#is_predicate) + + [`is_result_type`](#is_result_type) +* [Reference: Macros](#macros) + + [`BOOST_LEAF_`](#_boost_leaf) + - [`ASSIGN`](#BOOST_LEAF_ASSIGN) + - [`AUTO`](#BOOST_LEAF_AUTO) + - [`CHECK`](#BOOST_LEAF_CHECK) + - [`EXCEPTION`](#BOOST_LEAF_EXCEPTION) + - [`NEW_ERROR`](#BOOST_LEAF_NEW_ERROR) + - [`THROW_EXCEPTION`](#BOOST_LEAF_THROW_EXCEPTION) +* [Design](#rationale) + + [Rationale](#_rationale) + + [Critique 1: Error Types Do Not Participate in Function Signatures](#exception_specifications) + + [Critique 2: LEAF Does Not Facilitate Mapping Between Different Error Types](#translation) + + [Critique 3: LEAF Does Not Treat Low Level Error Types as Implementation Details](#errors_are_not_implementation_details) +* [Alternatives to LEAF](#_alternatives_to_leaf) + + [Comparison to Boost Exception](#boost_exception) + + [Comparison to Boost Outcome](#boost_outcome) + - [Design Differences](#_design_differences) + - [The Interoperability Problem](#interoperability) +* [Benchmark](#_benchmark) +* [Running the Unit Tests](#_running_the_unit_tests) + + [Meson Build](#_meson_build) + + [Boost Build](#_boost_build) +* [Configuration Macros](#configuration) +* [Limitations](#_limitations) +* [Acknowledgements](#_acknowledgements) + + +[GitHub](https://github.com/boostorg/leaf) | [PDF](https://boostorg.github.io/leaf/leaf.pdf) + + + +Abstract +-------- + +Boost LEAF is a lightweight error handling library for C++11. Features: + + + +* Small single-header format, no dependencies. +* Designed for maximum efficiency ("happy" path and "sad" path). +* No dynamic memory allocations, even with heavy payloads. +* O(1) transport of arbitrary error types (independent of call stack depth). +* Can be used with or without exception handling. +* Support for multi-thread programming. + + + + +| [Introduction](#introduction) | [Tutorial](#tutorial) | [Synopsis](#synopsis) | [Whitepaper](https://github.com/boostorg/leaf/blob/master/doc/whitepaper.md) | [Benchmark](https://github.com/boostorg/leaf/blob/master/benchmark/benchmark.md) | Reference: [Functions](#functions) | [Types](#types) | [Predicates](#predicates) | [Traits](#traits) | [Macros](#macros) | +LEAF is designed with a strong bias towards the common use case where callers of functions which may fail check for success and forward errors up the call stack but do not handle them. In this case, only a trivial success-or-failure discriminant is transported. Actual error objects are communicated directly to the error-handling scope, skipping the intermediate check-only frames altogether. + + + +Support +------- + +* [cpplang on Slack](https://Cpplang.slack.com) (use the `#boost` channel) +* [Boost Users Mailing List](https://lists.boost.org/mailman/listinfo.cgi/boost-users) +* [Boost Developers Mailing List](https://lists.boost.org/mailman/listinfo.cgi/boost) +* [Report an issue](https://github.com/boostorg/leaf/issues) on GitHub + + + +Portability +----------- + +LEAF requires only C++11, but is tested on many compiler versions and C++ standards. + +The library uses thread-local storage, except when multi-threading is disabled (e.g. on some embedded platforms). See [Configuration Macros](#configuration). + + + +Distribution +------------ + + + +There are three distribution channels: + +* LEAF is included in official [Boost](https://www.boost.org/) releases, starting with Boost 1.75. +* The source code is hosted on [GitHub](https://github.com/boostorg/leaf). +* For maximum portability, the latest LEAF release is also available in single-header format: simply download [leaf.hpp](https://raw.githubusercontent.com/boostorg/leaf/gh-pages/leaf.hpp) (direct download link). + + + +| | | +| --- | --- | +| | +LEAF does not depend on Boost or other libraries. + | + + + +Five Minute Introduction +------------------------ + +We’ll implement two versions of the same simple program: one using the LEAF `noexcept` API to handle errors, and another using the exception-handling API. + +### `noexcept` API +We’ll write a short but complete program that reads a text file in a buffer and prints it to `std::cout`, using LEAF to handle errors without exception handling. + + + +| | | +| --- | --- | +| | +LEAF provides an [Exception-Handling API](#introduction-eh) as well. + | + +We’ll skip to the chase and start with the `main` function: it will try several operations as needed and handle all the errors that occur. Did I say **all** the errors? I did, so we’ll use `leaf::try_handle_all`. It has the following signature: + + + +``` +template +<> try\_handle\_all( TryBlock && try\_block, Handler && ... handler ); +``` + +`TryBlock` is a function type, required to return a `result` — for example, `leaf::result` — that holds a value of type `T` or else indicates a failure. + +The first thing `try_handle_all` does is invoke the `try_block` function. If the returned object `r` indicates success, `try_handle_all` unwraps it, returning the contained `r.value()`; otherwise it calls the first suitable error handling function from the `handler…​` list. + +We’ll see later just what kind of a `TryBlock` will our `main` function pass to `try_handle_all`, but first, let’s look at the juicy error-handling part. In case of an error, LEAF will consider each of the error handlers, in order, and call the first suitable match: + + + +``` +int main( int argc, char const \* argv[] ) +{ + return leaf::try\_handle\_all( + + [&]() -> leaf::result + { + // The TryBlock goes here, we'll see it later + }, + + // Error handlers below: + + [](leaf::match, leaf::match\_value, leaf::e\_file\_name const & fn) + { **(1)** + std::cerr << "File not found: " << fn.value << std::endl; + return 1; + }, + + [](leaf::match, leaf::e\_errno const & errn, leaf::e\_file\_name const & fn) + { **(2)** + std::cerr << "Failed to open " << fn.value << ", errno=" << errn << std::endl; + return 2; + }, + + [](leaf::match, leaf::e\_errno const \* errn, leaf::e\_file\_name const & fn) + { **(3)** + std::cerr << "Failed to access " << fn.value; + if( errn ) + std::cerr << ", errno=" << \*errn; + std::cerr << std::endl; + return 3; + }, + + [](leaf::match, leaf::e\_errno const & errn) + { **(4)** + std::cerr << "Output error, errno=" << errn << std::endl; + return 4; + }, + + [](leaf::match) + { **(5)** + std::cout << "Bad command line argument" << std::endl; + return 5; + }, + + [](leaf::error\_info const & unmatched) + { **(6)** + std::cerr << + "Unknown failure detected" << std::endl << + "Cryptic diagnostic information follows" << std::endl << + unmatched; + return 6; + } + ); +} +``` + + + +| | | +| --- | --- | +| **1** | This handler will be called if the detected error includes: +• an object of type `enum error_code` equal to the value `open_error`, and +• an object of type `leaf::e_errno` that has `.value` equal to `ENOENT`, and +• an object of type `leaf::e_file_name`. +In short, it handles "file not found" errors. | +| **2** | This handler will be called if the detected error includes: +• an object of type `enum error_code` equal to `open_error`, and +• an object of type `leaf::e_errno` (regardless of its `.value`), and +• an object of type `leaf::e_file_name`. +In short, it will handle other "file open" errors. | +| **3** | This handler will be called if the detected error includes: +• an object of type `enum error_code` equal to any of `size_error`, `read_error`, `eof_error`, and +• an optional object of type `leaf::e_errno` (regardless of its `.value`), and +• an object of type `leaf::e_file_name`. | +| **4** | This handler will be called if the detected error includes: +• an object of type `enum error_code` equal to `output_error`, and +• an object of type `leaf::e_errno` (regardless of its `.value`), | +| **5** | This handler will be called if the detected error includes an object of type `enum error_code` equal to `bad_command_line`. | +| **6** | This last handler is a catch-all for any error, in case no other handler could be selected: it prints diagnostic information to help debug logic errors in the program, since it failed to find an appropriate error handler for the error condition it encountered. | + + + +| | | +| --- | --- | +| | +It is critical to understand that the error handlers are considered in order, rather than by finding a "best match". No error handler is "better" than the others: LEAF will call the first one for which all of the arguments can be supplied using the available error objects. + | + +Now, reading and printing a file may not seem like a complex job, but let’s split it into several functions, each communicating failures using `leaf::result`: + + + +``` +leaf::result parse\_command\_line( int argc, char const \* argv[] ) noexcept; **(1)** + +leaf::result> file\_open( char const \* file\_name ) noexcept; **(2)** + +leaf::result file\_size( FILE & f ) noexcept; **(3)** + +leaf::result file\_read( FILE & f, void \* buf, int size ) noexcept; **(4)** +``` + + + +| | | +| --- | --- | +| **1** | Parse the command line, return the file name. | +| **2** | Open a file for reading. | +| **3** | Return the size of the file. | +| **4** | Read size bytes from f into buf. | + +For example, let’s look at `file_open`: + + + +``` +leaf::result> file\_open( char const \* file\_name ) noexcept +{ + if( FILE \* f = fopen(file\_name,"rb") ) + return std::shared\_ptr(f,&fclose); + else + return leaf::new\_error(open\_error, leaf::e\_errno{errno}); +} +``` + +If `fopen` succeeds, we return a `shared_ptr` which will automatically call `fclose` as needed. If `fopen` fails, we report an error by calling `new_error`, which takes any number of error objects to communicate with the error. In this case we pass the system `errno` (LEAF defines `struct e_errno {int value;}`), and our own error code value, `open_error`. + +Here is our complete error code `enum`: + + + +``` +enum error\_code +{ + bad\_command\_line = 1, + open\_error, + read\_error, + size\_error, + eof\_error, + output\_error +}; +``` + +We’re now ready to look at the `TryBlock` we’ll pass to `try_handle_all`. It does all the work, bails out if it encounters an error: + + + +``` +int main( int argc, char const \* argv[] ) +{ + return leaf::try\_handle\_all( + + [&]() -> leaf::result + { + leaf::result file\_name = parse\_command\_line(argc,argv); + if( !file\_name ) + return file\_name.error(); +``` + +Wait, what’s this, if "error" return "error"? There is a better way: we’ll use `BOOST_LEAF_AUTO`. It takes a `result` and bails out in case of a failure (control leaves the calling function), otherwise uses the passed variable to access the `T` value stored in the `result` object. + +This is what our `TryBlock` really looks like: + + + +``` +int main( int argc, char const \* argv[] ) +{ + return leaf::try\_handle\_all( + + [&]() -> leaf::result **(1)** + { + BOOST\_LEAF\_AUTO(file\_name, parse\_command\_line(argc,argv)); **(2)** + + auto load = leaf::on\_error( leaf::e\_file\_name{file\_name} ); **(3)** + + BOOST\_LEAF\_AUTO(f, file\_open(file\_name)); **(4)** + + BOOST\_LEAF\_AUTO(s, file\_size(\*f)); **(4)** + + std::string buffer( 1 + s, '\0' ); + BOOST\_LEAF\_CHECK(file\_read(\*f, &buffer[0], buffer.size()-1)); **(4)** + + std::cout << buffer; + std::cout.flush(); + if( std::cout.fail() ) + return leaf::new\_error(output\_error, leaf::e\_errno{errno}); + + return 0; + }, + + .... **(5)** + + ); **(6)** +} +``` + + + +| | | +| --- | --- | +| **1** | Our `TryBlock` returns a `result`. In case of success, it will hold `0`, which will be returned from `main` to the OS. | +| **2** | If `parse_command_line` returns an error, we forward that error to `try_handle_all` (which invoked us) verbatim. Otherwise, `BOOST_LEAF_AUTO` gets us a variable, `file_name`, to access the parsed string. | +| **3** | From now on, all errors escaping this scope will automatically communicate the (now successfully parsed from the command line) file name (LEAF defines `struct e_file_name {std::string value;}`). This is as if every time one of the following functions wants to report an error, `on_error` says "wait, associate this `e_file_name` object with the error, it’s important!" | +| **4** | Call more functions, forward each failure to the caller. | +| **5** | List of error handlers goes here (we saw this earlier). | +| **6** | This concludes the `try_handle_all` arguments — as well as our program! | + +Nice and simple! Writing the `TryBlock`, we focus on the "happy" path — if we encounter any error we just return it to `try_handle_all` for processing. Well, that’s if we’re being good and using RAII for automatic clean-up — which we are, `shared_ptr` will automatically close the file for us. + + + +| | | +| --- | --- | +| | +The complete program from this tutorial is available [here](https://github.com/boostorg/leaf/blob/master/example/print_file/print_file_result.cpp?ts=4). The [other](https://github.com/boostorg/leaf/blob/master/example/print_file/print_file_eh.cpp?ts=4) version of the same program uses exception handling to report errors (see [below](#introduction-eh)). + | + + +--- + +### Exception-Handling API +And now, we’ll write the same program that reads a text file in a buffer and prints it to `std::cout`, this time using exceptions to report errors. First, we need to define our exception class hierarchy: + + + +``` +struct bad\_command\_line: std::exception { }; +struct input\_error: std::exception { }; +struct open\_error: input\_error { }; +struct read\_error: input\_error { }; +struct size\_error: input\_error { }; +struct eof\_error: input\_error { }; +struct output\_error: std::exception { }; +``` + +We’ll split the job into several functions, communicating failures by throwing exceptions: + + + +``` +char const \* parse\_command\_line( int argc, char const \* argv[] ); **(1)** + +std::shared\_ptr file\_open( char const \* file\_name ); **(2)** + +int file\_size( FILE & f ); **(3)** + +void file\_read( FILE & f, void \* buf, int size ); **(4)** +``` + + + +| | | +| --- | --- | +| **1** | Parse the command line, return the file name. | +| **2** | Open a file for reading. | +| **3** | Return the size of the file. | +| **4** | Read size bytes from f into buf. | + +The `main` function brings everything together and handles all the exceptions that are thrown, but instead of using `try` and `catch`, it will use the function template `leaf::try_catch`, which has the following signature: + + + +``` +template +<> try\_catch( TryBlock && try\_block, Handler && ... handler ); +``` + +`TryBlock` is a function type that takes no arguments; `try_catch` simply returns the value returned by the `try_block`, catching any exception it throws, in which case it calls the first suitable error handling function from the `handler…​` list. + +Let’s first look at the `TryBlock` our `main` function passes to `try_catch`: + + + +``` +int main( int argc, char const \* argv[] ) +{ + return leaf::try\_catch( + + [&] **(1)** + { + char const \* file\_name = parse\_command\_line(argc,argv); **(2)** + + auto load = leaf::on\_error( leaf::e\_file\_name{file\_name} ); **(3)** + + std::shared\_ptr f = file\_open( file\_name ); **(2)** + + std::string buffer( 1+file\_size(\*f), '\0' ); **(2)** + file\_read(\*f, &buffer[0], buffer.size()-1); **(2)** + + std::cout << buffer; + std::cout.flush(); + if( std::cout.fail() ) + throw leaf::exception(output\_error{}, leaf::e\_errno{errno}); + + return 0; + }, + + .... **(4)** + + ); **(5)** +} +``` + + + +| | | +| --- | --- | +| **1** | Except if it throws, our `TryBlock` returns `0`, which will be returned from `main` to the OS. | +| **2** | If any of the functions we call throws, `try_catch` will find an appropriate handler to invoke (below). | +| **3** | From now on, all exceptions escaping this scope will automatically communicate the (now successfully parsed from the command line) file name (LEAF defines `struct e_file_name {std::string value;}`). This is as if every time one of the following functions wants to throw an exception, `on_error` says "wait, associate this `e_file_name` object with the exception, it’s important!" | +| **4** | List of error handlers goes here. We’ll see that later. | +| **5** | This concludes the `try_catch` arguments — as well as our program! | + +As it is always the case when using exception handling, as long as our `TryBlock` is exception-safe, we can focus on the "happy" path. Of course, our `TryBlock` is exception-safe, since `shared_ptr` will automatically close the file for us in case an exception is thrown. + +Now let’s look at the second part of the call to `try_catch`, which lists the error handlers: + + + +``` +int main( int argc, char const \* argv[] ) +{ + return leaf::try\_catch( + [&] + { + // The TryBlock goes here (we saw that earlier) + }, + + // Error handlers below: + + [](open\_error &, leaf::match\_value, leaf::e\_file\_name const & fn) + { **(1)** + std::cerr << "File not found: " << fn.value << std::endl; + return 1; + }, + + [](open\_error &, leaf::e\_file\_name const & fn, leaf::e\_errno const & errn) + { **(2)** + std::cerr << "Failed to open " << fn.value << ", errno=" << errn << std::endl; + return 2; + }, + + [](input\_error &, leaf::e\_errno const \* errn, leaf::e\_file\_name const & fn) + { **(3)** + std::cerr << "Failed to access " << fn.value; + if( errn ) + std::cerr << ", errno=" << \*errn; + std::cerr << std::endl; + return 3; + }, + + [](output\_error &, leaf::e\_errno const & errn) + { **(4)** + std::cerr << "Output error, errno=" << errn << std::endl; + return 4; + }, + + [](bad\_command\_line &) + { **(5)** + std::cout << "Bad command line argument" << std::endl; + return 5; + }, + + [](leaf::error\_info const & unmatched) + { **(6)** + std::cerr << + "Unknown failure detected" << std::endl << + "Cryptic diagnostic information follows" << std::endl << + unmatched; + return 6; + } ); +} +``` + + + +| | | +| --- | --- | +| **1** | This handler will be called if: +• an `open_error` exception was caught, with +• an object of type `leaf::e_errno` that has `.value` equal to `ENOENT`, and +• an object of type `leaf::e_file_name`. +In short, it handles "file not found" errors. | +| **2** | This handler will be called if: +• an `open_error` exception was caught, with +• an object of type `leaf::e_errno` (regardless of its `.value`), and +• an object of type `leaf::e_file_name`. +In short, it handles other "file open" errors. | +| **3** | This handler will be called if: +• an `input_error` exception was caught (which is a base type), with +• an optional object of type `leaf::e_errno` (regardless of its `.value`), and +• an object of type `leaf::e_file_name`. | +| **4** | This handler will be called if: +• an `output_error` exception was caught, with +• an object of type `leaf::e_errno` (regardless of its `.value`), | +| **5** | This handler will be called if a `bad_command_line` exception was caught. | +| **6** | If `try_catch` fails to find an appropriate handler, it will re-throw the exception. But this is the `main` function which should handle all exceptions, so this last handler matches any error and prints diagnostic information, to help debug logic errors. | + + + +| | | +| --- | --- | +| | +It is critical to understand that the error handlers are considered in order, rather than by finding a "best match". No error handler is "better" than the others: LEAF will call the first one for which all of the arguments can be supplied using the available error objects. + | + +To conclude this introduction, let’s look at one of the error-reporting functions that our `TryBlock` calls, for example `file_open`: + + + +``` +std::shared\_ptr file\_open( char const \* file\_name ) +{ + if( FILE \* f = fopen(file\_name,"rb") ) + return std::shared\_ptr(f,&fclose); + else + throw leaf::exception(open\_error{}, leaf::e\_errno{errno}); +} +``` + +If `fopen` succeeds, it returns a `shared_ptr` which will automatically call `fclose` as needed. If `fopen` fails, we throw the exception object returned by `leaf::exception`, which in this case is of type that derives from `open_error`; the passed `e_errno` object will be associated with the exception. + + + +| | | +| --- | --- | +| | `try_catch` works with any exception, not only exceptions thrown using `leaf::exception`. + | + + + +| | | +| --- | --- | +| | +The complete program from this tutorial is available [here](https://github.com/boostorg/leaf/blob/master/example/print_file/print_file_eh.cpp?ts=4). The [other](https://github.com/boostorg/leaf/blob/master/example/print_file/print_file_result.cpp?ts=4) version of the same program does not use exception handling to report errors (see the [previous introduction](#introduction-result)). + | + +Tutorial +-------- + +This section assumes the reader has basic understanding of using LEAF to handle errors; see [Five Minute Introduction](#introduction). + +### Error Communication Model +#### `noexcept` API +The following figure illustrates how error objects are transported when using LEAF without exception handling: + + +![LEAF 1](LEAF-1.png) + +Figure 1. LEAF noexcept Error Communication Model + + +The arrows pointing down indicate the call stack order for the functions `f1` through `f5`: higher level functions calling lower level functions. + +Note the call to `on_error` in `f3`: it caches the passed error objects of types `E1` and `E3` in the returned object `load`, where they stay ready to be communicated in case any function downstream from `f3` reports an error. Presumably these objects are relevant to any such failure, but are conveniently accessible only in this scope. + +*Figure 1* depicts the condition where `f5` has detected an error. It calls `leaf::new_error` to create a new, unique `error_id`. The passed error object of type `E2` is immediately loaded in the first active `context` object that provides static storage for it, found in any calling scope (in this case `f1`), and is associated with the newly-generated `error_id` (solid arrow); + +The `error_id` itself is returned to the immediate caller `f4`, usually stored in a `result` object `r`. That object takes the path shown by dashed arrows, as each error-neutral function, unable to handle the failure, forwards it to its immediate caller in the returned value — until an error-handling scope is reached. + +When the destructor of the `load` object in `f3` executes, it detects that `new_error` was invoked after its initialization, loads the cached objects of types `E1` and `E3` in the first active `context` object that provides static storage for them, found in any calling scope (in this case `f1`), and associates them with the last generated `error_id` (solid arrow). + +When the error-handling scope `f1` is reached, it probes `ctx` for any error objects associated with the `error_id` it received from `f2`, and processes a list of user-provided error handlers, in order, until it finds a handler with arguments that can be supplied using the available (in `ctx`) error objects. That handler is called to deal with the failure. + + +#### Exception-Handling API +The following figure illustrates the slightly different error communication model used when errors are reported by throwing exceptions: + + +![LEAF 2](LEAF-2.png) + +Figure 2. LEAF Error Communication Model Using Exception Handling + + +The main difference is that the call to `new_error` is implicit in the call to the function template `leaf::exception`, which in this case takes an exception object of type `Ex`, and returns an exception object of unspecified type that derives publicly from `Ex`. + + +#### Interoperability +Ideally, when an error is detected, a program using LEAF would always call [`new_error`](#new_error), ensuring that each encountered failure is definitely assigned a unique [`error_id`](#error_id), which then is reliably delivered, by an exception or by a `result` object, to the appropriate error-handling scope. + +Alas, this is not always possible. + +For example, the error may need to be communicated through uncooperative 3rd-party interfaces. To facilitate this transmission, a error ID may be encoded in a `std::error_code`. As long as a 3rd-party interface understands `std::error_code`, it should be compatible with LEAF. + +Further, it is sometimes necessary to communicate errors through an interface that does not even use `std::error_code`. An example of this is when an external lower-level library throws an exception, which is unlikely to be able to carry an `error_id`. + +To support this tricky use case, LEAF provides the function [`current_error`](#current_error), which returns the error ID returned by the most recent call (from this thread) to [`new_error`](#new_error). One possible approach to solving the problem is to use the following logic (implemented by the [`error_monitor`](#error_monitor) type): + +1. Before calling the uncooperative API, call [`current_error`](#current_error) and cache the returned value. +2. Call the API, then call `current_error` again: + + 1. If this returns the same value as before, pass the error objects to `new_error` to associate them with a new `error_id`; + 2. else, associate the error objects with the `error_id` value returned by the second call to `current_error`. + +Note that if the above logic is nested (e.g. one function calling another), `new_error` will be called only by the inner-most function, because that call guarantees that all calling functions will hit the `else` branch. + + + +| | | +| --- | --- | +| | +To avoid ambiguities, whenever possible, use the [`exception`](#exception) function template when throwing exceptions to ensure that the exception object transports a unique `error_id`; better yet, use the [`THROW_EXCEPTION`](#BOOST_LEAF_THROW_EXCEPTION) macro, which in addition will capture `__FILE__` and `__LINE__`. + | + + +--- + + +### Loading of Error Objects +To load an error object is to move it into an active [`context`](#context), usually local to a [`try_handle_some`](#try_handle_some), a [`try_handle_all`](#try_handle_all) or a [`try_catch`](#try_catch) scope in the calling thread, where it becomes uniquely associated with a specific [`error_id`](#error_id) — or discarded if storage is not available. + +Various LEAF functions take a list of error objects to load. As an example, if a function `copy_file` that takes the name of the input file and the name of the output file as its arguments detects a failure, it could communicate an error code `ec`, plus the two relevant file names using [`new_error`](#new_error): + + + +``` +return leaf::new\_error(ec, e\_input\_name{n1}, e\_output\_name{n2}); +``` + +Alternatively, error objects may be loaded using a `result` that is already communicating an error. This way they become associated with that error, rather than with a new error: + + + +``` +leaf::result f() noexcept; + +leaf::result g( char const \* fn ) noexcept +{ + if( leaf::result r = f() ) + { **(1)** + ....; + return { }; + } + else + { + return r.load( e\_file\_name{fn} ); **(2)** + } +} +``` + +[`result`](#result) | [`load`](#result::load) + + + +| | | +| --- | --- | +| **1** | Success! Use `r.value()`. | +| **2** | `f()` has failed; here we associate an additional `e_file_name` with the error. However, this association occurs iff in the call stack leading to `g` there are error handlers that take an `e_file_name` argument. Otherwise, the object passed to `load` is discarded. In other words, the passed objects are loaded iff the program actually uses them to handle errors. | + +Besides error objects, `load` can take function arguments: + +* If we pass a function that takes no arguments, it is invoked, and the returned error object is loaded. +Consider that if we pass to `load` an error object that is not needed by any error handler, it will be discarded. If the object is expensive to compute, it would be better if the computation can be skipped as well. Passing a function with no arguments to `load` is an excellent way to achieve this behavior: + + + +``` +struct info { .... }; + +info compute\_info() noexcept; + +leaf::result operation( char const \* file\_name ) noexcept +{ + if( leaf::result r = try\_something() ) + { **(1)** + .... + return { }; + } + else + { + return r.load( **(2)** + [&] + { + return compute\_info(); + } ); + } +} +``` + +[`result`](#result) | [`load`](#result::load) + + + +| | | +| --- | --- | +| **1** | Success! Use `r.value()`. | +| **2** | `try_something` has failed; `compute_info` will only be called if an error handler exists which takes a `info` argument. | +* If we pass a function that takes a single argument of type `E &`, LEAF calls the function with the object of type `E` currently loaded in an active `context`, associated with the error. If no such object is available, a new one is default-initialized and then passed to the function. +For example, if an operation that involves many different files fails, a program may provide for collecting all relevant file names in a `e_relevant_file_names` object: + + + +``` +struct e\_relevant\_file\_names +{ + std::vector value; +}; + +leaf::result operation( char const \* file\_name ) noexcept +{ + if( leaf::result r = try\_something() ) + { **(1)** + .... + return { }; + } + else + { + return r.load( **(2)** + [&](e\_relevant\_file\_names & e) + { + e.value.push\_back(file\_name); + } ); + } +} +``` + +[`result`](#result) | [`load`](#result::load) + + + +| | | +| --- | --- | +| **1** | Success! Use `r.value()`. | +| **2** | `try_something` has failed — add `file_name` to the `e_relevant_file_names` object, associated with the `error_id` communicated in `r`. Note, however, that the passed function will only be called iff in the call stack there are error handlers that take an `e_relevant_file_names` object. | + + +--- + +### Using `on_error` +It is not typical for an error-reporting function to be able to supply all of the data needed by a suitable error-handling function in order to recover from the failure. For example, a function that reports `FILE` operation failures may not have access to the file name, yet an error handling function needs it in order to print a useful error message. + +Of course the file name is typically readily available in the call stack leading to the failed `FILE` operation. Below, while `parse_info` can’t report the file name, `parse_file` can and does: + + + +``` +leaf::result parse\_info( FILE \* f ) noexcept; **(1)** + +leaf::result parse\_file( char const \* file\_name ) noexcept +{ + auto load = leaf::on\_error(leaf::e\_file\_name{file\_name}); **(2)** + + if( FILE \* f = fopen(file\_name,"r") ) + { + auto r = parse\_info(f); + fclose(f); + return r; + } + else + return leaf::new\_error( error\_enum::file\_open\_error ); +} +``` + +[`result`](#result) | [`on_error`](#on_error) | [`new_error`](#new_error) + + + +| | | +| --- | --- | +| **1** | `parse_info` parses `f`, communicating errors using `result`. | +| **2** | Using `on_error` ensures that the file name is included with any error reported out of `parse_file`. All we need to do is hold on to the returned object `load`; when it expires, if an error is being reported, the passed `e_file_name` value will be automatically associated with it. | + + + +| | | +| --- | --- | +| | `on_error` —  like `load` — can be passed any number of arguments. + | + +When we invoke `on_error`, we can pass three kinds of arguments: + +1. Actual error objects (like in the example above); +2. Functions that take no arguments and return an error object; +3. Functions that take an error object by mutable reference. + +If we want to use `on_error` to capture `errno`, we can’t just pass [`e_errno`](#e_errno) to it, because at that time it hasn’t been set (yet). Instead, we’d pass a function that returns it: + + + +``` +void read\_file(FILE \* f) { + + auto load = leaf::on\_error([]{ return e\_errno{errno}; }); + + .... + size\_t nr1=fread(buf1,1,count1,f); + if( ferror(f) ) + throw leaf::exception(); + + size\_t nr2=fread(buf2,1,count2,f); + if( ferror(f) ) + throw leaf::exception(); + + size\_t nr3=fread(buf3,1,count3,f); + if( ferror(f) ) + throw leaf::exception(); + .... +} +``` + +Above, if a `throw` statement is reached, LEAF will invoke the function passed to `on_error` and associate the returned `e_errno` object with the exception. + +The final type of arguments that can be passed to `on_error` is a function that takes a single mutable error object reference. In this case, `on_error` uses it similarly to how such functios are used by `load`; see [Loading of Error Objects](#tutorial-loading). + + +--- + +### Using Predicates to Handle Errors +Usually, LEAF error handlers are selected based on the type of the arguments they take and the type of the available error objects. When an error handler takes a predicate type as an argument, the [handler selection procedure](#handler_selection_procedure) is able to also take into account the *value* of the available error objects. + +Consider this error code enum: + + + +``` +enum class my\_error +{ + e1=1, + e2, + e3 +}; +``` + +We could handle `my_error` errors like so: + + + +``` +return leaf::try\_handle\_some( + [] + { + return f(); // returns leaf::result + }, + + []( my\_error e ) + { **(1)** + switch(e) + { + case my\_error::e1: + ....; **(2)** + break; + case my\_error::e2: + case my\_error::e3: + ....; **(3)** + break; + default: + ....; **(4)** + break; + } ); +``` + + + +| | | +| --- | --- | +| **1** | This handler will be selected if we’ve got a `my_error` object. | +| **2** | Handle `e1` errors. | +| **3** | Handle `e2` and `e3` errors. | +| **4** | Handle bad `my_error` values. | + +If `my_error` object is available, LEAF will call our error handler. If not, the failure will be forwarded to our caller. + +This can be rewritten using the [`match`](#match) predicate to organize the different cases in different error handlers. The following is equivalent: + + + +``` +return leaf::try\_handle\_some( + [] + { + return f(); // returns leaf::result + }, + + []( leaf::match m ) + { **(1)** + assert(m.matched == my\_error::e1); + ....; + }, + + []( leaf::match m ) + { **(2)** + assert(m.matched == my\_error::e2 || m.matched == my\_error::e3); + ....; + }, + + []( my\_error e ) + { **(3)** + ....; + } ); +``` + + + +| | | +| --- | --- | +| **1** | We’ve got a `my_error` object that compares equal to `e1`. | +| **2** | We`ve got a `my_error` object that compares equal to either `e2` or `e3`. | +| **3** | Handle bad `my_error` values. | + +The first argument to the `match` template generally specifies the type `E` of the error object `e` that must be available for the error handler to be considered at all. Typically, the rest of the arguments are values. The error handler to be dropped if `e` does not compare equal to any of them. + +In particular, `match` works great with `std::error_code`. The following handler is designed to handle `ENOENT` errors: + + + +``` +[]( leaf::match ) +{ +} +``` + +This, however, requires C++17 or newer, because it is impossible to infer the type of the error enum (in this case, `std::errc`) from the specified type `std::error_code`, and C++11 does not allow `auto` template arguments. LEAF provides the following workaround, compatible with C++11: + + + +``` +[]( leaf::match, std::errc::no\_such\_file\_or\_directory> ) +{ +} +``` + +In addition, it is possible to select a handler based on `std::error_category`. The following handler will match any `std::error_code` of the `std::generic_category` (requires C++17 or newer): + + + +``` +[]( std::error\_code, leaf::category> ) +{ +} +``` + + + +| | | +| --- | --- | +| | +See [`match`](#match) for more examples. + | + +The following predicates are available: + +* [`match`](#match): as described above. +* [`match_value`](#match_value): where `match` compares the object `e` of type `E` with the values `V…​`, `match_value` compare `e.value` with the values `V…​`. +* [`match_member`](#match_member): similar to `match_value`, but takes a pointer to the data member to compare; that is, `match_member<&E::value, V…​>` is equvialent to `match_value`. Note, however, that `match_member` requires C++17 or newer, while `match_value` does not. +* `[catch\_](#catch_)`: Similar to `match`, but checks whether the caught `std::exception` object can be `dynamic_cast` to any of the `Ex` types. +* [`if_not`](#if_not) is a special predicate that takes any other predicate `Pred` and requires that an error object of type `E` is available and that `Pred` evaluates to `false`. For example, `if_not>` requires that an object `e` of type `E` is available, and that it does not compare equal to any of the specified `V…​`. + +Finally, the predicate system is easily extensible, see [Predicates](#predicates). + + + +| | | +| --- | --- | +| | +See also [Working with `std::error_code`, `std::error_condition`](#tutorial-std_error_code). + | + + +--- + +### Binding Error Handlers in a `std::tuple` +Consider this snippet: + + + +``` +leaf::try\_handle\_all( + [&] + { + return f(); // returns leaf::result + }, + + [](my\_error\_enum x) + { + ... + }, + + [](read\_file\_error\_enum y, e\_file\_name const & fn) + { + ... + }, + + [] + { + ... + }); +``` + +[`try_handle_all`](#try_handle_all) | [`e_file_name`](#e_file_name) + +Looks pretty simple, but what if we need to attempt a different set of operations yet use the same handlers? We could repeat the same thing with a different function passed as `TryBlock` for `try_handle_all`: + + + +``` +leaf::try\_handle\_all( + [&] + { + return g(); // returns leaf::result + }, + + [](my\_error\_enum x) + { + ... + }, + + [](read\_file\_error\_enum y, e\_file\_name const & fn) + { + ... + }, + + [] + { + ... + }); +``` + +That works, but it is better to bind our error handlers in a `std::tuple`: + + + +``` +auto error\_handlers = std::make\_tuple( + [](my\_error\_enum x) + { + ... + }, + + [](read\_file\_error\_enum y, e\_file\_name const & fn) + { + ... + }, + + [] + { + ... + }); +``` + +The `error_handlers` tuple can later be used with any error handling function: + + + +``` +leaf::try\_handle\_all( + [&] + { + // Operations which may fail **(1)** + }, + + error\_handlers ); + +leaf::try\_handle\_all( + [&] + { + // Different operations which may fail **(2)** + }, + + error\_handlers ); **(3)** +``` + +[`try_handle_all`](#try_handle_all) | [`error_info`](#error_info) + + + +| | | +| --- | --- | +| **1** | One set of operations which may fail…​ | +| **2** | A different set of operations which may fail…​ | +| **3** | …​ both using the same `error_handlers`. | + +Error-handling functions accept a `std::tuple` of error handlers in place of any error handler. The behavior is as if the tuple is unwrapped in-place. + + +--- + +### Transporting Error Objects Between Threads +Error objects are stored on the stack in an instance of the [`context`](#context) class template in the scope of e.g. [`try_handle_some`](#try_handle_some), [`try_handle_all`](#try_handle_all) or [`try_catch`](#try_catch) functions. When using concurrency, we need a mechanism to collect error objects in one thread, then use them to handle errors in another thread. + +LEAF offers two interfaces for this purpose, one using `result`, and another designed for programs that use exception handling. + +#### Using `result` +Let’s assume we have a `task` that we want to launch asynchronously, which produces a `task_result` but could also fail: + + + +``` +leaf::result task(); +``` + +Because the task will run asynchronously, in case of a failure we need it to capture the relevant error objects but not handle errors. To this end, in the main thread we bind our error handlers in a `std::tuple`, which we will later use to handle errors from each completed asynchronous task (see [tutorial](#tutorial-binding_handlers)): + + + +``` +auto error\_handlers = std::make\_tuple( + [](E1 e1, E2 e2) + { + //Deal with E1, E2 + .... + return { }; + }, + + [](E3 e3) + { + //Deal with E3 + .... + return { }; + } ); +``` + +Why did we start with this step? Because we need to create a [`context`](#context) object to collect the error objects we need. We could just instantiate the `context` template with `E1`, `E2` and `E3`, but that would be prone to errors, since it could get out of sync with the handlers we use. Thankfully LEAF can deduce the types we need automatically, we just need to show it our `error_handlers`: + + + +``` +std::shared\_ptr ctx = leaf::make\_shared\_context(error\_handlers); +``` + +The `polymorphic_context` type is an abstract base class that has the same members as any instance of the `context` class template, allowing us to erase its exact type. In this case what we’re holding in `ctx` is a `context`, where `E1`, `E2` and `E3` were deduced automatically from the `error_handlers` tuple we passed to `make_shared_context`. + +We’re now ready to launch our asynchronous task: + + + +``` +std::future> launch\_task() noexcept +{ + return std::async( + std::launch::async, + [&] + { + std::shared\_ptr ctx = leaf::make\_shared\_context(error\_handlers); + return leaf::capture(ctx, &task); + } ); +} +``` + +[`result`](#result) | [`make_shared_context`](#make_shared_context) | [`capture`](#capture) + +That’s it! Later when we `get` the `std::future`, we can process the returned `result` in a call to [`try_handle_some`](#try_handle_some), using the `error_handlers` tuple we created earlier: + + + +``` +//std::future> fut; +fut.wait(); + +return leaf::try\_handle\_some( + + [&]() -> leaf::result + { + BOOST\_LEAF\_AUTO(r, fut.get()); + //Success! + return { } + }, + + error\_handlers ); +``` + +[`try_handle_some`](#try_handle_some) | [`result`](#result) | [`AUTO`](#BOOST_LEAF_AUTO) + +The reason this works is that in case it communicates a failure, `leaf::result` is able to hold a `shared_ptr` object. That is why earlier instead of calling `task()` directly, we called `leaf::capture`: it calls the passed function and, in case that fails, it stores the `shared_ptr` we created in the returned `result`, which now doesn’t just communicate the fact that an error has occurred, but also holds the `context` object that `try_handle_some` needs in order to supply a suitable handler with arguments. + + + +| | | +| --- | --- | +| | +Follow this link to see a complete example program: [capture\_in\_result.cpp](https://github.com/boostorg/leaf/blob/master/example/capture_in_result.cpp?ts=4). + | + + +--- + +#### Using Exception Handling +Let’s assume we have an asynchronous `task` which produces a `task_result` but could also throw: + + + +``` +task\_result task(); +``` + +Just like we saw in [Using `result`](#tutorial-async_result), first we will bind our error handlers in a `std::tuple`: + + + +``` +auto handle\_errors = std::make\_tuple( +{ + [](E1 e1, E2 e2) + { + //Deal with E1, E2 + .... + return { }; + }, + + [](E3 e3) + { + //Deal with E3 + .... + return { }; + } ); +``` + +Launching the task looks the same as before, except that we don’t use `result`: + + + +``` +std::future launch\_task() +{ + return std::async( + std::launch::async, + [&] + { + std::shared\_ptr ctx = leaf::make\_shared\_context(&handle\_error); + return leaf::capture(ctx, &task); + } ); +} +``` + +[`make_shared_context`](#make_shared_context) | [`capture`](#capture) + +That’s it! Later when we `get` the `std::future`, we can process the returned `task_result` in a call to [`try_catch`](#try_catch), using the `error_handlers` we saved earlier, as if it was generated locally: + + + +``` +//std::future fut; +fut.wait(); + +return leaf::try\_catch( + + [&] + { + task\_result r = fut.get(); // Throws on error + //Success! + }, + + error\_handlers ); +``` + +[`try_catch`](#try_catch) + +This works similarly to using `result`, except that the `std::shared_ptr` is transported in an exception object (of unspecified type which [`try_catch`](#try_catch) recognizes and then automatically unwraps the original exception). + + + +| | | +| --- | --- | +| | +Follow this link to see a complete example program: [capture\_in\_exception.cpp](https://github.com/boostorg/leaf/blob/master/example/capture_in_exception.cpp?ts=4). + | + + +--- + + +### Classification of Failures +It is common for any given interface to define an `enum` that lists all possible error codes that the API reports. The benefit of this approach is that the list is complete and usually contains comments, so we know where to go for reference. + +The disadvantage of such flat enums is that they do not support handling a whole class of failures. Consider this error handler from the [introduction section](#introduction-result): + + + +``` +.... +[](leaf::match, leaf::e\_errno const \* errn, leaf::e\_file\_name const & fn) +{ + std::cerr << "Failed to access " << fn.value; + if( errn ) + std::cerr << ", errno=" << \*errn; + std::cerr << std::endl; + return 3; +}, +.... +``` + +It will get called if the value of the `error_code` enum communicated with the failure is one of `size_error`, `read_error` or `eof_error`. In short, the idea is to handle any input error. + +But what if later we add support for detecting and reporting a new type of input error, e.g. `permissions_error`? It is easy to add that to our `error_code` enum; but now our input error handler won’t recognize this new input error — and we have a bug. + +If we can use exceptions, the situation is better because exception types can be organized in a hierarchy in order to classify failures: + + + +``` +struct input\_error: std::exception { }; +struct read\_error: input\_error { }; +struct size\_error: input\_error { }; +struct eof\_error: input\_error { }; +``` + +In terms of LEAF, our input error exception handler now looks like this: + + + +``` +[](input\_error &, leaf::e\_errno const \* errn, leaf::e\_file\_name const & fn) +{ + std::cerr << "Failed to access " << fn.value; + if( errn ) + std::cerr << ", errno=" << \*errn; + std::cerr << std::endl; + return 3; +}, +``` + +This is future-proof, but still not ideal, because it is not possible to refine the classification of the failure after the exception object has been thrown. + +LEAF supports a novel style of error handling where the classification of failures does not use error code values or exception type hierarchies. If we go back to the introduction section, instead of defining: + + + +``` +enum error\_code +{ + .... + read\_error, + size\_error, + eof\_error, + .... +}; +``` + +We could define: + + + +``` +.... +struct input\_error { }; +struct read\_error { }; +struct size\_error { }; +struct eof\_error { }; +.... +``` + +With this in place, `file_read` from the [print\_file\_result.cpp](https://github.com/boostorg/leaf/blob/master/example/print_file/print_file_result.cpp?ts=4) example can be rewritten like this: + + + +``` +leaf::result file\_read( FILE & f, void \* buf, int size ) +{ + int n = fread(buf, 1, size, &f); + + if( ferror(&f) ) + return leaf::new\_error(input\_error{}, read\_error{}, leaf::e\_errno{errno}); **(1)** + + if( n!=size ) + return leaf::new\_error(input\_error{}, eof\_error{}); **(2)** + + return { }; +} +``` + +[`result`](#result) | [`new_error`](#new_error) | [`e_errno`](#e_errno) + + + +| | | +| --- | --- | +| **1** | This error is classified as `input_error` and `read_error`. | +| **2** | This error is classified as `input_error` and `eof_error`. | + +Or, even better: + + + +``` +leaf::result file\_read( FILE & f, void \* buf, int size ) +{ + auto load = leaf::on\_error(input\_error{}); **(1)** + + int n = fread(buf, 1, size, &f); + + if( ferror(&f) ) + return leaf::new\_error(read\_error{}, leaf::e\_errno{errno}); **(2)** + + if( n!=size ) + return leaf::new\_error(eof\_error{}); **(3)** + + return { }; +} +``` + +[`result`](#result) | [`on_error`](#on_error) | [`new_error`](#new_error) | [`e_errno`](#e_errno) + + + +| | | +| --- | --- | +| **1** | Any error escaping this scope will be classified as `input_error` | +| **2** | In addition, this error is classified as `read_error`. | +| **3** | In addition, this error is classified as `eof_error`. | + +This technique works just as well if we choose to use exception handling: + + + +``` +void file\_read( FILE & f, void \* buf, int size ) +{ + auto load = leaf::on\_error(input\_error{}); + + int n = fread(buf, 1, size, &f); + + if( ferror(&f) ) + throw leaf::exception(read\_error{}, leaf::e\_errno{errno}); + + if( n!=size ) + throw leaf::exception(eof\_error{}); +} +``` + +[`on_error`](#on_error) | [`exception`](#exception) | [`e_errno`](#e_errno) + + + +| | | +| --- | --- | +| | +If the type of the first argument passed to `leaf::exception` derives from `std::exception`, it will be used to initialize the returned exception object taken by `throw`. Here this is not the case, so the function returns a default-initialized `std::exception` object, while the first (and any other) argument is associated with the failure. + | + +And now we can write a future-proof handler that can handle any `input_error`: + + + +``` +.... +[](input\_error, leaf::e\_errno const \* errn, leaf::e\_file\_name const & fn) +{ + std::cerr << "Failed to access " << fn.value; + if( errn ) + std::cerr << ", errno=" << \*errn; + std::cerr << std::endl; + return 3; +}, +.... +``` + +Remarkably, because the classification of the failure does not depend on error codes or on exception types, this error handler can be used with `try_catch` if we use exception handling, or with `try_handle_some`/`try_handle_all` if we do not. Here is the complete example from the introduction section, rewritten to use this technique: + +* [print\_file\_result\_error\_tags.cpp](https://github.com/boostorg/leaf/blob/master/example/print_file/print_file_result_error_tags.cpp?ts=4) (using `leaf::result`). +* [print\_file\_eh\_error\_tags.cpp](https://github.com/boostorg/leaf/blob/master/example/print_file/print_file_eh_error_tags.cpp?ts=4) (using exception handling). + + +--- + +### Converting Exceptions to `result` +It is sometimes necessary to catch exceptions thrown by a lower-level library function, and report the error through different means, to a higher-level library which may not use exception handling. + + + +| | | +| --- | --- | +| | +Understand that error handlers that take arguments of types that derive from `std::exception` work correctly — regardless of whether the error object itself is thrown as an exception, or [loaded](#tutorial-loading) into a [`context`](#context). The technique described here is only needed when the exception must be communicated through functions which are not exception-safe, or are compiled with exception-handling disabled. + | + +Suppose we have an exception type hierarchy and a function `compute_answer_throws`: + + + +``` +class error\_base: public std::exception { }; +class error\_a: public error\_base { }; +class error\_b: public error\_base { }; +class error\_c: public error\_base { }; + +int compute\_answer\_throws() +{ + switch( rand()%4 ) + { + default: return 42; + case 1: throw error\_a(); + case 2: throw error\_b(); + case 3: throw error\_c(); + } +} +``` + +We can write a simple wrapper using `exception_to_result`, which calls `compute_answer_throws` and switches to `result` for error handling: + + + +``` +leaf::result compute\_answer() noexcept +{ + return leaf::exception\_to\_result( + [] + { + return compute\_answer\_throws(); + } ); +} +``` + +[`result`](#result) | [`exception_to_result`](#exception_to_result) + +The `exception_to_result` template takes any number of exception types. All exception types thrown by the passed function are caught, and an attempt is made to convert the exception object to each of the specified types. Each successfully-converted slice of the caught exception object, as well as the return value of `std::current_exception`, are copied and [loaded](#tutorial-loading), and in the end the exception is converted to a `[result](#result)` object. + +(In our example, `error_a` and `error_b` slices as communicated as error objects, but `error_c` exceptions will still be captured by `std::exception_ptr`). + +Here is a simple function which prints successfully computed answers, forwarding any error (originally reported by throwing an exception) to its caller: + + + +``` +leaf::result print\_answer() noexcept +{ + BOOST\_LEAF\_AUTO(answer, compute\_answer()); + std::cout << "Answer: " << answer << std::endl; + return { }; +} +``` + +[`result`](#result) | [`AUTO`](#BOOST_LEAF_AUTO) + +Finally, here is a scope that handles the errors — it will work correctly regardless of whether `error_a` and `error_b` objects are thrown as exceptions or not. + + + +``` +leaf::try\_handle\_all( + []() -> leaf::result + { + BOOST\_LEAF\_CHECK(print\_answer()); + return { }; + }, + + [](error\_a const & e) + { + std::cerr << "Error A!" << std::endl; + }, + + [](error\_b const & e) + { + std::cerr << "Error B!" << std::endl; + }, + + [] + { + std::cerr << "Unknown error!" << std::endl; + } ); +``` + +[`try_handle_all`](#try_handle_all) | [`result`](#result) | [`CHECK`](#BOOST_LEAF_CHECK) + + + +| | | +| --- | --- | +| | +The complete program illustrating this technique is available [here](https://github.com/boostorg/leaf/blob/master/example/exception_to_result.cpp?ts=4). + | + + +--- + +### Using `error_monitor` to Report Arbitrary Errors from C-callbacks +Communicating information pertaining to a failure detected in a C callback is tricky, because C callbacks are limited to a specific static signature, which may not use C++ types. + +LEAF makes this easy. As an example, we’ll write a program that uses Lua and reports a failure from a C++ function registered as a C callback, called from a Lua program. The failure will be propagated from C++, through the Lua interpreter (written in C), back to the C++ function which called it. + +C/C++ functions designed to be invoked from a Lua program must use the following signature: + + + +``` +int do\_work( lua\_State \* L ) ; +``` + +Arguments are passed on the Lua stack (which is accessible through `L`). Results too are pushed onto the Lua stack. + +First, let’s initialize the Lua interpreter and register `do_work` as a C callback, available for Lua programs to call: + + + +``` +std::shared\_ptr init\_lua\_state() noexcept +{ + std::shared\_ptr L(lua\_open(), &lua\_close); **(1)** + + lua\_register(&\*L, "do\_work", &do\_work); **(2)** + + luaL\_dostring(&\*L, "\ **(3)** +\n function call\_do\_work()\ +\n return do\_work()\ +\n end"); + + return L; +} +``` + + + +| | | +| --- | --- | +| **1** | Create a new `lua_State`. We’ll use `std::shared_ptr` for automatic cleanup. | +| **2** | Register the `do_work` C++ function as a C callback, under the global name `do_work`. With this, calls from Lua programs to `do_work` will land in the `do_work` C++ function. | +| **3** | Pass some Lua code as a `C` string literal to Lua. This creates a global Lua function called `call_do_work`, which we will later ask Lua to execute. | + +Next, let’s define our `enum` used to communicate `do_work` failures: + + + +``` +enum do\_work\_error\_code +{ + ec1=1, + ec2 +}; +``` + +We’re now ready to define the `do_work` callback function: + + + +``` +int do\_work( lua\_State \* L ) noexcept +{ + bool success = rand()%2; **(1)** + if( success ) + { + lua\_pushnumber(L, 42); **(2)** + return 1; + } + else + { + leaf::new\_error(ec1); **(3)** + return luaL\_error(L, "do\_work\_error"); **(4)** + } +} +``` + +[`new_error`](#new_error) | [`load`](#error_id::load) + + + +| | | +| --- | --- | +| **1** | "Sometimes" `do_work` fails. | +| **2** | In case of success, push the result on the Lua stack, return back to Lua. | +| **3** | Generate a new `error_id` and associate a `do_work_error_code` with it. Normally, we’d return this in a `leaf::result`, but the `do_work` function signature (required by Lua) does not permit this. | +| **4** | Tell the Lua interpreter to abort the Lua program. | + +Now we’ll write the function that calls the Lua interpreter to execute the Lua function `call_do_work`, which in turn calls `do_work`. We’ll return `[result](#result)`, so that our caller can get the answer in case of success, or an error: + + + +``` +leaf::result call\_lua( lua\_State \* L ) +{ + lua\_getfield(L, LUA\_GLOBALSINDEX, "call\_do\_work"); + + error\_monitor cur\_err; + if( int err=lua\_pcall(L, 0, 1, 0) ) **(1)** + { + auto load = leaf::on\_error(e\_lua\_error\_message{lua\_tostring(L,1)}); **(2)** + lua\_pop(L,1); + + return cur\_err.assigned\_error\_id().load(e\_lua\_pcall\_error{err}); **(3)** + } + else + { + int answer = lua\_tonumber(L, -1); **(4)** + lua\_pop(L, 1); + return answer; + } +} +``` + +[`result`](#result) | [`on_error`](#on_error) | [`error_monitor`](#error_monitor) + + + +| | | +| --- | --- | +| **1** | Ask the Lua interpreter to call the global Lua function `call_do_work`. | +| **2** | `on_error` works as usual. | +| **3** | `load` will use the `error_id` generated in our Lua callback. This is the same `error_id` the `on_error` uses as well. | +| **4** | Success! Just return the `int` answer. | + +Finally, here is the `main` function which exercises `call_lua`, each time handling any failure: + + + +``` +int main() noexcept +{ + std::shared\_ptr L=init\_lua\_state(); + + for( int i=0; i!=10; ++i ) + { + leaf::try\_handle\_all( + + [&]() -> leaf::result + { + BOOST\_LEAF\_AUTO(answer, call\_lua(&\*L)); + std::cout << "do\_work succeeded, answer=" << answer << '\n'; **(1)** + return { }; + }, + + [](do\_work\_error\_code e) **(2)** + { + std::cout << "Got do\_work\_error\_code = " << e << "!\n"; + }, + + [](e\_lua\_pcall\_error const & err, e\_lua\_error\_message const & msg) **(3)** + { + std::cout << "Got e\_lua\_pcall\_error, Lua error code = " << err.value << ", " << msg.value << "\n"; + }, + + [](leaf::error\_info const & unmatched) + { + std::cerr << + "Unknown failure detected" << std::endl << + "Cryptic diagnostic information follows" << std::endl << + unmatched; + } ); + } +``` + +[`try_handle_all`](#try_handle_all) | [`result`](#result) | [`AUTO`](#BOOST_LEAF_AUTO) | [`error_info`](#error_info) + + + +| | | +| --- | --- | +| **1** | If the call to `call_lua` succeeded, just print the answer. | +| **2** | Handle `do_work` failures. | +| **3** | Handle all other `lua_pcall` failures. | + + + +| | | +| --- | --- | +| | +Follow this link to see the complete program: [lua\_callback\_result.cpp](https://github.com/boostorg/leaf/blob/master/example/lua_callback_result.cpp?ts=4). + | + + + +| | | +| --- | --- | +| | +When using Lua with C++, we need to protect the Lua interpreter from exceptions that may be thrown from C++ functions installed as `lua_CFunction` callbacks. Here is the program from this section rewritten to use a C++ exception to safely communicate errors out of the `do_work` function: [lua\_callback\_eh.cpp](https://github.com/boostorg/leaf/blob/master/example/lua_callback_eh.cpp?ts=4). + | + + +--- + +### Diagnostic Information +LEAF is able to automatically generate diagnostic messages that include information about all error objects available to error handlers. For this purpose, it needs to be able to print objects of user-defined error types. + +To do this, LEAF attempts to bind an unqualified call to `operator<<`, passing a `std::ostream` and the error object. If that fails, it will also attempt to bind `operator<<` that takes the `.value` of the error type. If that also doesn’t compile, the error object value will not appear in diagnostic messages, though LEAF will still print its type. + +Even with error types that define a printable `.value`, the user may still want to overload `operator<<` for the enclosing `struct`, e.g.: + + + +``` +struct e\_errno +{ + int value; + + friend std::ostream & operator<<( std::ostream & os, e\_errno const & e ) + { + return os << "errno = " << e.value << ", \"" << strerror(e.value) << '"'; + } +}; +``` + +The `e_errno` type above is designed to hold `errno` values. The defined `operator<<` overload will automatically include the output from `strerror` when `e_errno` values are printed (LEAF defines `e_errno` in ``, together with other commonly-used error types). + + + +| | | +| --- | --- | +| | +The automatically-generated diagnostic messages are developer-friendly, but not user-friendly. Therefore, `operator<<` overloads for error types should only print technical information in English, and should not attempt to localize strings or to format a user-friendly message; this should be done in error-handling functions specifically designed for that purpose. + | + + +--- + +### Working with `std::error_code`, `std::error_condition` +#### Introduction +The relationship between `std::error_code` and `std::error_condition` is not easily understood from reading the standard specifications. This section explains how they’re supposed to be used, and how LEAF interacts with them. + +The idea behind `std::error_code` is to encode both an integer value representing an error code, as well as the domain of that value. The domain is represented by a `std::error_category` reference. Conceptually, a `std::error_code` is like a `pair`. + +Let’s say we have this `enum`: + + + +``` +enum class libfoo\_error +{ + e1 = 1, + e2, + e3 +}; +``` + +We want to be able to transport `libfoo_error` values in `std::error_code` objects. This erases their static type, which enables them to travel freely across API boundaries. To this end, we must define a `std::error_category` that represents our `libfoo_error` type: + + + +``` +std::error\_category const & libfoo\_error\_category() +{ + struct category: std::error\_category + { + char const \* name() const noexcept override + { + return "libfoo"; + } + + std::string message(int code) const override + { + switch( libfoo\_error(code) ) + { + case libfoo\_error::e1: return "e1"; + case libfoo\_error::e2: return "e2"; + case libfoo\_error::e3: return "e3"; + default: return "error"; + } + } + }; + + static category c; + return c; +} +``` + +We also need to inform the standard library that `libfoo_error` is compatible with `std::error_code`, and provide a factory function which can be used to make `std::error_code` objects out of `libfoo_error` values: + + + +``` +namespace std +{ + template <> + struct is\_error\_code\_enum: std::true\_type + { + }; +} + +std::error\_code make\_error\_code(libfoo\_error e) +{ + return std::error\_code(int(e), libfoo\_error\_category()); +} +``` + +With this in place, if we receive a `std::error_code`, we can easily check if it represents some of the `libfoo_error` values we’re interested in: + + + +``` +std::error\_code f(); + +.... +auto ec = f(); +if( ec == libfoo\_error::e1 || ec == libfoo\_error::e2 ) +{ + // We got either a libfoo\_error::e1 or a libfoo\_error::e2 +} +``` + +This works because the standard library detects that `std::is_error_code_enum::value` is `true`, and then uses `make_error_code` to create a `std::error_code` object it actually uses to compare to `ec`. + +So far so good, but remember, the standard library defines another type also, `std::error_condition`. The first confusing thing is that in terms of its physical representation, `std::error_condition` is identical to `std::error_code`; that is, it is also like a pair of `std::error_category` reference and an `int`. Why do we need two different types which use identical physical representation? + +The key to answering this question is to understand that `std::error_code` objects are designed to be returned from functions to indicate failures. In contrast, `std::error_condition` objects are never supposed to be communicated; their purpose is to interpret the `std::error_code` values being communicated. The idea is that in a given program there may be multiple different "physical" (maybe platform-specific) `std::error_code` values which all indicate the same "logical" `std::error_condition`. + +This leads us to the second confusing thing about `std::error_condition`: it uses the same `std::error_category` type, but for a completely different purpose: to specify what `std::error_code` values are equivalent to what `std::error_condition` values. + +Let’s say that in addition to `libfoo`, our program uses another library, `libbar`, which communicates failures in terms of `std::error_code` with a different error category. Perhaps `libbar_error` looks like this: + + + +``` +enum class libbar\_error +{ + e1 = 1, + e2, + e3, + e4 +}; + +// Boilerplate omitted: +// - libbar\_error\_category() +// - specialization of std::is\_error\_code\_enum +// - make\_error\_code factory function for libbar\_error. +``` + +We can now use `std::error_condition` to define the *logical* error conditions represented by the `std::error_code` values communicated by `libfoo` and `libbar`: + + + +``` +enum class my\_error\_condition **(1)** +{ + c1 = 1, + c2 +}; + +std::error\_category const & libfoo\_error\_category() **(2)** +{ + struct category: std::error\_category + { + char const \* name() const noexcept override + { + return "my\_error\_condition"; + } + + std::string message(int cond) const override + { + switch( my\_error\_condition(code) ) + { + case my\_error\_condition::c1: return "c1"; + case my\_error\_condition::c2: return "c2"; + default: return "error"; + } + } + + bool equivalent(std::error\_code const & code, int cond) const noexcept + { + switch( my\_error\_condition(cond) ) + { + case my\_error\_condition::c1: **(3)** + return + code == libfoo\_error::e1 || + code == libbar\_error::e3 || + code == libbar\_error::e4; + case my\_error\_condition::c2: **(4)** + return + code == libfoo\_error::e2 || + code == libbar\_error::e1 || + code == libbar\_error::e2; + default: + return false; + } + } + }; + + static category c; + return c; +} + +namespace std +{ + template <> **(5)** + class is\_error\_condition\_enum: std::true\_type + { + }; +} + +std::error\_condition make\_error\_condition(my\_error\_condition e) **(6)** +{ + return std::error\_condition(int(e), my\_error\_condition\_error\_category()); +} +``` + + + +| | | +| --- | --- | +| **1** | Enumeration of the two logical error conditions, `c1` and `c2`. | +| **2** | Define the `std::error_category` for `std::error_condition` objects that represent a `my_error_condition`. | +| **3** | Here we specify that any of `libfoo:error::e1`, `libbar_error::e3` and `libbar_error::e4` are logically equivalent to `my_error_condition::c1`, and that…​ | +| **4** | …​any of `libfoo:error::e2`, `libbar_error::e1` and `libbar_error::e2` are logically equivalent to `my_error_condition::c2`. | +| **5** | This specialization tells the standard library that the `my_error_condition` enum is designed to be used with `std::error_condition`. | +| **6** | The factory function to make `std::error_condition` objects out of `my_error_condition` values. | + +Phew! + +Now, if we have a `std::error_code` object `ec`, we can easily check if it is equivalent to `my_error_condition::c1` like so: + + + +``` +if( ec == my\_error\_condition::c1 ) +{ + // We have a c1 in our hands +} +``` + +Again, remember that beyond defining the `std::error_category` for `std::error_condition` objects initialized with a `my_error_condition` value, we don’t need to interact with the actual `std::error_condition` instances: they’re created when needed to compare to a `std::error_code`, and that’s pretty much all they’re good for. + + +#### Support in LEAF +The following support for `std::error_code` and `std::error_condition` is available: + +* The [`match`](#match) template can be used as an argument to a LEAF error handler, so it can be considered based on the value of a communicated `std::error_code`. + + +| | | +| --- | --- | +| | +See [`match`](#match) for examples. + | +* The [`error_id`](#error_id) type can be converted to a `std::error_code`; see [`to_error_code`](#error_id::to_error_code). The returned object encodes the state of the `error_id` without any loss of information. This is useful if an `error_id` needs to be communicated through interfaces that support `std::error_code` but do not use LEAF. +* The `error_id` type can be implicitly initialized with a `std::error_code`. If the `std::error_code` was created using `to_error_code`, the original `error_id` state is restored. Otherwise, the `std::error_code` is [loaded](#tutorial-loading) so it can be used by LEAF error handlers, while the `error_id` itself is initialized by [`new_error`](#new_error). +* The `leaf::result` type can be implicitly initialized with an `error_id`, which means that it can be implicitly initialized with a `std::error_code`. + + +--- + + +### Boost Exception Integration +Instead of the [`boost::get_error_info`](https://www.boost.org/doc/libs/release/libs/exception/doc/get_error_info.html) API defined by Boost Exception, it is possible to use LEAF error handlers directly. Consider the following use of `boost::get_error_info`: + + + +``` +typedef boost::error\_info my\_info; + +void f(); // Throws using boost::throw\_exception + +void g() +{ + try + { + f(); + }, + catch( boost::exception & e ) + { + if( int const \* x = boost::get\_error\_info(e) ) + std::cerr << "Got my\_info with value = " << \*x; + } ); +} +``` + +We can rewrite `g` to access `my_info` using LEAF: + + + +``` +#include + +void g() +{ + leaf::try\_catch( + [] + { + f(); + }, + + []( my\_info x ) + { + std::cerr << "Got my\_info with value = " << x.value(); + } ); +} +``` + +[`try_catch`](#try_catch) + +Taking `my_info` means that the handler will only be selected if the caught exception object carries `my_info` (which LEAF accesses via `boost::get_error_info`). + +The use of [`match`](#match) is also supported: + + + +``` +void g() +{ + leaf::try\_catch( + [] + { + f(); + }, + + []( leaf::match\_value ) + { + std::cerr << "Got my\_info with value = 42"; + } ); +} +``` + +Above, the handler will be selected if the caught exception object carries `my_info` with `.value()` equal to 42. + +Examples +-------- + +See [github](https://github.com/boostorg/leaf/tree/master/example). + + + +Synopsis +-------- + +This section lists each public header file in LEAF, documenting the definitions it provides. + +LEAF headers are designed to minimize coupling: + +* Headers needed to report or forward but not handle errors are lighter than headers providing error-handling functionality. +* Headers that provide exception handling or throwing functionality are separate from headers that provide error-handling or reporting but do not use exceptions. + +A standalone single-header option is available; please `#include `. + + +--- +### Error Reporting +#### `error.hpp` + + +#include + + +``` +namespace boost { namespace leaf { + + class error\_id + { + public: + + error\_id() noexcept; + + template + error\_id( Enum e, typename std::enable\_if::value, Enum>::type \* = 0 ) noexcept; + + error\_id( std::error\_code const & ec ) noexcept; + + int value() const noexcept; + explicit operator bool() const noexcept; + + std::error\_code to\_error\_code() const noexept; + + friend bool operator==( error\_id a, error\_id b ) noexcept; + friend bool operator!=( error\_id a, error\_id b ) noexcept; + friend bool operator<( error\_id a, error\_id b ) noexcept; + + template + error\_id load( Item && ... item ) const noexcept; + + friend std::ostream & operator<<( std::ostream & os, error\_id x ); + }; + + bool is\_error\_id( std::error\_code const & ec ) noexcept; + + template + error\_id new\_error( Item && ... item ) noexcept; + + error\_id current\_error() noexcept; + + ////////////////////////////////////////// + + class polymorphic\_context + { + protected: + + polymorphic\_context() noexcept = default; + ~polymorphic\_context() noexcept = default; + + public: + + virtual void activate() noexcept = 0; + virtual void deactivate() noexcept = 0; + virtual bool is\_active() const noexcept = 0; + + virtual void propagate() noexcept = 0; + + virtual void print( std::ostream & ) const = 0; + }; + + ////////////////////////////////////////// + + template + class context\_activator + { + context\_activator( context\_activator const & ) = delete; + context\_activator & operator=( context\_activator const & ) = delete; + + public: + + explicit context\_activator( Ctx & ctx ) noexcept; + context\_activator( context\_activator && ) noexcept; + ~context\_activator() noexcept; + }; + + template + context\_activator activate\_context( Ctx & ctx ) noexcept; + + template + struct is\_result\_type: std::false\_type + { + }; + + template + struct is\_result\_type: is\_result\_type + { + }; + +} } + +#define BOOST\_LEAF\_ASSIGN(v, r)\ + auto && <> = r;\ + if( !<> )\ + return <>.error();\ + v = std::forward>)>(<>).value() + +#define BOOST\_LEAF\_AUTO(v, r)\ + BOOST\_LEAF\_ASSIGN(auto v, r) + +#define BOOST\_LEAF\_CHECK(r)\ + auto && <> = r;\ + if( <> )\ + ;\ + else\ + return <>.error() + +#define BOOST\_LEAF\_NEW\_ERROR <> ::boost::leaf::new\_error +``` + +Reference: [`error_id`](#error_id) | [`is_error_id`](#is_error_id) | [`new_error`](#new_error) | [`current_error`](#current_error) | [`polymorphic_context`](#polymorphic_context) | [`context_activator`](#context_activator) | [`activate_context`](#activate_context) | [`is_result_type`](#is_result_type) | [`ASSIGN`](#BOOST_LEAF_ASSIGN) | [`AUTO`](#BOOST_LEAF_AUTO) | [`CHECK`](#BOOST_LEAF_CHECK) | [`NEW_ERROR`](#BOOST_LEAF_NEW_ERROR) + +#### `common.hpp` + + +#include + + +``` +namespace boost { namespace leaf { + + struct e\_api\_function { char const \* value; }; + + struct e\_file\_name { std::string value; }; + + struct e\_type\_info\_name { char const \* value; }; + + struct e\_at\_line { int value; }; + + struct e\_errno + { + int value; + friend std::ostream & operator<<( std::ostream &, e\_errno const & ); + }; + + namespace windows + { + struct e\_LastError + { + unsigned value; + friend std::ostream & operator<<( std::ostream &, e\_LastError const & ); + }; + } + +} } +``` + +Reference: [`e_api_function`](#e_api_function) | [`e_file_name`](#e_file_name) | [`e_at_line`](#e_at_line) | [`e_type_info_name`](#e_type_info_name) | [`e_source_location`](#e_source_location) | [`e_errno`](#e_errno) | [`e_LastError`](#e_LastError) + +#### `result.hpp` + + +#include + + +``` +namespace boost { namespace leaf { + + template + class result + { + public: + + result() noexcept; + result( T && v ) noexcept; + result( T const & v ); + + template + result( U && u, <> ); + + result( error\_id err ) noexcept; + result( std::shared\_ptr && ctx ) noexcept; + + template + result( Enum e, typename std::enable\_if::value, Enum>::type \* = 0 ) noexcept; + + result( std::error\_code const & ec ) noexcept; + + result( result && r ) noexcept; + + template + result( result && r ) noexcept; + + result & operator=( result && r ) noexcept; + + template + result & operator=( result && r ) noexcept; + + explicit operator bool() const noexcept; + + T const & value() const; + T & value(); + + T const & operator\*() const; + T & operator\*(); + + T const \* operator->() const; + T \* operator->(); + + <> error() noexcept; + + template + error\_id load( Item && ... item ) noexcept; + }; + + template <> + class result + { + public: + + result() noexcept; + + result( error\_id err ) noexcept; + result( std::shared\_ptr && ctx ) noexcept; + + template + result( Enum e, typename std::enable\_if::value, Enum>::type \* = 0 ) noexcept; + + result( std::error\_code const & ec ) noexcept; + + result( result && r ) noexcept; + + template + result( result && r ) noexcept; + + result & operator=( result && r ) noexcept; + + template + result & operator=( result && r ) noexcept; + + explicit operator bool() const noexcept; + + void value() const; + + <> error() noexcept; + + template + error\_id load( Item && ... item ) noexcept; + }; + + struct bad\_result: std::exception { }; + + template + struct is\_result\_type>: std::true\_type + { + }; + +} } +``` + +Reference: [`result`](#result) | [`is_result_type`](#is_result_type) + +#### `on_error.hpp` + + +#include + + +``` +namespace boost { namespace leaf { + + template + <> on\_error( Item && ... e ) noexcept; + + class error\_monitor + { + public: + + error\_monitor() noexcept; + + error\_id check() const noexcept; + error\_id assigned\_error\_id() const noexcept; + }; + +} } +``` + +Reference: [`on_error`](#on_error) | [`error_monitor`](#error_monitor) + +#### `exception.hpp` + + +#include + + +``` +namespace boost { namespace leaf { + + template **(1)** + <> exception( Ex &&, E && ... ) noexcept; + + template **(2)** + <> exception( E1 &&, E && ... ) noexcept; + + <> exception() noexcept; + + template **(1)** + <> exception( error\_id id, Ex &&, E && ... ) noexcept; + + template **(2)** + <> exception( error\_id id, E1 &&, E && ... ) noexcept; + + <> exception( error\_id id ) noexcept; + +} } + +#define BOOST\_LEAF\_EXCEPTION <> ::boost::leaf::exception + +#define BOOST\_LEAF\_THROW\_EXCEPTION <> ::boost::leaf::exception +``` + +Reference: [`exception`](#exception) | [`EXCEPTION`](#BOOST_LEAF_EXCEPTION) | [`THROW_EXCEPTION`](#BOOST_LEAF_THROW_EXCEPTION) + + + +| | | +| --- | --- | +| **1** | Only enabled if std::is\_base\_of::value. | +| **2** | Only enabled if !std::is\_base\_of::value. | + +#### `capture.hpp` + + +#include + + +``` +namespace boost { namespace leaf { + + template + decltype(std::declval()(std::forward(std::declval())...)) + capture(std::shared\_ptr && ctx, F && f, A... a); + + template + <-deduced>> exception\_to\_result( F && f ) noexcept; + +} } +``` + +Reference: [`capture`](#capture) | [`exception_to_result`](#exception_to_result) + +--- + + +### Error Handling +#### `context.hpp` + + +#include + + +``` +namespace boost { namespace leaf { + + template + class context + { + context( context const & ) = delete; + context & operator=( context const & ) = delete; + + public: + + context() noexcept; + context( context && x ) noexcept; + ~context() noexcept; + + void activate() noexcept; + void deactivate() noexcept; + bool is\_active() const noexcept; + + void propagate () noexcept; + + void print( std::ostream & os ) const; + + template + R handle\_error( R &, H && ... ) const; + }; + + ////////////////////////////////////////// + + template + using context\_type\_from\_handlers = typename <>::type; + + template + BOOST\_LEAF\_CONSTEXPR context\_type\_from\_handlers make\_context() noexcept; + + template + BOOST\_LEAF\_CONSTEXPR context\_type\_from\_handlers make\_context( H && ... ) noexcept; + + template + context\_ptr make\_shared\_context() noexcept; + + template + context\_ptr make\_shared\_context( H && ... ) noexcept; + +} } +``` + +Reference: [`context`](#context) | [`context_type_from_handlers`](#context_type_from_handlers) | [`make_context`](#make_context) | [`make_shared_context`](#make_shared_context) + +#### `handle_errors.hpp` + + +#include + + +``` +namespace boost { namespace leaf { + + template + typename std::decay()().value())>::type + try\_handle\_all( TryBlock && try\_block, H && ... h ); + + template + typename std::decay()())>::type + try\_handle\_some( TryBlock && try\_block, H && ... h ); + + template + typename std::decay()())>::type + try\_catch( TryBlock && try\_block, H && ... h ); + + ////////////////////////////////////////// + + class error\_info + { + //No public constructors + + public: + + error\_id error() const noexcept; + + bool exception\_caught() const noexcept; + std::exception const \* exception() const noexcept; + + friend std::ostream & operator<<( std::ostream & os, error\_info const & x ); + }; + + class diagnostic\_info: public error\_info + { + //No public constructors + + friend std::ostream & operator<<( std::ostream & os, diagnostic\_info const & x ); + }; + + class verbose\_diagnostic\_info: public error\_info + { + //No public constructors + + friend std::ostream & operator<<( std::ostream & os, diagnostic\_info const & x ); + }; + +} } +``` + +Reference: [`try_handle_all`](#try_handle_all) | [`try_handle_some`](#try_handle_some) | [`try_catch`](#try_catch) | [`error_info`](#error_info) | [`diagnostic_info`](#diagnostic_info) | [`verbose_diagnostic_info`](#verbose_diagnostic_info) + +#### `pred.hpp` + + +#include + + +``` +namespace boost { namespace leaf { + + template + struct is\_predicate: std::false\_type + { + }; + + template + struct match + { + E matched; + + // Other members not specified + }; + + template + struct is\_predicate>: std::true\_type + { + }; + + template + struct match\_value + { + E matched; + + // Other members not specified + }; + + template + struct is\_predicate>: std::true\_type + { + }; + + template + struct match\_member; + + template + struct member + { + E matched; + + // Other members not specified + }; + + template + struct is\_predicate>: std::true\_type + { + }; + + template + struct catch\_ + { + std::exception const & matched; + + // Other members not specified + }; + + template + struct catch\_ + { + Ex const & matched; + + // Other members not specified + }; + + template + struct is\_predicate>: std::true\_type + { + }; + + template + struct if\_not + { + E matched; + + // Other members not specified + }; + + template + struct is\_predicate>: std::true\_type + { + }; + + template + bool category( std::error\_code const & ec ) noexcept; + + template + struct condition; + +} } +``` + +Reference: [`match`](#match) | [`match_value`](#match_value) | [`match_member`](#match_member) | [`catch_`](#catch_) | [`if_not`](#if_not) | [`category`](#category) | [`condition`](#condition) + + + + +Reference: Functions +-------------------- + + + +| | | +| --- | --- | +| | +The contents of each Reference section are organized alphabetically. + | + + +--- +### `activate_context` +#include + + +``` +namespace boost { namespace leaf { + + template + context\_activator activate\_context( Ctx & ctx ) noexcept + { + return context\_activator(ctx); + } + +} } +``` + +[`context_activator`](#context_activator) + +Example: + + +``` +leaf::context ctx; + +{ + auto active\_context = activate\_context(ctx); **(1)** +} **(2)** +``` + + + +| | | +| --- | --- | +| **1** | Activate `ctx`. | +| **2** | Automatically deactivate `ctx`. | + + +--- + +### `capture` +#include + + +``` +namespace boost { namespace leaf { + + template + decltype(std::declval()(std::forward(std::declval())...)) + capture(std::shared\_ptr && ctx, F && f, A... a); + +} } +``` + +[`polymorphic_context`](#polymorphic_context) + +This function can be used to capture error objects stored in a [`context`](#context) in one thread and transport them to a different thread for handling, either in a `[result](#result)` object or in an exception. + + +Returns: + +The same type returned by `F`. +Effects: + +Uses an internal [`context_activator`](#context_activator) to [`activate`](#context::activate) `*ctx`, then invokes `std::forward(f)(std::forward(a)…​)`. Then: + + +* If the returned value `r` is not a `result` type (see [`is_result_type`](#is_result_type)), it is forwarded to the caller. +* Otherwise: + + + If `!r`, the return value of `capture` is initialized with `ctx`; + + + + + + | | | + | --- | --- | + | | + An object of type `leaf::[result](#result)` can be initialized with a `std::shared_ptr`. + | + + otherwise, it is initialized with `r`. + + + +In case `f` throws, `capture` catches the exception in a `std::exception_ptr`, and throws a different exception of unspecified type that transports both the `std::exception_ptr` as well as `ctx`. This exception type is recognized by [`try_catch`](#try_catch), which automatically unpacks the original exception and propagates the contents of `*ctx` (presumably, in a different thread). + + + +| | | +| --- | --- | +| | +See also [Transporting Error Objects Between Threads](#tutorial-async) from the Tutorial. + | + + +--- + +### `context_type_from_handlers` +#include + + +``` +namespace boost { namespace leaf { + + template + using context\_type\_from\_handlers = typename <>::type; + +} } +``` + +Example: + + +``` +auto error\_handlers = std::make\_tuple( + [](e\_this const & a, e\_that const & b) + { + .... + }, + + [](leaf::diagnostic\_info const & info) + { + .... + }, + .... ); + +leaf::context\_type\_from\_handlers ctx; **(1)** +``` + + + +| | | +| --- | --- | +| **1** | `ctx` will be of type `context`, deduced automatically from the specified error handlers. | + + + +| | | +| --- | --- | +| | +Alternatively, a suitable context may be created by calling [`make_context`](#make_context), or allocated dynamically by calling [`make_shared_context`](#make_shared_context). + | + + +--- + +### `current_error` +#include + + +``` +namespace boost { namespace leaf { + + error\_id current\_error() noexcept; + +} } +``` + + +Returns: + +The `error_id` value returned the last time [`new_error`](#new_error) was invoked from the calling thread. + + +| | | +| --- | --- | +| | +See also [`on_error`](#on_error). + | + + +--- + +### `exception` +#include + + +``` +namespace boost { namespace leaf { + + template **(1)** + <> exception( Ex && ex, E && ... e ) noexcept; + + template **(2)** + <> exception( E1 && e1, E && ... e ) noexcept; + + <> exception() noexcept; **(3)** + + template **(4)** + <> exception( error\_id id, Ex && ex, E && ... e ) noexcept; + + template **(5)** + <> exception( error\_id id, E1 && e1, E && ... e ) noexcept; + + <> exception( error\_id id ) noexcept; **(6)** + +} } +``` + +The `exception` function is overloaded: it can be invoked with no arguments, or else there are several alternatives, selected using `std::enable_if` based on the type of the passed arguments: + + + +| | | +| --- | --- | +| **1** | Selected if the first argument is not of type `error_id` and is an exception object, that is, iff `Ex` derives publicly from `std::exception`. In this case the return value is of unspecified type which derives publicly from `Ex` **and** from class [`error_id`](#error_id), such that: + +* its `Ex` subobject is initialized by `std::forward(ex)`; +* its `error_id` subobject is initialized by `[new\_error](#new_error)(std::forward(e)…​`). + + + | +| **2** | Selected if the first argument is not of type `error_id` and is not an exception object. In this case the return value is of unspecified type which derives publicly from `std::exception` **and** from class `error_id`, such that: + +* its `std::exception` subobject is default-initialized; +* its `error_id` subobject is initialized by `[new\_error](#new_error)(std::forward(e1), std::forward(e)…​`). + + + | +| **3** | If the fuction is invoked without arguments, the return value is of unspecified type which derives publicly from `std::exception` **and** from class `error_id`, such that: + +* its `std::exception` subobject is default-initialized; +* its `error_id` subobject is initialized by `[new\_error](#new_error)()`. + + + | +| **4** | Selected if the first argument is of type `error_id` and the second argument is an exception object, that is, iff `Ex` derives publicly from `std::exception`. In this case the return value is of unspecified type which derives publicly from `Ex` **and** from class [`error_id`](#error_id), such that: + +* its `Ex` subobject is initialized by `std::forward(ex)`; +* its `error_id` subobject is initialized by `id.[`load`](#error_id::load)(std::forward(e)…​)`. + + + | +| **5** | Selected if the first argument is of type `error_id` and the second argument is not an exception object. In this case the return value is of unspecified type which derives publicly from `std::exception` **and** from class `error_id`, such that: + +* its `std::exception` subobject is default-initialized; +* its `error_id` subobject is initialized by `id.[`load`](#error_id::load)(std::forward(e1), std::forward(e)…​`). + + + | +| **6** | If `exception` is invoked with just an `error_id` object, the return value is of unspecified type which derives publicly from `std::exception` **and** from class `error_id`, such that: + +* its `std::exception` subobject is default-initialized; +* its `error_id` subobject is initialized by copying from `id`. + + + | + + + +| | | +| --- | --- | +| | +The first three overloads return an exception object that is associated with a new `error_id`. The second three overloads return an exception object that is associated with the specified `error_id`. + | + +Example 1: + + +``` +struct my\_exception: std::exception { }; + +throw leaf::exception(my\_exception{}); **(1)** +``` + + + +| | | +| --- | --- | +| **1** | Throws an exception of a type that derives from `error_id` and from `my_exception` (because `my_exception` derives from `std::exception`). | + +Example 2: + + +``` +enum class my\_error { e1=1, e2, e3 }; **(1)** + +throw leaf::exception(my\_error::e1); +``` + + + +| | | +| --- | --- | +| **1** | Throws an exception of a type that derives from `error_id` and from `std::exception` (because `my_error` does not derive from `std::exception`). | + + + +| | | +| --- | --- | +| | +To automatically capture `__FILE__`, `__LINE__` and `__FUNCTION__` with the returned object, use [`EXCEPTION`](#BOOST_LEAF_EXCEPTION) instead of `leaf::exception`. + | + + +--- + +### `exception_to_result` +#include + + +``` +namespace boost { namespace leaf { + + template + <-deduced>> exception\_to\_result( F && f ) noexcept; + +} } +``` + +This function can be used to catch exceptions from a lower-level library and convert them to `[result](#result)`. + + +Returns: + +Where `f` returns a type `T`, `exception_to_result` returns `leaf::result`. +Effects: + + +1. Catches all exceptions, then captures `std::current_exception` in a `std::exception_ptr` object, which is [loaded](#tutorial-loading) with the returned `result`. +2. Attempts to convert the caught exception, using `dynamic_cast`, to each type `Exi` in `Ex…​`. If the cast to `Exi` succeeds, the `Exi` slice of the caught exception is loaded with the returned `result`. + + + +| | | +| --- | --- | +| | +An error handler that takes an argument of an exception type (that is, of a type that derives from `std::exception`) will work correctly whether the object is thrown as an exception or communicated via [`new_error`](#new_error) (or converted using `exception_to_result`). + | + +Example: + + +``` +int compute\_answer\_throws(); + +//Call compute\_answer, convert exceptions to result +leaf::result compute\_answer() +{ + return leaf::exception\_to\_result(compute\_answer\_throws()); +} +``` + +At a later time we can invoke [`try_handle_some`](#try_handle_some) / [`try_handle_all`](#try_handle_all) as usual, passing handlers that take `ex_type1` or `ex_type2`, for example by reference: + + + +``` +return leaf::try\_handle\_some( + + [] -> leaf::result + { + BOOST\_LEAF\_AUTO(answer, compute\_answer()); + //Use answer + .... + return { }; + }, + + [](ex\_type1 & ex1) + { + //Handle ex\_type1 + .... + return { }; + }, + + [](ex\_type2 & ex2) + { + //Handle ex\_type2 + .... + return { }; + }, + + [](std::exception\_ptr const & p) + { + //Handle any other exception from compute\_answer. + .... + return { }; + } ); +``` + +[`try_handle_some`](#try_handle_some) | [`result`](#result) | [`AUTO`](#BOOST_LEAF_AUTO) + + + +| | | +| --- | --- | +| | +When a handler takes an argument of an exception type (that is, a type that derives from `std::exception`), if the object is thrown, the argument will be matched dynamically (using `dynamic_cast`); otherwise (e.g. after being converted by `exception_to_result`) it will be matched based on its static type only (which is the same behavior used for types that do not derive from `std::exception`). + | + + + +| | | +| --- | --- | +| | +See also [Converting Exceptions to `result`](#tutorial-exception_to_result) from the tutorial. + | + + +--- + +### `make_context` +#include + + +``` +namespace boost { namespace leaf { + + template + context\_type\_from\_handlers make\_context() noexcept + { + return { }; + } + + template + context\_type\_from\_handlers make\_context( H && ... ) noexcept + { + return { }; + } + +} } +``` + +[`context_type_from_handlers`](#context_type_from_handlers) + +Example: + + +``` +auto ctx = leaf::make\_context( **(1)** + []( e\_this ) { .... }, + []( e\_that ) { .... } ); +``` + + + +| | | +| --- | --- | +| **1** | `decltype(ctx)` is `leaf::context`. | + + +--- + +### `make_shared_context` +#include + + +``` +namespace boost { namespace leaf { + + template + context\_ptr make\_shared\_context() noexcept + { + return std::make\_shared>>(); + } + + template + context\_ptr make\_shared\_context( H && ... ) noexcept + { + return std::make\_shared>>(); + } + +} } +``` + +[`context_type_from_handlers`](#context_type_from_handlers) + + + +| | | +| --- | --- | +| | +See also [Transporting Error Objects Between Threads](#tutorial-async) from the tutorial. + | + + +--- + +### `new_error` +#include + + +``` +namespace boost { namespace leaf { + + template + error\_id new\_error(Item && ... item) noexcept; + +} } +``` + + +Requires: + +Each of the `Item…​` types must be no-throw movable. +Effects: + +As if: + + +``` +error\_id id = <>; +return id.load(std::forward(item)...); +``` + +Returns: + +A new `error_id` value, which is unique across the entire program. +Ensures: + +`id.value()!=0`, where `id` is the returned `error_id`. + + +| | | +| --- | --- | +| | `new_error` discards error objects which are not used in any active error-handling calling scope. + | + + + +| | | +| --- | --- | +| | +When loaded into a `context`, an error object of a type `E` will overwrite the previously loaded object of type `E`, if any. + | + + +--- + +### `on_error` +#include + + +``` +namespace boost { namespace leaf { + + template + <> on\_error(Item && ... item) noexcept; + +} } +``` + + +Requires: + +Each of the `Item…​` types must be no-throw movable. +Effects: + +All `item…​` objects are forwarded and stored, together with the value returned from `std::unhandled_exceptions`, into the returned object of unspecified type, which should be captured by `auto` and kept alive in the calling scope. When that object is destroyed, if an error has occurred since `on_error` was invoked, LEAF will process the stored items to obtain error objects to be associated with the failure. +On error, LEAF first needs to deduce an `error_id` value `err` to associate error objects with. This is done using the following logic: + + + +* If [`new_error`](#new_error) was invoked (by the calling thread) since the object returned by `on_error` was created, `err` is initialized with the value returned by [`current_error`](#current_error); +* Otherwise, if `std::unhandled_exceptions` returns a greater value than it returned during initialization, `err` is initialized with the value returned by [`new_error`](#new_error); +* Otherwise, the stored `item…​` objects are discarded and no further action is taken (no error has occurred). + + + +Next, LEAF proceeds similarly to: + + + +``` +err.load(std::forward(item)...); +``` + +The difference is that unlike [`load`](#error_id::load), `on_error` will not overwrite any error objects already associated with `err`. + + + +| | | +| --- | --- | +| | +See [Using `on_error`](#tutorial-on_error) from the Tutorial. + | + + +--- + +### `try_catch` +#include + + +``` +namespace boost { namespace leaf { + + template + typename std::decay()())>::type + try\_catch( TryBlock && try\_block, H && ... h ); + +} } +``` + +The `try_catch` function works similarly to [`try_handle_some`](#try_handle_some), except that it does not use or understand the semantics of `result` types; instead: + +* It assumes that the `try_block` throws to indicate a failure, in which case `try_catch` will attempt to find a suitable handler among `h…​`; +* If a suitable handler isn’t found, the original exception is re-thrown using `throw;`. + + + +| | | +| --- | --- | +| | +See also Five Minute Introduction [Exception-Handling API](#introduction-eh). + | + + +--- + +### `try_handle_all` +#include + + +``` +namespace boost { namespace leaf { + + template + typename std::decay()().value())>::type + try\_handle\_all( TryBlock && try\_block, H && ... h ); + +} } +``` + +The `try_handle_all` function works similarly to [`try_handle_some`](#try_handle_some), except: + +* In addition, it requires that at least one of `h…​` can be used to handle any error (this requirement is enforced at compile time); +* If the `try_block` returns some `result` type, it must be possible to initialize a value of type `T` with the value returned by each of `h…​`, and +* Because it is required to handle all errors, `try_handle_all` unwraps the `result` object `r` returned by the `try_block`, returning `r.value()` instead of `r`. + + + +| | | +| --- | --- | +| | +See also [Five Minute Introduction](#introduction-result). + | + + +--- + +### `try_handle_some` +#include + + +``` +namespace boost { namespace leaf { + + template + typename std::decay()())>::type + try\_handle\_some( TryBlock && try\_block, H && ... h ); + +} } +``` + + +Requires: + + +* The `try_block` function may not take any arguments. +* The type `R` returned by the `try_block` function must be a `result` type (see [`is_result_type`](#is_result_type)). It is valid for the `try_block` to return `leaf::[result](#result)`, however this is not a requirement. +* Each of the `h…​` functions: + + + must return a type that can be used to initialize an object of the type `R`; in case R is a `result` (that is, in case of success it does not communicate a value), handlers that return `void` are permitted. If such a handler is selected, the `try_handle_some` return value is initialized by `{}`; + + may take any error objects, by value, by (`const`) reference, or as pointer (to `const`); + + may take arguments, by value, of any predicate type: [`catch_`](#catch_), [`match`](#match), [`match_value`](#match_value), [`match_member`](#match_member), [`if_not`](#if_not), or of any user-defined predicate type `Pred` for which `[is\_predicate](#is_predicate)::value` is `true`; + + may take an [`error_info`](#error_info) argument by `const &`; + + may take a [`diagnostic_info`](#diagnostic_info) argument by `const &`; + + may take a [`verbose_diagnostic_info`](#verbose_diagnostic_info) argument by `const &`. + +Effects: + + +* Creates a local `[context](#context)` object `ctx`, where the `E…​` types are automatically deduced from the types of arguments taken by each of `h…​`, which guarantees that `ctx` is able to store all of the types required to handle errors. +* Invokes the `try_block`: + + + if the returned object `r` indicates success and the `try_block` did not throw, `r` is forwarded to the caller. + + otherwise, LEAF considers each of the `h…​` handlers, in order, until it finds one that it can supply with arguments using the error objects currently stored in `ctx`, associated with `r.error()`. The first such handler is invoked and its return value is used to initialize the return value of `try_handle_some`, which can indicate success if the handler was able to handle the error, or failure if it was not. + + if `try_handle_some` is unable to find a suitable handler, it returns `r`. + + + +| | | +| --- | --- | +| | `try_handle_some` is exception-neutral: it does not throw exceptions, however the `try_block` and any of `h…​` are permitted to throw. + | + + +Handler Selection Procedure: + + +A handler `h` is suitable to handle the failure reported by `r` iff `try_handle_some` is able to produce values to pass as its arguments, using the error objects currently available in `ctx`, associated with the error ID obtained by calling `r.error()`. As soon as it is determined that an argument value can not be produced, the current handler is dropped and the selection process continues with the next handler, if any. + +The return value of `r.error()` must be implicitly convertible to [`error_id`](#error_id). Naturally, the `leaf::result` template satisfies this requirement. If an external `result` type is used instead, usually `r.error()` would return a `std::error_code`, which is able to communicate LEAF error IDs; see [Interoperability](#tutorial-interoperability). + +If `err` is the `error_id` obtained from `r.error()`, each argument `ai` taken by the handler currently under consideration is produced as follows: + +* If `ai` is of type `Ai`, `Ai const&` or `Ai&`: + + + + + If an error object of type `Ai`, associated with `err`, is currently available in `ctx`, `ai` is initialized with a reference to that object; otherwise + + If `Ai` derives from `std::exception`, and the `try_block` throws an object `ex` of type that derives from `std::exception`, LEAF obtains `Ai* p = dynamic_cast(&ex)`. The handler is dropped if `p` is null, otherwise `ai` is initialized with `*p`. + + Otherwise the handler is dropped. + +Example: + + +``` +.... +auto r = leaf::try\_handle\_some( + []() -> leaf::result + { + return f(); + }, + + [](leaf::e\_file\_name const & fn) **(1)** + { + std::cerr << "File Name: \"" << fn.value << '"' << std::endl; **(2)** + + return 1; + } ); +``` + +[`result`](#result) | [`e_file_name`](#e_file_name) + + + +| | | +| --- | --- | +| **1** | In case the `try_block` indicates a failure, this handler will be selected if `ctx` stores an `e_file_name` associated with the error. Because this is the only supplied handler, if an `e_file_name` is not available, `try_handle_some` will return the `leaf::result` returned by `f`. | +| **2** | Print the file name, handle the error. | +* If `ai` is of type `Ai` `const*` or `Ai*`, `try_handle_some` is always able to produce it: first it attempts to produce it as if it is taken by reference; if that fails, rather than dropping the handler, `ai` is initialized with `0`. +Example: + + +``` +.... +try\_handle\_some( + []() -> leaf::result + { + return f(); + }, + + [](leaf::e\_file\_name const \* fn) **(1)** + { + if( fn ) **(2)** + std::cerr << "File Name: \"" << fn->value << '"' << std::endl; + + return 1; + } ); +} +``` + +[`result`](#result) | [`e_file_name`](#e_file_name) + + + +| | | +| --- | --- | +| **1** | This handler can be selected to handle any error, because it takes `e_file_name` as a `const *` (and nothing else). | +| **2** | If an `e_file_name` is available with the current error, print it. | +* If `ai` is of a predicate type `Pred` (for which `[is\_predicate](#is_predicate)::value` is `true`), `E` is deduced as `typename Pred::error_type`, and then: + + + If `E` is not `void`, and an error object `e` of type `E`, associated with `err`, is not currently stored in `ctx`, the handler is dropped; otherwise the handler is dropped if the expression `Pred::evaluate(e)` returns `false`. + + if `E` is `void`, and a `std::exception` was not caught, the handler is dropped; otherwise the handler is dropped if the expression `Pred::evaluate(e)`, where `e` is of type `std::exception const &`, returns `false`. + + To invoke the handler, the `Pred` argument `ai` is initialized with `Pred{e}`. + + + + + + | | | + | --- | --- | + | | + See also: [Predicates](#predicates). + | +* If `ai` is of type `error_info const &`, `try_handle_some` is always able to produce it. +Example: + + +``` +.... +try\_handle\_some( + [] + { + return f(); // returns leaf::result + }, + + [](leaf::error\_info const & info) **(1)** + { + std::cerr << "leaf::error\_info:" << std::endl << info; **(2)** + return info.error(); **(3)** + } ); +``` + +[`result`](#result) | [`error_info`](#error_info) + + + +| | | +| --- | --- | +| **1** | This handler matches any error. | +| **2** | Print error information. | +| **3** | Return the original error, which will be returned out of `try_handle_some`. | +* If `ai` is of type `diagnostic_info const &`, `try_handle_some` is always able to produce it. +Example: + + +``` +.... +try\_handle\_some( + [] + { + return f(); // throws + }, + + [](leaf::diagnostic\_info const & info) **(1)** + { + std::cerr << "leaf::diagnostic\_information:" << std::endl << info; **(2)** + return info.error(); **(3)** + } ); +``` + +[`result`](#result) | [`diagnostic_info`](#diagnostic_info) + + + +| | | +| --- | --- | +| **1** | This handler matches any error. | +| **2** | Print diagnostic information, including limited information about dropped error objects. | +| **3** | Return the original error, which will be returned out of `try_handle_some`. | +* If `ai` is of type `verbose_diagnostic_info const &`, `try_handle_some` is always able to produce it. +Example: + + +``` +.... +try\_handle\_some( + [] + { + return f(); // throws + }, + + [](leaf::verbose\_diagnostic\_info const & info) **(1)** + { + std::cerr << "leaf::verbose\_diagnostic\_information:" << std::endl << info; **(2)** + return info.error(); **(3)** + } ); +``` + +[`result`](#result) | [`verbose_diagnostic_info`](#verbose_diagnostic_info) + + + +| | | +| --- | --- | +| **1** | This handler matches any error. | +| **2** | Print verbose diagnostic information, including values of dropped error objects. | +| **3** | Return the original error, which will be returned out of `try_handle_some`. | + + + + +Reference: Types +---------------- + + + +| | | +| --- | --- | +| | +The contents of each Reference section are organized alphabetically. + | + + +--- +### `context` +#include + + +``` +namespace boost { namespace leaf { + + template + class context + { + context( context const & ) = delete; + context & operator=( context const & ) = delete; + + public: + + context() noexcept; + context( context && x ) noexcept; + ~context() noexcept; + + void activate() noexcept; + void deactivate() noexcept; + bool is\_active() const noexcept; + + void propagate() noexcept; + + void print( std::ostream & os ) const; + + template + R handle\_error( error\_id, H && ... ) const; + + }; + + template + using context\_type\_from\_handlers = typename <>::type; + +} } +``` + +[Constructors](#context::context) | [`activate`](#context::activate) | [`deactivate`](#context::deactivate) | [`is_active`](#context::is_active) | [`propagate`](#context::propagate) | [`print`](#context::print) | [`handle_error`](#context::handle_error) | [`context_type_from_handlers`](#context_type_from_handlers) + +The `context` class template provides storage for each of the specified `E…​` types. Typically, `context` objects are not used directly; they’re created internally when the [`try_handle_some`](#try_handle_some), [`try_handle_all`](#try_handle_all) or [`try_catch`](#try_catch) functions are invoked, instantiated with types that are automatically deduced from the types of the arguments of the passed handlers. + +Independently, users can create `context` objects if they need to capture error objects and then transport them, by moving the `context` object itself. + +Even in that case it is recommended that users do not instantiate the `context` template by explicitly listing the `E…​` types they want it to be able to store. Instead, use [`context_type_from_handlers`](#context_type_from_handlers) or call the [`make_context`](#make_context) function template, which deduce the correct `E…​` types from a captured list of handler function objects. + +To be able to load up error objects in a `context` object, it must be activated. Activating a `context` object `ctx` binds it to the calling thread, setting thread-local pointers of the stored `E…​` types to point to the corresponding storage within `ctx`. It is possible, even likely, to have more than one active `context` in any given thread. In this case, activation/deactivation must happen in a LIFO manner. For this reason, it is best to use a [`context_activator`](#context_activator), which relies on RAII to activate and deactivate a `context`. + +When a `context` is deactivated, it detaches from the calling thread, restoring the thread-local pointers to their pre-`activate` values. Typically, at this point the stored error objects, if any, are either discarded (by default) or moved to corresponding storage in other `context` objects active in the calling thread (if available), by calling [`propagate`](#context::propagate). + +While error handling typically uses [`try_handle_some`](#try_handle_some), [`try_handle_all`](#try_handle_all) or [`try_catch`](#try_catch), it is also possible to handle errors by calling the member function [`handle_error`](#context::handle_error). It takes an [`error_id`](#error_id), and attempts to select an error handler based on the error objects stored in `*this`, associated with the passed `error_id`. + + + +| | | +| --- | --- | +| | `context` objects can be moved, as long as they aren’t active. + | + + + +| | | +| --- | --- | +| | +Moving an active `context` results in undefined behavior. + | + + +--- +#### Constructors +#include + + +``` +namespace boost { namespace leaf { + + template + context::context() noexcept; + + template + context::context( context && x ) noexcept; + +} } +``` + +The default constructor initializes an empty `context` object: it provides storage for, but does not contain any error objects. + +The move constructor moves the stored error objects from one `context` to the other. + + + +| | | +| --- | --- | +| | +Moving an active `context` object results in undefined behavior. + | + + +--- + +#### `activate` +#include + + +``` +namespace boost { namespace leaf { + + template + void context::activate() noexcept; + +} } +``` + + +Requires: + +`![is\_active](#context::is_active)()`. +Effects: + +Associates `*this` with the calling thread. +Ensures: + +`[is\_active](#context::is_active)()`. + + + +When a context is associated with a thread, thread-local pointers are set to point each `E…​` type in its store, while the previous value of each such pointer is preserved in the `context` object, so that the effect of `activate` can be undone by calling `deactivate`. + +When an error object is [loaded](#tutorial-loading), it is moved in the last activated (in the calling thread) `context` object that provides storage for its type (note that this may or may not be the last activated `context` object). If no such storage is available, the error object is discarded. + + +--- + +#### `deactivate` +#include + + +``` +namespace boost { namespace leaf { + + template + void context::deactivate() noexcept; + +} } +``` + + +Requires: + + +* `[is\_active](#context::is_active)()`; +* `*this` must be the last activated `context` object in the calling thread. + +Effects: + +Un-associates `*this` with the calling thread. +Ensures: + +`![is\_active](#context::is_active)()`. + + + +When a context is deactivated, the thread-local pointers that currently point to each individual error object storage in it are restored to their original value prior to calling [`activate`](#context::activate). + + +--- + +#### `handle_error` +#include + + +``` +namespace boost { namespace leaf { + + template + template + R context::handle\_error( error\_id err, H && ... h ) const; + +} } +``` + +This function works similarly to [`try_handle_all`](#try_handle_all), but rather than calling a `try_block` and obtaining the [`error_id`](#error_id) from a returned `result` type, it matches error objects (stored in `*this`, associated with `err`) with a suitable error handler from the `h…​` pack. + + + +| | | +| --- | --- | +| | +The caller is required to specify the return type `R`. This is because in general the supplied handlers may return different types (which must all be convertible to `R`). + | + + +--- + +#### `is_active` +#include + + +``` +namespace boost { namespace leaf { + + template + bool context::is\_active() const noexcept; + +} } +``` + + +Returns: + +`true` if the `*this` is active in any thread, `false` otherwise. + +--- + +#### `print` +#include + + +``` +namespace boost { namespace leaf { + + template + void context::print( std::ostream & os ) const; + +} } +``` + + +Effects: + +Prints all error objects currently stored in `*this`, together with the unique error ID each individual error object is associated with. + +--- + +#### `propagate` +#include + + +``` +namespace boost { namespace leaf { + + template + void context::propagate() noexcept; + +} } +``` + + +Requires: + +`![is\_active](#context::is_active)()`. +Effects: + +Each stored error object of some type `E` is moved into another `context` object active in the call stack that provides storage for objects of type `E`, if any, or discarded. + +--- + + +### `context_activator` +#include + + +``` +namespace boost { namespace leaf { + + template + class context\_activator + { + context\_activator( context\_activator const & ) = delete; + context\_activator & operator=( context\_activator const & ) = delete; + + public: + + explicit context\_activator( Ctx & ctx ) noexcept; + context\_activator( context\_activator && ) noexcept; + ~context\_activator() noexcept; + }; + +} } +``` + +`context_activator` is a simple class that activates and deactivates a [`context`](#context) using RAII: + +If `[ctx.is\_active](#context::is_active)`() is `true` at the time the `context_activator` is initialized, the constructor and the destructor have no effects. Otherwise: + +* The constructor stores a reference to `ctx` in `*this` and calls `[ctx.activate](#context::activate)`(). +* The destructor: + + + Has no effects if `ctx.is_active()` is `false` (that is, it is valid to call [`deactivate`](#context::deactivate) manually, before the `context_activator` object expires); + + Otherwise, calls `[ctx.deactivate](#context::deactivate)`() and, if there are new uncaught exceptions since the constructor was called, the destructor calls `[ctx.propagate](#context::propagate)`(). + +For automatic deduction of `Ctx`, use [`activate_context`](#activate_context). + + +--- + +### `diagnostic_info` +#include + + +``` +namespace boost { namespace leaf { + + class diagnostic\_info: public error\_info + { + //Constructors unspecified + + friend std::ostream & operator<<( std::ostream & os, diagnostic\_info const & x ); + }; + +} } +``` + +Handlers passed to [`try_handle_some`](#try_handle_some), [`try_handle_all`](#try_handle_all) or [`try_catch`](#try_catch) may take an argument of type `diagnostic_info const &` if they need to print diagnostic information about the error. + +The message printed by `operator<<` includes the message printed by `error_info`, followed by basic information about error objects that were communicated to LEAF (to be associated with the error) for which there was no storage available in any active [`context`](#context) (these error objects were discarded by LEAF, because no handler needed them). + +The additional information is limited to the type name of the first such error object, as well as their total count. + + + +| | | +| --- | --- | +| | +The behavior of `diagnostic_info` (and [`verbose_diagnostic_info`](#verbose_diagnostic_info)) is affected by the value of the macro `BOOST_LEAF_DIAGNOSTICS`: + + +* If it is 1 (the default), LEAF produces `diagnostic_info` but only if an active error handling context on the call stack takes an argument of type `diagnostic_info`; +* If it is 0, the `diagnostic_info` functionality is stubbed out even for error handling contexts that take an argument of type `diagnostic_info`. This could shave a few cycles off the error path in some programs (but it is probably not worth it). + + + | + + +--- + +### `error_id` +#include + + +``` +namespace boost { namespace leaf { + + class error\_id + { + public: + + error\_id() noexcept; + + template + result( Enum e, typename std::enable\_if::value, Enum>::type \* = 0 ) noexcept; + + error\_id( std::error\_code const & ec ) noexcept; + + int value() const noexcept; + explicit operator bool() const noexcept; + + std::error\_code to\_error\_code() const noexcept; + + friend bool operator==( error\_id a, error\_id b ) noexcept; + friend bool operator!=( error\_id a, error\_id b ) noexcept; + friend bool operator<( error\_id a, error\_id b ) noexcept; + + template + error\_id load( Item && ... item ) const noexcept; + + friend std::ostream & operator<<( std::ostream & os, error\_id x ); + }; + + bool is\_error\_id( std::error\_code const & ec ) noexcept; + + template + error\_id new\_error( E && ... e ) noexcept; + + error\_id current\_error() noexcept; + +} } +``` + +[Constructors](#error_id::error_id) | [`value`](#error_id::value) | [`operator bool`](#error_id::operator_bool) | [`to_error_code`](#error_id::to_error_code) | [`operator==`, `!=`, `<`](#error_id::comparison_operators) | [`load`](#error_id::load) | [`is_error_id`](#is_error_id) | [`new_error`](#new_error) | [`current_error`](#current_error) + +Values of type `error_id` identify a specific occurrence of a failure across the entire program. They can be copied, moved, assigned to, and compared to other `error_id` objects. They’re as efficient as an `int`. + + +--- +#### Constructors +#include + + +``` +namespace boost { namespace leaf { + + error\_id::error\_id() noexcept = default; + + template + error\_id::error\_id( Enum e, typename std::enable\_if::value, Enum>::type \* = 0 ) noexcept; + + error\_id::error\_id( std::error\_code const & ec ) noexcept; + +} } +``` + +A default-initialized `error_id` object does not represent a specific failure. It compares equal to any other default-initialized `error_id` object. All other `error_id` objects identify a specific occurrence of a failure. + + + +| | | +| --- | --- | +| | +When using an object of type `error_id` to initialize a `result` object, it will be initialized in error state, even when passing a default-initialized `error_id` value. + | + +Converting an `error_id` object to `std::error_code` uses an unspecified `std::error_category` which LEAF recognizes. This allows an `error_id` to be transported through interfaces that work with `std::error_code`. The `std::error_code` constructor allows the original `error_id` to be restored. + + + +| | | +| --- | --- | +| | +To check if a given `std::error_code` is actually carrying an `error_id`, use [`is_error_id`](#is_error_id). + | + +Typically, users create new `error_id` objects by invoking [`new_error`](#new_error). The constructor that takes `std::error_code`, and the one that takes a type `Enum` for which `std::is_error_code_enum::value` is `true`, have the following effects: + +* If `ec.value()` is `0`, the effect is the same as using the default constructor. +* Otherwise, if `[is\_error\_id](#is_error_id)(ec)` is `true`, the original `error_id` value is used to initialize `*this`; +* Otherwise, `*this` is initialized by the value returned by [`new_error`](#new_error), while `ec` is passed to `load`, which enables handlers used with `try_handle_some`, `try_handle_all` or `try_catch` to receive it as an argument of type `std::error_code`. + + +--- + +#### `is_error_id` +#include + + +``` +namespace boost { namespace leaf { + + bool is\_error\_id( std::error\_code const & ec ) noexcept; + +} } +``` + + +Returns: + +`true` if `ec` uses the LEAF-specific `std::error_category` that identifies it as carrying an error ID rather than another error code; otherwise returns `false`. + +--- + +#### `load` +#include + + +``` +namespace boost { namespace leaf { + + template + error\_id error\_id::load( Item && ... item ) const noexcept; + +} } +``` + + +Requires: + +Each of the `Item…​` types must be no-throw movable. +Effects: + + +* If `value()==0`, all of `item…​` are discarded and no further action is taken. +* Otherwise, what happens with each `item` depends on its type: + + + If it is a function that takes a single argument of some type `E &`, that function is called with the object of type `E` currently associated with `*this`. If no such object exists, a default-initialized object is associated with `*this` and then passed to the function. + + If it is a function that takes no arguments, than function is called to obtain an error object, which is associated with `*this`. + + Otherwise, the `item` itself is assumed to be an error object, which is associated with `*this`. + +Returns: + +`*this`. + + +| | | +| --- | --- | +| | `load` discards error objects which are not used in any active error-handling calling scope. + | + + + +| | | +| --- | --- | +| | +When loaded into a `context`, an error object of a type `E` will overwrite the previously loaded object of type `E`, if any. + | + + +See also: + +[Loading of Error Objects](#tutorial-loading). + +--- + +#### `operator==`, `!=`, `<` +#include + + +``` +namespace boost { namespace leaf { + + friend bool operator==( error\_id a, error\_id b ) noexcept; + friend bool operator!=( error\_id a, error\_id b ) noexcept; + friend bool operator<( error\_id a, error\_id b ) noexcept; + +} } +``` + +These functions have the usual semantics, comparing `a.value()` and `b.value()`. + + + +| | | +| --- | --- | +| | +The exact strict weak ordering implemented by `operator<` is not specified. In particular, if for two `error_id` objects `a` and `b`, `a < b` is true, it does not follow that the failure identified by `a` ocurred earlier than the one identified by `b`. + | + + +--- + +#### `operator bool` +#include + + +``` +namespace boost { namespace leaf { + + explicit error\_id::operator bool() const noexcept; + +} } +``` + + +Effects: + +As if `return value()!=0`. + +--- + +#### `to_error_code` +#include + + +``` +namespace boost { namespace leaf { + + std::error\_code error\_id::to\_error\_code() const noexcept; + +} } +``` + + +Effects: + +Returns a `std::error_code` with the same `value()` as `*this`, using an unspecified `std::error_category`. + + +| | | +| --- | --- | +| | +The returned object can be used to initialize an `error_id`, in which case the original `error_id` value will be restored. + | + + + +| | | +| --- | --- | +| | +Use [`is_error_id`](#is_error_id) to check if a given `std::error_code` carries an `error_id`. + | + + +--- + +#### `value` +#include + + +``` +namespace boost { namespace leaf { + + int error\_id::value() const noexcept; + +} } +``` + + +Effects: + + +* If `*this` was initialized using the default constructor, returns 0. +* Otherwise returns an `int` that is guaranteed to not be 0: a program-wide unique identifier of the failure. + + +--- + + +### `error_monitor` +#include + + +``` +namespace boost { namespace leaf { + + class error\_monitor + { + public: + + error\_monitor() noexcept; + + error\_id check() const noexcept; + + error\_id assigned\_error\_id( E && ... e ) const noexcept; + }; + +} } +``` + +This class helps obtain an [`error_id`](#error_id) to associate error objects with, when augmenting failures communicated using LEAF through uncooperative APIs that do not use LEAF to report errors (and therefore do not return an `error_id` on error). + +The common usage of this class is as follows: + + + +``` +error\_code compute\_value( int \* out\_value ) noexcept; **(1)** + +leaf::error augmenter() noexcept +{ + leaf::error\_monitor cur\_err; **(2)** + + int val; + auto ec = compute\_value(&val); + + if( failure(ec) ) + return cur\_err.assigned\_error\_id().load(e1, e2, ...); **(3)** + else + return val; **(4)** +} +``` + + + +| | | +| --- | --- | +| **1** | Uncooperative third-party API that does not use LEAF, but may result in calling a user callback that does use LEAF. In case our callback reports a failure, we’ll augment it with error objects available in the calling scope, even though `compute_value` can not communicate an [`error_id`](#error_id). | +| **2** | Initialize an `error_monitor` object. | +| **3** | The call to `compute_value` has failed: + +* If [`new_error`](#new_error) was invoked (by the calling thread) after the `augment` object was initialized, `assigned_error_id` returns the last `error_id` returned by `new_error`. This would be the case if the failure originates in our callback (invoked internally by `compute_value`). +* Else, `assigned_error_id` invokes `new_error` and returns that `error_id`. + + + | +| **4** | The call was successful, return the computed value. | + +The `check` function works similarly, but instead of invoking `new_error` it returns a default-initialized `error_id`. + + + +| | | +| --- | --- | +| | +See [Using `error_monitor` to Report Arbitrary Errors from C-callbacks](#tutorial-on_error_in_c_callbacks). + | + + +--- + +### `e_api_function` +#include + + +``` +namespace boost { namespace leaf { + + struct e\_api\_function {char const \* value;}; + +} } +``` + +The `e_api_function` type is designed to capture the name of the API function that failed. For example, if you’re reporting an error from `fread`, you could use `leaf::e_api_function {"fread"}`. + + + +| | | +| --- | --- | +| | +The passed value is stored as a C string (`char const *`), so `value` should only be initialized with a string literal. + | + + +--- + +### `e_at_line` +#include + + +``` +namespace boost { namespace leaf { + + struct e\_at\_line { int value; }; + +} } +``` + +`e_at_line` can be used to communicate the line number when reporting errors (for example parse errors) about a text file. + + +--- + +### `e_errno` +#include + + +``` +namespace boost { namespace leaf { + + struct e\_errno + { + int value; + friend std::ostream & operator<<( std::ostream & os, e\_errno const & err ); + }; + +} } +``` + +To capture `errno`, use `e_errno`. When printed in automatically-generated diagnostic messages, `e_errno` objects use `strerror` to convert the `errno` code to string. + + +--- + +### `e_file_name` +#include + + +``` +namespace boost { namespace leaf { + + struct e\_file\_name { std::string value; }; + +} } +``` + +When a file operation fails, you could use `e_file_name` to store the name of the file. + + + +| | | +| --- | --- | +| | +It is probably better to define your own file name wrappers to avoid clashes if different modules all use `leaf::e_file_name`. It is best to use a descriptive name that clarifies what kind of file name it is (e.g. `e_source_file_name`, `e_destination_file_name`), or at least define `e_file_name` in a given module’s namespace. + | + + +--- + +### `e_LastError` +#include + + +``` +namespace boost { namespace leaf { + + namespace windows + { + struct e\_LastError + { + unsigned value; + friend std::ostream & operator<<( std::ostream & os, e\_LastError const & err ); + }; + } + +} } +``` + +`e_LastError` is designed to communicate `GetLastError()` values on Windows. + + +--- + +### `e_source_location` +#include + + +``` +namespace boost { namespace leaf { + + struct e\_source\_location + { + char const \* const file; + int const line; + char const \* const function; + + friend std::ostream & operator<<( std::ostream & os, e\_source\_location const & x ); + }; + +} } +``` + +The [`NEW_ERROR`](#BOOST_LEAF_NEW_ERROR), [`EXCEPTION`](#BOOST_LEAF_EXCEPTION) and [`THROW_EXCEPTION`](#BOOST_LEAF_THROW_EXCEPTION) macros capture `__FILE__`, `__LINE__` and `__FUNCTION__` into a `e_source_location` object. + + +--- + +### `e_type_info_name` +#include + + +``` +namespace boost { namespace leaf { + + struct e\_type\_info\_name { char const \* value; }; + +} } +``` + +`e_type_info_name` is designed to store the return value of `std::type_info::name`. + + +--- + +### `error_info` +#include + + +``` +namespace boost { namespace leaf { + + class error\_info + { + //Constructors unspecified + + public: + + error\_id error() const noexcept; + + bool exception\_caught() const noexcept; + std::exception const \* exception() const noexcept; + + friend std::ostream & operator<<( std::ostream & os, error\_info const & x ); + }; + +} } +``` + +Handlers passed to error-handling functions such as [`try_handle_some`](#try_handle_some), [`try_handle_all`](#try_handle_all) or [`try_catch`](#try_catch) may take an argument of type `error_info const &` to receive generic information about the error being handled. + +The `error` member function returns the program-wide unique [`error_id`](#error_id) of the error. + +The `exception_caught` member function returns `true` if the handler that received `*this` is being invoked to handle an exception, `false` otherwise. + +If handling an exception, the `exception` member function returns a pointer to the `std::exception` subobject of the caught exception, or `0` if that exception could not be converted to `std::exception`. + + + +| | | +| --- | --- | +| | +It is illegal to call the `exception` member function unless `exception_caught()` is `true`. + | + +The `operator<<` overload prints diagnostic information about each error object currently stored in the [`context`](#context) local to the [`try_handle_some`](#try_handle_some), [`try_handle_all`](#try_handle_all) or [`try_catch`](#try_catch) scope that invoked the handler, but only if it is associated with the [`error_id`](#error_id) returned by `error()`. + + +--- + +### `polymorphic_context` +#include + + +``` +namespace boost { namespace leaf { + + class polymorphic\_context + { + protected: + + polymorphic\_context() noexcept; + ~polymorphic\_context() noexcept; + + public: + + virtual void activate() noexcept = 0; + virtual void deactivate() noexcept = 0; + virtual bool is\_active() const noexcept = 0; + + virtual void propagate() noexcept = 0; + + virtual void print( std::ostream & ) const = 0; + }; + +} } +``` + +The `polymorphic_context` class is an abstract base type which can be used to erase the type of the exact instantiation of the [`context`](#context) class template used. See [`make_shared_context`](#make_shared_context). + + +--- + +### `result` +#include + + +``` +namespace boost { namespace leaf { + + template + class result + { + public: + + result() noexcept; + result( T && v ) noexcept; + result( T const & v ); + + template + result( U &&, <> ); + + result( error\_id err ) noexcept; + result( std::shared\_ptr && ctx ) noexcept; + + template + result( Enum e, typename std::enable\_if::value, Enum>::type \* = 0 ) noexcept; + + result( std::error\_code const & ec ) noexcept; + + result( result && r ) noexcept; + + template + result( result && r ) noexcept; + + result & operator=( result && r ) noexcept; + + template + result & operator=( result && r ) noexcept; + + explicit operator bool() const noexcept; + + T const & value() const; + T & value(); + + T const & operator\*() const; + T & operator\*(); + + T const \* operator->() const; + T \* operator->(); + + <> error() noexcept; + + template + error\_id load( Item && ... item ) noexcept; + }; + + template <> + class result + { + public: + + result() noexcept; + + result( error\_id err ) noexcept; + result( std::shared\_ptr && ctx ) noexcept; + + template + result( Enum e, typename std::enable\_if::value, Enum>::type \* = 0 ) noexcept; + + result( std::error\_code const & ec ) noexcept; + + result( result && r ) noexcept; + + template + result( result && r ) noexcept; + + result & operator=( result && r ) noexcept; + + template + result & operator=( result && r ) noexcept; + + explicit operator bool() const noexcept; + + void value() const; + + <> error() noexcept; + + template + error\_id load( Item && ... item ) noexcept; + }; + + struct bad\_result: std::exception { }; + +} } +``` + +[Constructors](#result::result) | [`operator=`](#result::operator_eq) | [`operator bool`](#result::operator_bool) | [`value`, `operator*`, `->`](#result::value) | [`error`](#result::error) | [`load`](#result::load) + +The `result` type can be returned by functions which produce a value of type `T` but may fail doing so. + + +Requires: + +`T` must be movable, and its move constructor may not throw. +Invariant: + +A `result` object is in one of three states: +* Value state, in which case it contains an object of type `T`, and `[value](#result::value)`/`[operator\*](#result::value)`/`[operator->](#result::value)` can be used to access the contained value. +* Error state, in which case it contains an error ID, and calling `[value](#result::value)`/`[operator\*](#result::value)`/`[operator->](#result::value)` throws `leaf::bad_result`. +* Error-capture state, which is the same as the Error state, but in addition to the error ID, it holds a `std::shared_ptr<[polymorphic\_context](#polymorphic_context)>`. + +`result` objects are nothrow-moveable but are not copyable. + + +--- +#### Constructors + + +#include + + +``` +namespace boost { namespace leaf { + + template + result::result() noexcept; + + template + result::result( T && v ) noexcept; **(1)** + + template + result::result( T const & v ); **(1)** + + template + result::result( U && u, <> ); **(2)** + + template + result::result( leaf::error\_id err ) noexcept; + + template + template + result::result( Enum e, typename std::enable\_if::value, Enum>::type \* = 0 ) noexcept; + + template + result::result( std::error\_code const & ec ) noexcept; + + template + result::result( std::shared\_ptr && ctx ) noexcept; + + template + result::result( result && ) noexcept; + + template + template + result::result( result && ) noexcept; + +} } +``` + + + +| | | +| --- | --- | +| **1** | Not available if `T` is `void`. | +| **2** | Available if an object of type `T` can be initialized with `std::forward(u)`. This is to enable e.g. `result` to be initialized with a string literal. | + +Requires: + +`T` must be movable, and its move constructor may not throw; or `void`. +Effects: + +Establishes the `result` invariant: + + +* To get a `result` in [Value state](#result), initialize it with an object of type `T` or use the default constructor. +* To get a `result` in [Error state](#result), initialize it with: + + + an [`error_id`](#error_id) object. + + + + + + | | | + | --- | --- | + | | + Initializing a `result` with a default-initialized `error_id` object (for which `.value()` returns `0`) will still result in [Error state](#result)! + | + + a `std::error_code` object. + + an object of type `Enum` for which `std::is_error_code_enum::value` is `true`. +* To get a `result` in [Error-capture state](#result), initialize it with a `std::shared_ptr<[polymorphic\_context](#polymorphic_context)>` (which can be obtained by calling e.g. [`make_shared_context`](#make_shared_context)). + + + +When a `result` object is initialized with a `std::error_code` object, it is used to initialize an `error_id` object, then the behavior is the same as if initialized with `error_id`. + +Throws: + + +* Initializing the `result` in Value state may throw, depending on which constructor of `T` is invoked; +* Other constructors do not throw. + + + +| | | +| --- | --- | +| | +A `result` that is in value state converts to `true` in boolean contexts. A `result` that is not in value state converts to `false` in boolean contexts. + | + + + +| | | +| --- | --- | +| | `result` objects are nothrow-moveable but are not copyable. + | + + +--- + +#### `error` +#include + + +``` +namespace boost { namespace leaf { + + template + <> result::error() noexcept; + +} } +``` + +Returns: A proxy object of unspecified type, implicitly convertible to any instance of the `result` class template, as well as to [`error_id`](#error_id). + +* If the proxy object is converted to some `result`: + + + If `*this` is in [Value state](#result), returns `result(error_id())`. + + Otherwise the state of `*this` is moved into the returned `result`. +* If the proxy object is converted to an `error_id`: + + + If `*this` is in [Value state](#result), returns a default-initialized [`error_id`](#error_id) object. + + If `*this` is in [Error-capture state](#result), all captured error objects are [loaded](#tutorial-loading) in the calling thread, and the captured `error_id` value is returned. + + If `*this` is in [Error state](#result), returns the stored `error_id`. +* If the proxy object is not used, the state of `*this` is not modified. + + + +| | | +| --- | --- | +| | +The returned proxy object refers to `*this`; avoid holding on to it. + | + + +--- + +#### `load` +#include + + +``` +namespace boost { namespace leaf { + + template + template + error\_id result::load( Item && ... item ) noexcept; + +} } +``` + +This member function is designed for use in `return` statements in functions that return `result` to forward additional error objects to the caller. + + +Effects: + +As if `error_id(this->error()).load(std::forward(item)…​)`. +Returns: + +`*this`. + +--- + +#### `operator=` +#include + + +``` +namespace boost { namespace leaf { + + template + result & result::operator=( result && ) noexcept; + + template + template + result & result::operator=( result && ) noexcept; + +} } +``` + + +Effects: + +Destroys `*this`, then re-initializes it as if using the appropriate `result` constructor. Basic exception-safety guarantee. + +--- + +#### `operator bool` +#include + + +``` +namespace boost { namespace leaf { + + template + result::operator bool() const noexcept; + +} } +``` + + +Returns: + +If `*this` is in [value state](#result), returns `true`, otherwise returns `false`. + +--- + +#### `value`, `operator*`, `->` +#include + + +``` +namespace boost { namespace leaf { + + void result::value() const; **(1)** + + template + T const & result::value() const; **(2)** + + template + T & result::value(); + + template + T const & result::operator\*() const; **(2)** + + template + T & result::operator\*(); + + template + T const \* result::operator->() const; **(2)** + + template + T \* result::operator->(); **(2)** + + struct bad\_result: std::exception { }; + +} } +``` + + + +| | | +| --- | --- | +| **1** | Only when `T` is `void`. | +| **2** | Only when `T` is not `void`. | + + +Effects: + +If `*this` is in [value state](#result), returns a reference (or pointer) to the stored value, otherwise throws `bad_result`. + +--- + + +### `verbose_diagnostic_info` +#include + + +``` +namespace boost { namespace leaf { + + class verbose\_diagnostic\_info: public error\_info + { + //Constructors unspecified + + friend std::ostream & operator<<( std::ostream & os, verbose\_diagnostic\_info const & x ); + }; + +} } +``` + +Handlers passed to error-handling functions such as [`try_handle_some`](#try_handle_some), [`try_handle_all`](#try_handle_all) or [`try_catch`](#try_catch) may take an argument of type `verbose_diagnostic_info const &` if they need to print diagnostic information about the error. + +The message printed by `operator<<` includes the message printed by `error_info`, followed by information about error objects that were communicated to LEAF (to be associated with the error) for which there was no storage available in any active [`context`](#context) (these error objects were discarded by LEAF, because no handler needed them). + +The additional information includes the types and the values of all such error objects. + + + +| | | +| --- | --- | +| | +The behavior of `verbose_diagnostic_info` (and [`diagnostic_info`](#diagnostic_info)) is affected by the value of the macro `BOOST_LEAF_DIAGNOSTICS`: + + +* If it is 1 (the default), LEAF produces `verbose_diagnostic_info` but only if an active error handling context on the call stack takes an argument of type `verbose_diagnostic_info`; +* If it is 0, the `verbose_diagnostic_info` functionality is stubbed out even for error handling contexts that take an argument of type `verbose_diagnostic_info`. This could save some cycles on the error path in some programs (but is probably not worth it). + + + | + + + +| | | +| --- | --- | +| | +Using `verbose_diagnostic_info` will likely allocate memory dynamically. + | + +Reference: Predicates +--------------------- + + + +| | | +| --- | --- | +| | +The contents of each Reference section are organized alphabetically. + | + +A predicate is a special type of error handler argument which enables the [handler selection procedure](#handler_selection_procedure) to consider the *value* of available error objects, not only their type; see [Using Predicates to Handle Errors](#tutorial-predicates). + +The following predicates are available: + +* [`match`](#match) +* [`match_value`](#match_value) +* [`match_member`](#match_member) +* [`catch_`](#catch_) +* [`if_not`](#if_not) + +In addition, any user-defined type `Pred` for which `[is\_predicate](#is_predicate)::value` is `true` is treated as a predicate. In this case, it is required that: + +* `Pred` defines an accessible member type `error_type` to specify the error object type it requires; +* `Pred` defines an accessible static member function `evaluate`, which returns a boolean type, and can be invoked with an object of type `error_type const &`; +* A `Pred` instance can be initialized with an object of type `error_type`. + +When an error handler takes an argument of a predicate type `Pred`, the [handler selection procedure](#handler_selection_procedure) drops the handler if an error object `e` of type `Pred::error_type` is not available. Otherwise, the handler is dropped if `Pred::evaluate(e)` returns `false`. If the handler is invoked, the `Pred` argument is initialized with `Pred{e}`. + + + +| | | +| --- | --- | +| | +Predicates are evaluated before the error handler is invoked, and so they may not access dynamic state (of course the error handler itself can access dynamic state, e.g. by means of lambda expression captures). + | + +Example 1: + + +``` +enum class my\_error { e1 = 1, e2, e3 }; + +struct my\_pred +{ + using error\_type = my\_error; **(1)** + + static bool evaluate(my\_error) noexcept; **(2)** + + my\_error matched; **(3)** +} + +namespace boost { namespace leaf { + + template <> + struct is\_predicate: std::true\_type + { + }; + +} } +``` + + + +| | | +| --- | --- | +| **1** | This predicate requires an error object of type `my_error`. | +| **2** | The handler selection procedure will call this function with an object `e` of type `my_error` to evaluate the predicate…​ | +| **3** | …​and if successful, initialize the `my_pred` error handler argument with `my_pred{e}`. | + +Example 2: + + +``` +struct my\_pred +{ + using error\_type = leaf::e\_errno; **(1)** + + static bool evaluate(leaf::e\_errno const &) noexcept; **(2)** + + leaf::e\_errno const & matched; **(3)** +} + +namespace boost { namespace leaf { + + template <> + struct is\_predicate: std::true\_type + { + }; + +} } +``` + + + +| | | +| --- | --- | +| **1** | This predicate requires an error object of type [`e_errno`](#e_errno). | +| **2** | The handler selection procedure will call this function with an object `e` of type `e_errno` to evaluate the predicate…​ | +| **3** | …​and if successful, initialize the `my_pred` error handler argument with `my_pred{e}`. | + + +--- +### `catch_` +#include + + +``` +namespace boost { namespace leaf { + + template + struct catch\_ + { + std::exception const & matched; + + // Other members not specified + }; + + template + struct catch\_ + { + Ex const & matched; + + // Other members not specified + }; + + template + struct is\_predicate>: std::true\_type + { + }; + +} } +``` + +[`is_predicate`](#is_predicate) + +When an error handler takes an argument of type that is an instance of the `catch_` template, the [handler selection procedure](#handler_selection_procedure) first checks if a `std::exception` was caught. If not, the handler is dropped. Otherwise, the handler is dropped if the caught `std::exception` can not be `dynamic_cast` to any of the specified types `Ex…​`. + +If the error handler is invoked, the `matched` member can be used to access the exception object. + + + +| | | +| --- | --- | +| | +See also: [Using Predicates to Handle Errors](#tutorial-predicates). + | + + + +| | | +| --- | --- | +| | +While `catch_` requires that the caught exception object is of type that derives from `std::exception`, it is not required that the `Ex…​` types derive from `std::exception`. + | + +Example 1: + + +``` +struct ex1: std::exception { }; +struct ex2: std::exception { }; + +leaf::try\_catch( + [] + { + return f(); // throws + }, + + [](leaf::catch\_ c) + { **(1)** + assert(dynamic\_cast(&c.matched) || dynamic\_cast(&c.matched)); + .... + } ); +``` + + + +| | | +| --- | --- | +| **1** | The handler is selected if `f` throws an exception of type `ex1` or `ex2`. | + +Example 2: + + +``` +struct ex1: std::exception { }; + +leaf::try\_handle\_some( + [] + { + return f(); // returns leaf::result + }, + + [](ex1 & e) + { **(1)** + .... + } ); +``` + + + +| | | +| --- | --- | +| **1** | The handler is selected if `f` throws an exception of type `ex1`. Notice that if we’re interested in only one exception type, as long as that type derives from `std::exception`, the use of `catch_` is not required. | + + +--- + +### `if_not` +#include + + +``` +namespace boost { namespace leaf { + + template + struct if\_not + { + <> matched; + + // Other members not specified + }; + + template + struct is\_predicate>: std::true\_type + { + }; + +} } +``` + +[`is_predicate`](#is_predicate) + +When an error handler takes an argument of type `if_not

`, where `P` is another predicate type, the [handler selection procedure](#handler_selection_procedure) first checks if an error object of the type `E` required by `P` is available. If not, the handler is dropped. Otherwise, the handler is dropped if `P` evaluates to `true`. + +If the error handler is invoked, `matched` can be used to access the matched object `E`. + + + +| | | +| --- | --- | +| | +See also [Using Predicates to Handle Errors](#tutorial-predicates). + | + +Example: + + +``` +enum class my\_enum { e1, e2, e3 }; + +leaf::try\_handle\_some( + [] + { + return f(); // returns leaf::result + }, + + []( leaf::if\_not> ) + { **(1)** + .... + } ); +``` + +[`try_handle_some`](#try_handle_some) | [`match`](#match) + + + +| | | +| --- | --- | +| **1** | The handler is selected if an object of type `my_enum`, which **does not** compare equal to `e1` or to `e2`, **is** associated with the detected error. | + + +--- + +### `match` +#include + + +``` +namespace boost { namespace leaf { + + template + class match + { + <> matched; + + // Other members not specified + }; + + template + struct is\_predicate>: std::true\_type + { + }; + +} } +``` + +[`is_predicate`](#is_predicate) + +When an error handler takes an argument of type `match`, the [handler selection procedure](#handler_selection_procedure) first checks if an error object `e` of type `E` is available. If it is not available, the handler is dropped. Otherwise, the handler is dropped if the following condition is not met: + +`p1 || p2 || …​ pn`. + +Generally, `pi` is equivalent to `e == Vi`, except if `Vi` is pointer to a function + +`bool (*Vi)(T x)`. + +In this case it is required that `Vi != 0` and that `x` can be initialized with `E const &`, and `pi` is equivalent to: + +`Vi(e)`. + +In particular, it is valid to pass pointer to the function `leaf::category` for any `Vi`, where: + +`std::is_error_code_enum::value || std::is_error_condition_enum::value`. + +In this case, `pi` is equivalent to: + +`&e.category() == &std::error_code(Enum{}).category()`. + +If the error handler is invoked, `matched` can be used to access `e`. + + + +| | | +| --- | --- | +| | +See also [Using Predicates to Handle Errors](#tutorial-predicates). + | + +Example 1: Handling of a subset of enum values. + + +``` +enum class my\_enum { e1, e2, e3 }; + +leaf::try\_handle\_some( + [] + { + return f(); // returns leaf::result + }, + + []( leaf::match m ) + { **(1)** + static\_assert(std::is\_same::value); + assert(m.matched == my\_enum::e1 || m.matched == my\_enum::e2); + .... + } ); +``` + + + +| | | +| --- | --- | +| **1** | The handler is selected if an object of type `my_enum`, which compares equal to `e1` or to `e2`, is associated with the detected error. | + +Example 2: Handling of a subset of std::error\_code enum values (requires at least C++17, see Example 4 for a C++11-compatible workaround). + + +``` +enum class my\_enum { e1=1, e2, e3 }; + +namespace std +{ + template <> struct is\_error\_code\_enum: std::true\_type { }; +} + +leaf::try\_handle\_some( + [] + { + return f(); // returns leaf::result + }, + + []( leaf::match m ) + { **(1)** + static\_assert(std::is\_same::value); + assert(m.matched == my\_enum::e1 || m.matched == my\_enum::e2); + .... + } ); +``` + + + +| | | +| --- | --- | +| **1** | The handler is selected if an object of type `std::error_code`, which compares equal to `e1` or to `e2`, is associated with the detected error. | + +Example 3: Handling of a specific std::error\_code::category (requires at least C++17). + + +``` +enum class enum\_a { a1=1, a2, a3 }; +enum class enum\_b { b1=1, b2, b3 }; + +namespace std +{ + template <> struct is\_error\_code\_enum: std::true\_type { }; + template <> struct is\_error\_code\_enum: std::true\_type { }; +} + +leaf::try\_handle\_some( + [] + { + return f(); // returns leaf::result + }, + + []( leaf::match, enum\_b::b2> m ) + { **(1)** + static\_assert(std::is\_same::value); + assert(&m.matched.category() == &std::error\_code(enum\_{}).category() || m.matched == enum\_b::b2); + .... + } ); +``` + + + +| | | +| --- | --- | +| **1** | The handler is selected if an object of type `std::error_code`, which either has the same `std::error_category` as that of `enum_a` or compares equal to `enum_b::b2`, is associated with the detected error. | + +The use of the `leaf::category` template requires automatic deduction of the type of each `Vi`, which in turn requires C++17 or newer. The same applies to the use of `std::error_code` as `E`, but LEAF provides a compatible C++11 workaround for this case, using the template `condition`. The following is equivalent to Example 2: + +Example 4: Handling of a subset of std::error\_code enum values using the C++11-compatible API. + + +``` +enum class my\_enum { e1=1, e2, e3 }; + +namespace std +{ + template <> struct is\_error\_code\_enum: std::true\_type { }; +} + +leaf::try\_handle\_some( + [] + { + return f(); // returns leaf::result + }, + + []( leaf::match, my\_enum::e1, my\_enum::e2> m ) + { + static\_assert(std::is\_same::value); + assert(m.matched == my\_enum::e1 || m.matched == my\_enum::e2); + .... + } ); +``` + +Instead of a set of values, the `match` template can be given pointers to functions that implement a custom comparison. In the following example, we define a handler which will be selected to handle any error that communicates an object of the user-defined type `severity` with value greater than 4: + +Example 5: Handling of failures with severity::value greater than a specified threshold (requires at least C++17). + + +``` +struct severity { int value; } + +template +constexpr bool severity\_greater\_than( severity const & e ) noexcept +{ + return e.value > S; +} + +leaf::try\_handle\_some( + [] + { + return f(); // returns leaf::result + }, + + []( leaf::match> m ) + { + static\_assert(std::is\_same::value); + assert(m.matched.value > 4); + .... + } ); +``` + + +--- + +### `match_member` +#include + + +``` +namespace boost { namespace leaf { + + template + struct match\_member; + + template + struct match\_member + { + E const & matched; + + // Other members not specified + }; + + template + struct is\_predicate>: std::true\_type + { + }; + +} } +``` + +[`is_predicate`](#is_predicate) + +This predicate is similar to [`match_value`](#match_value), but able to bind any accessible data member of `E`; e.g. `match_member<&E::value, V…​>` is equivalent to `match_value`. + + + +| | | +| --- | --- | +| | +See also [Using Predicates to Handle Errors](#tutorial-predicates). + | + + + +| | | +| --- | --- | +| | `match_member` requires at least C++17, whereas `match_value` does not. + | + + +--- + +### `match_value` +#include + + +``` +namespace boost { namespace leaf { + + template + struct match\_value + { + E const & matched; + + // Other members not specified + }; + + template + struct is\_predicate>: std::true\_type + { + }; + +} } +``` + +[`is_predicate`](#is_predicate) + +This predicate is similar to [`match`](#match), but where `match` compares the available error object `e` of type `E` to the specified values `V…​`, `match_value` works with `e.value`. + + + +| | | +| --- | --- | +| | +See also [Using Predicates to Handle Errors](#tutorial-predicates). + | + +Example: + + +``` +struct e\_errno { int value; } + +leaf::try\_handle\_some( + [] + { + return f(); // returns leaf::result + }, + + []( leaf::match\_value m ) + { **(1)** + static\_assert(std::is\_same::value); + assert(m.matched.value == ENOENT); + .... + } ); +``` + + + +| | | +| --- | --- | +| **1** | The handler is selected if an object of type [`e_errno`](#e_errno), with `.value` equal to `ENOENT`, is associated with the detected error. | + +Reference: Traits +----------------- + + + +| | | +| --- | --- | +| | +The contents of each Reference section are organized alphabetically. + | + +### `is_predicate` +#include > + + +``` +namespace boost { namespace leaf { + + template + struct is\_predicate: std::false\_type + { + }; + +} } +``` + +The `is_predicate` template is used by the [handler selection procedure](#handler_selection_procedure) to detect predicate types. See [Using Predicates to Handle Errors](#tutorial-predicates). + + +--- + +### `is_result_type` +#include > + + +``` +namespace boost { namespace leaf { + + template + struct is\_result\_type: std::false\_type + { + }; + +} } +``` + +The error-handling functionality provided by [`try_handle_some`](#try_handle_some) and [`try_handle_all`](#try_handle_all) — including the ability to [load](#tutorial-loading) error objects of arbitrary types — is compatible with any external `result` type R, as long as for a given object `r` of type `R`: + +* If `bool(r)` is `true`, `r` indicates success, in which case it is valid to call `r.value()` to recover the `T` value. +* Otherwise `r` indicates a failure, in which case it is valid to call `r.error()`. The returned value is used to initialize an `error_id` (note: `error_id` can be initialized by `std::error_code`). + +To use an external `result` type R, you must specialize the `is_result_type` template so that `is_result_type::value` evaluates to `true`. + +Naturally, the provided `leaf::[result](#result)` class template satisfies these requirements. In addition, it allows error objects to be transported across thread boundaries, using a `std::shared_ptr<[polymorphic\_context](#polymorphic_context)>`. + +Reference: Macros +----------------- + + + +| | | +| --- | --- | +| | +The contents of each Reference section are organized alphabetically. + | + + +--- +### `BOOST_LEAF_` +#### `ASSIGN` +#include + + +``` +#define BOOST\_LEAF\_ASSIGN(v, r)\ + auto && <> = r;\ + if( !<> )\ + return <>.error();\ + v = std::forward>)>(<>).value() +``` + +`BOOST_LEAF_ASSIGN` is useful when calling a function that returns `result` (other than `result`), if the desired behavior is to forward any errors to the caller verbatim. + +In case of success, the result `value()` of type `T` is assigned to the specified variable `v`, which must have been declared prior to invoking `BOOST_LEAF_ASSIGN`. However, it is possible to use `BOOST_LEAF_ASSIGN` to declare a new variable, by passing in `v` its type together with its name, e.g. `BOOST_LEAF_ASSIGN(auto && x, f())` calls `f`, forwards errors to the caller, while capturing successful values in `x`. + + + +| | | +| --- | --- | +| | +See also [`AUTO`](#BOOST_LEAF_AUTO). + | + + +--- + +#### `AUTO` +#include + + +``` +#define BOOST\_LEAF\_AUTO(v, r)\ + BOOST\_LEAF\_ASSIGN(auto v, r) +``` + +[`ASSIGN`](#BOOST_LEAF_ASSIGN) + +`BOOST_LEAF_AUTO` is useful when calling a function that returns `result` (other than `result`), if the desired behavior is to forward any errors to the caller verbatim. + +Example: + + +``` +leaf::result compute\_value(); + +leaf::result add\_values() +{ + BOOST\_LEAF\_AUTO(v1, compute\_value()); **(1)** + BOOST\_LEAF\_AUTO(v2, compute\_value()); **(2)** + return v1 + v2; +} +``` + + + +| | | +| --- | --- | +| **1** | Call `compute_value`, bail out on failure, define a local variable `v1` on success. | +| **2** | Call `compute_value` again, bail out on failure, define a local variable `v2` on success. | + +Of course, we could write `add_value` without using `BOOST_LEAF_AUTO`. This is equivalent: + + + +``` +leaf::result add\_values() +{ + auto v1 = compute\_value(); + if( !v1 ) + return v1.error(); + + auto v2 = compute\_value(); + if( !v2 ) + return v2.error(); + + return v1.value() + v2.value(); +} +``` + + + +| | | +| --- | --- | +| | +See also [`ASSIGN`](#BOOST_LEAF_ASSIGN). + | + + +--- + +#### `CHECK` +#include + + +``` +#define BOOST\_LEAF\_CHECK(r)\ + auto && <> = r;\ + if( <> )\ + ;\ + else\ + return <>.error() +``` + +`BOOST_LEAF_CHECK` is useful when calling a function that returns `result`, if the desired behavior is to forward any errors to the caller verbatim. + +Example: + + +``` +leaf::result send\_message( char const \* msg ); + +leaf::result compute\_value(); + +leaf::result say\_hello\_and\_compute\_value() +{ + BOOST\_LEAF\_CHECK(send\_message("Hello!")); **(1)** + return compute\_value(); +} +``` + + + +| | | +| --- | --- | +| **1** | Try to send a message, then compute a value, report errors using BOOST\_LEAF\_CHECK. | + +Equivalent implementation without `BOOST_LEAF_CHECK`: + + + +``` +leaf::result add\_values() +{ + auto r = send\_message("Hello!"); + if( !r ) + return r.error(); + + return compute\_value(); +} +``` + + +--- + +#### `EXCEPTION` +#include + + +``` +#define BOOST\_LEAF\_EXCEPTION <> +``` + + +Effects: + +`BOOST_LEAF_EXCEPTION(e…​)` is equivalent to `leaf::[exception](#exception)(e…​)`, except the current source location is automatically passed, in a `[`e_source_location`](#e_source_location)` object (in addition to all `e…​` objects). + +--- + +#### `NEW_ERROR` +#include + + +``` +#define BOOST\_LEAF\_NEW\_ERROR <> +``` + + +Effects: + +`BOOST_LEAF_NEW_ERROR(e…​)` is equivalent to `leaf::[new\_error](#new_error)(e…​)`, except the current source location is automatically passed, in a `[`e_source_location`](#e_source_location)` object (in addition to all `e…​` objects). + +--- + +#### `THROW_EXCEPTION` +#include + + +``` +#define BOOST\_LEAF\_THROW\_EXCEPTION throw BOOST\_LEAF\_EXCEPTION +``` + + +Effects: + +Throws the exception object returned by [`EXCEPTION`](#BOOST_LEAF_EXCEPTION). + + + + +Design +------ + +### Rationale + +Definition: + +Objects that carry information about error conditions are called error objects. For example, objects of type `std::error_code` are error objects. + + +| | | +| --- | --- | +| | +The following reasoning is independent of the mechanism used to transport error objects, whether it is exception handling or anything else. + | + + +Definition: + +Depending on their interaction with error objects, functions can be classified as follows: +* **Error-initiating**: functions that initiate error conditions by creating new error objects. +* **Error-neutral**: functions that forward to the caller error objects communicated by lower-level functions they call. +* **Error-handling**: functions that dispose of error objects they have received, recovering normal program operation. + +A crucial observation is that *error-initiating* functions are typically low-level functions that lack any context and can not determine, much less dictate, the correct program behavior in response to the errors they may initiate. Error conditions which (correctly) lead to termination in some programs may (correctly) be ignored in others; yet other programs may recover from them and resume normal operation. + +The same reasoning applies to *error-neutral* functions, but in this case there is the additional issue that the errors they need to communicate, in general, are initiated by functions multiple levels removed from them in the call chain, functions which usually are — and should be treated as — implementation details. An *error-neutral* function should not be coupled with error object types communicated by *error-initiating* functions, for the same reason it should not be coupled with any other aspect of their interface. + +Finally, *error-handling* functions, by definition, have the full context they need to deal with at least some, if not all, failures. In their scope it is an absolute necessity that the author knows exactly what information must be communicated by lower level functions in order to recover from each error condition. Specifically, none of this necessary information can be treated as implementation details; in this case, the coupling which is to be avoided in *error-neutral* functions is in fact desirable. + +We’re now ready to define our + + +Design goals: + + +* **Error-initiating** functions should be able to communicate all information available to them that is relevant to the failure being reported. +* **Error-neutral** functions should not be coupled with error types communicated by lower-level *error-initiating* functions. They should be able to augment any failure with additional relevant information available to them. +* **Error-handling** functions should be able to access all the information communicated by *error-initiating* or *error-neutral* functions that is needed in order to deal with failures. + +The design goal that *error-neutral* functions are not coupled with the static type of error objects that pass through them seems to require dynamic polymorphism and therefore dynamic memory allocations (the Boost Exception library meets this design goal at the cost of dynamic memory allocation). + +As it turns out, dynamic memory allocation is not necessary due to the following + + +Fact: + + +* **Error-handling** functions "know" which of the information *error-initiating* and *error-neutral* functions are able to communicate is actually needed in order to deal with failures in a particular program. Ideally, no resources should be used wasted storing or communicating information which is not currently needed to handle errors, even if it is relevant to the failure. + +For example, if a library function is able to communicate an error code but the program does not need to know the exact error code, then that information may be ignored at the time the library function attempts to communicate it. On the other hand, if an *error-handling* function needs that information, the memory needed to store it can be reserved statically in its scope. + +The LEAF functions [`try_handle_some`](#try_handle_some), [`try_handle_all`](#try_handle_all) and [`try_catch`](#try_catch) implement this idea. Users provide error-handling lambda functions, each taking arguments of the types it needs in order to recover from a particular error condition. LEAF simply provides the space needed to store these types (in the form of a `std::tuple`, using automatic storage duration) until they are passed to a suitable handler. + +At the time this space is reserved in the scope of an error-handling function, `thread_local` pointers of the required error types are set to point to the corresponding objects within it. Later on, *error-initiating* or *error-neutral* functions wanting to communicate an error object of a given type `E` use the corresponding `thread_local` pointer to detect if there is currently storage available for this type: + +* If the pointer is not null, storage is available and the object is moved into the pointed storage, exactly once — regardless of how many levels of function calls must unwind before an *error-handling* function is reached. +* If the pointer is null, storage is not available and the error object is discarded, since no error-handling function makes any use of it in this program — saving resources. + +This almost works, except we need to make sure that *error-handling* functions are protected from accessing stale error objects stored in response to previous failures, which would be a serious logic error. To this end, each occurrence of an error is assigned a unique [`error_id`](#error_id). Each of the `E…​` objects stored in error-handling scopes is assigned an `error_id` as well, permanently associating it with a particular failure. + +Thus, to handle a failure we simply match the available error objects (associated with its unique `error_id`) with the argument types required by each user-provided error-handling function. In terms of C++ exception handling, it is as if we could write something like: + + + +``` +try +{ + auto r = process\_file(); + + //Success, use r: + .... +} + +catch(file\_read\_error &, e\_file\_name const & fn, e\_errno const & err) +{ + std::cerr << + "Could not read " << fn << ", errno=" << err << std::endl; +} + +catch(file\_read\_error &, e\_errno const & err) +{ + std::cerr << + "File read error, errno=" << err << std::endl; +} + +catch(file\_read\_error &) +{ + std::cerr << "File read error!" << std::endl; +} +``` + +Of course this syntax is not valid, so LEAF uses lambda functions to express the same idea: + + + +``` +leaf::try\_catch( + + [] + { + auto r = process\_file(); //Throws in case of failure, error objects stored inside the try\_catch scope + + //Success, use r: + .... + } + + [](file\_read\_error &, e\_file\_name const & fn, e\_errno const & err) + { + std::cerr << + "Could not read " << fn << ", errno=" << err << std::endl; + }, + + [](file\_read\_error &, e\_errno const & err) + { + std::cerr << + "File read error, errno=" << err << std::endl; + }, + + [](file\_read\_error &) + { + std::cerr << "File read error!" << std::endl; + } ); +``` + +[`try_catch`](#try_catch) | [`e_file_name`](#e_file_name) | [`e_errno`](#e_errno) + +Similar syntax works without exception handling as well. Below is the same snippet, written using `[result](#result)`: + + + +``` +return leaf::try\_handle\_some( + + []() -> leaf::result + { + BOOST\_LEAF\_AUTO(r, process\_file()); //In case of errors, error objects are stored inside the try\_handle\_some scope + + //Success, use r: + .... + + return { }; + } + + [](leaf::match, e\_file\_name const & fn, e\_errno const & err) + { + std::cerr << + "Could not read " << fn << ", errno=" << err << std::endl; + }, + + [](leaf::match, e\_errno const & err) + { + std::cerr << + "File read error, errno=" << err << std::endl; + }, + + [](leaf::match) + { + std::cerr << "File read error!" << std::endl; + } ); +``` + +[`result`](#result) | [`try_handle_some`](#try_handle_some) | [`match`](#match) | [`e_file_name`](#e_file_name) | [`e_errno`](#e_errno) + + + +| | | +| --- | --- | +| | +Please post questions and feedback on the Boost Developers Mailing List. + | + + +--- + +### Critique 1: Error Types Do Not Participate in Function Signatures +A knee-jerk critique of the LEAF design is that it does not statically enforce that each possible error condition is recognized and handled by the program. One idea I’ve heard from multiple sources is to add `E…​` parameter pack to `result`, essentially turning it into `expected`, so we could write something along these lines: + + + +``` +expected f() noexcept; **(1)** + +expected g() noexcept **(2)** +{ + if( expected r = f() ) + { + return r; //Success, return the T + } + else + { + return r.handle\_error( [] ( .... ) **(3)** + { + .... + } ); + } +} +``` + + + +| | | +| --- | --- | +| **1** | `f` may only return error objects of type `E1`, `E2`, `E3`. | +| **2** | `g` narrows that to only `E1` and `E3`. | +| **3** | Because `g` may only return error objects of type `E1` and `E3`, it uses `handle_error` to deal with `E2`. In case `r` contains `E1` or `E3`, `handle_error` simply returns `r`, narrowing the error type parameter pack from `E1, E2, E3` down to `E1, E3`. If `r` contains an `E2`, `handle_error` calls the supplied lambda, which is required to return one of `E1`, `E3` (or a valid `T`). | + +The motivation here is to help avoid bugs in functions that handle errors that pop out of `g`: as long as the programmer deals with `E1` and `E3`, he can rest assured that no error is left unhandled. + +Congratulations, we’ve just discovered exception specifications. The difference is that exception specifications, before being removed from C++, were enforced dynamically, while this idea is equivalent to statically-enforced exception specifications, like they are in Java. + +Why not use the equivalent of exception specifications, even if they are enforced statically? + + +> +> The short answer is that nobody knows how to fix exception specifications in any language, because the dynamic enforcement C++ chose has only different (not greater or fewer) problems than the static enforcement Java chose. …​ When you go down the Java path, people love exception specifications until they find themselves all too often encouraged, or even forced, to add `throws Exception`, which immediately renders the exception specification entirely meaningless. (Example: Imagine writing a Java generic that manipulates an arbitrary type `T`).[[1](#_footnotedef_1 "View footnote.")] +> +— Herb Sutter +Consider again the example above: assuming we don’t want important error-related information to be lost, values of type `E1` and/or `E3` must be able to encode any `E2` value dynamically. But like Sutter points out, in generic contexts we don’t know what errors may result in calling a user-supplied function. The only way around that is to specify a single type (e.g. `std::error_code`) that can communicate any and all errors, which ultimately defeats the idea of using static type checking to enforce correct error handling. + +That said, in every program there are certain *error-handling* functions (e.g. `main`) which are required to handle any error, and it is highly desirable to be able to enforce this requirement at compile-time. In LEAF, the `try_handle_all` function implements this idea: if the user fails to supply at least one handler that will match any error, the result is a compile error. This guarantees that the scope invoking `try_handle_all` is prepared to recover from any failure. + + +--- + +### Critique 2: LEAF Does Not Facilitate Mapping Between Different Error Types +Most C++ programs use multiple C and C++ libraries, and each library may provide its own system of error codes. But because it is difficult to define static interfaces that can communicate arbitrary error code types, a popular idea is to map each library-specific error code to a common program-wide enum. + +For example, if we have —  + + + +``` +namespace lib\_a +{ + enum error + { + ok, + ec1, + ec2, + .... + }; +} +``` + + + +``` +namespace lib\_b +{ + enum error + { + ok, + ec1, + ec2, + .... + }; +} +``` + + — we could define: + + + +``` +namespace program +{ + enum error + { + ok, + lib\_a\_ec1, + lib\_a\_ec2, + .... + lib\_b\_ec1, + lib\_b\_ec2, + .... + }; +} +``` + +An error-handling library could provide conversion API that uses the C++ static type system to automate the mapping between the different error enums. For example, it may define a class template `result` with value-or-error variant semantics, so that: + +* `lib_a` errors are transported in `result`, +* `lib_b` errors are transported in `result`, +* then both are automatically mapped to `result` once control reaches the appropriate scope. + +There are several problems with this idea: + +* It is prone to errors, both during the initial implementation as well as under maintenance. +* It does not compose well. For example, if both of `lib_a` and `lib_b` use `lib_c`, errors that originate in `lib_c` would be obfuscated by the different APIs exposed by each of `lib_a` and `lib_b`. +* It presumes that all errors in the program can be specified by exactly one error code, which is false. + +To elaborate on the last point, consider a program that attempts to read a configuration file from three different locations: in case all of the attempts fail, it should communicate each of the failures. In theory `result` handles this case well: + + + +``` +struct attempted\_location +{ + std::string path; + error ec; +}; + +struct config\_error +{ + attempted\_location current\_dir, user\_dir, app\_dir; +}; + +result read\_config(); +``` + +This looks nice, until we realize what the `config_error` type means for the automatic mapping API we wanted to define: an `enum` can not represent a `struct`. It is a fact that we can not assume that all error conditions can be fully specified by an `enum`; an error handling library must be able to transport arbitrary static types efficiently. + + +### Critique 3: LEAF Does Not Treat Low Level Error Types as Implementation Details +This critique is a combination of [Critique 1](#exception_specifications) and [Critique 2](#translation), but it deserves special attention. Let’s consider this example using LEAF: + + + +``` +leaf::result read\_line( reader & r ); + +leaf::result parse\_line( std::string const & line ); + +leaf::result read\_and\_parse\_line( reader & r ) +{ + BOOST\_LEAF\_AUTO(line, read\_line(r)); **(1)** + BOOST\_LEAF\_AUTO(parsed, parse\_line(line)); **(2)** + return parsed; +} +``` + +[`result`](#result) | [`AUTO`](#BOOST_LEAF_AUTO) + + + +| | | +| --- | --- | +| **1** | Read a line, forward errors to the caller. | +| **2** | Parse the line, forward errors to the caller. | + +The objection is that LEAF will forward verbatim the errors that are detected in `read_line` or `parse_line` to the caller of `read_and_parse_line`. The premise of this objection is that such low-level errors are implementation details and should be treated as such. Under this premise, `read_and_parse_line` should act as a translator of sorts, in both directions: + +* When called, it should translate its own arguments to call `read_line` and `parse_line`; +* If an error is detected, it should translate the errors from the error types returned by `read_line` and `parse_line` to a higher-level type. + +The motivation is to isolate the caller of `read_and_parse_line` from its implementation details `read_line` and `parse_line`. + +There are two possible ways to implement this translation: + +**1)** `read_and_parse_line` understands the semantics of **all possible failures** that may be reported by both `read_line` and `parse_line`, implementing a non-trivial mapping which both *erases* information that is considered not relevant to its caller, as well as encodes *different* semantics in the error it reports. In this case `read_and_parse_line` assumes full responsibility for describing precisely what went wrong, using its own type specifically designed for the job. + +**2)** `read_and_parse_line` returns an error object that essentially indicates which of the two inner functions failed, and also transports the original error object without understanding its semantics and without any loss of information, wrapping it in a new error type. + +The problem with **1)** is that typically the caller of `read_and_parse_line` is not going to handle the error, but it does need to forward it to its caller. In our attempt to protect the **one** error-handling function from "implementation details", we’ve coupled the interface of **all** intermediate error-neutral functions with the static types of errors they do not understand and do not handle. + +Consider the case where `read_line` communicates `errno` in its errors. What is `read_and_parse_line` supposed to do with e.g. `EACCESS`? Turn it into `READ_AND_PARSE_LINE_EACCESS`? To what end, other than to obfuscate the original (already complex and platform-specific) semantics of `errno`? + +And what if the call to `read` is polymorphic, which is also typical? What if it involves a user-supplied function object? What kinds of errors does it return and why should `read_and_parse_line` care? + +Therefore, we’re left with **2)**. There’s almost nothing wrong with this option, since it passes any and all error-related information from lower level functions without any loss. However, using a wrapper type to grant (presumably dynamic) access to any lower-level error type it may be transporting is cumbersome and (like Niall Douglas [explains](#interoperability)) in general probably requires dynamic allocations. It is better to use independent error types that communicate the additional information not available in the original error object, while error handlers rely on LEAF to provide efficient access to any and all low-level error types, as needed. + +Alternatives to LEAF +-------------------- + +* [Boost Exception](https://www.boost.org/doc/libs/release/libs/exception/doc/boost-exception.html) +* [Boost Outcome](https://ned14.github.io/outcome) +* [`tl::expected`](https://github.com/TartanLlama/expected) + +Below we offer a comparison of Boost LEAF to Boost Exception and to Boost Outcome. + +### Comparison to Boost Exception +While LEAF can be used without exception handling, in the use case when errors are communicated by throwing exceptions, it can be viewed as a better, more efficient alternative to Boost Exception. LEAF has the following advantages over Boost Exception: + +* LEAF does not allocate memory dynamically; +* LEAF does not waste system resources communicating error objects not used by specific error handling functions; +* LEAF does not store the error objects in the exception object, and therefore it is able to augment exceptions thrown by external libraries (Boost Exception can only augment exceptions of types that derive from `boost::exception`). + +The following tables outline the differences between the two libraries which should be considered when code that uses Boost Exception is refactored to use LEAF instead. + + + +| | | +| --- | --- | +| | +It is possible to access Boost Exception error information using the LEAF error handling interface. See [Boost Exception Integration](#tutorial-boost_exception_integration). + | + + +Table 1. Defining a custom type for transporting values of type T +| Boost Exception | LEAF | +| --- | --- | +| + + +``` +typedef error\_info my\_info; +``` + +[`boost::error_info`](https://www.boost.org/doc/libs/release/libs/exception/doc/error_info.html) + | + + +``` +struct my\_info { T value; }; +``` + + + | + +Table 2. Passing arbitrary info at the point of the throw +| Boost Exception | LEAF | +| --- | --- | +| + + +``` +throw my\_exception() << + my\_info(x) << + my\_info(y); +``` + +[`operator<<`](https://www.boost.org/doc/libs/release/libs/exception/doc/exception_operator_shl.html) + | + + +``` +throw leaf::exception( my\_exception(), + my\_info{x}, + my\_info{y} ); +``` + +[`exception`](#exception) + | + +Table 3. Augmenting exceptions in error-neutral contexts +| Boost Exception | LEAF | +| --- | --- | +| + + +``` +try +{ + f(); +} +catch( boost::exception & e ) +{ + e << my\_info(x); + throw; +} +``` + +[`boost::exception`](https://www.boost.org/doc/libs/release/libs/exception/doc/exception.html) | [`operator<<`](https://www.boost.org/doc/libs/release/libs/exception/doc/exception_operator_shl.html) + | + + +``` +auto load = leaf::on\_error( my\_info{x} ); + +f(); +``` + +[`on_error`](#on_error) + | + +Table 4. Obtaining arbitrary info at the point of the catch +| Boost Exception | LEAF | +| --- | --- | +| + + +``` +try +{ + f(); +} +catch( my\_exception & e ) +{ + if( T \* v = get\_error\_info(e) ) + { + //my\_info is available in e. + } +} +``` + +[`boost::get_error_info`](https://www.boost.org/doc/libs/release/libs/exception/doc/get_error_info.html) + | + + +``` +leaf::try\_catch( + [] + { + f(); // throws + } + [](my\_exception &, my\_info const & x) + { + //my\_info is available with + //the caught exception. + } ); +``` + +[`try_catch`](#try_catch) + | + +Table 5. Transporting of error objects +| Boost Exception | LEAF | +| --- | --- | +| +All supplied [`boost::error_info`](https://www.boost.org/doc/libs/release/libs/exception/doc/error_info.html) objects are allocated dynamically and stored in the [`boost::exception`](https://www.boost.org/doc/libs/release/libs/exception/doc/exception.html) subobject of exception objects. + | +User-defined error objects are stored statically in the scope of [`try_catch`](#try_catch), but only if their types are needed to handle errors; otherwise they are discarded. + | + +Table 6. Transporting of error objects across thread boundaries +| Boost Exception | LEAF | +| --- | --- | +| +[`boost::exception_ptr`](https://www.boost.org/doc/libs/release/libs/exception/doc/exception_ptr.html) automatically captures [`boost::error_info`](https://www.boost.org/doc/libs/release/libs/exception/doc/error_info.html) objects stored in a `boost::exception` and can transport them across thread boundaries. + | +Transporting error objects across thread boundaries requires the use of [`capture`](#capture). + | + +Table 7. Printing of error objects in automatically-generated diagnostic information messages +| Boost Exception | LEAF | +| --- | --- | +| +`boost::error_info` types may define conversion to `std::string` by providing `to_string` overloads **or** by overloading `operator<<` for `std::ostream`. + | +LEAF does not use `to_string`. Error types may define `operator<<` overloads for `std::ostream`. + | + + +| | | +| --- | --- | +| | +The fact that Boost Exception stores all supplied `boost::error_info` objects — while LEAF discards them if they aren’t needed — affects the completeness of the message we get when we print `leaf::[diagnostic\_info](#diagnostic_info)` objects, compared to the string returned by [`boost::diagnostic_information`](https://www.boost.org/doc/libs/release/libs/exception/doc/diagnostic_information.html). + + +If the user requires a complete diagnostic message, the solution is to use `leaf::[verbose\_diagnostic\_info](#verbose_diagnostic_info)`. In this case, before unused error objects are discarded by LEAF, they are converted to string and printed. Note that this allocates memory dynamically. + | + + +--- + +### Comparison to Boost Outcome +#### Design Differences +Like LEAF, the [Boost Outcome](https://ned14.github.io/outcome) library is designed to work in low latency environments. It provides two class templates, `result<>` and `outcome<>`: + +* `result` can be used as the return type in `noexcept` functions which may fail, where `T` specifies the type of the return value in case of success, while `EC` is an "error code" type. Semantically, `result` is similar to `std::variant`. Naturally, `EC` defaults to `std::error_code`. +* `outcome` is similar to `result<>`, but in case of failure, in addition to the "error code" type `EC` it can hold a "pointer" object of type `EP`, which defaults to `std::exception_ptr`. + + + +| | | +| --- | --- | +| | `NVP` is a policy type used to customize the behavior of `.value()` when the `result<>` or the `outcome<>` object contains an error. + | + +The idea is to use `result<>` to communicate failures which can be fully specified by an "error code", and `outcome<>` to communicate failures that require additional information. + +Another way to describe this design is that `result<>` is used when it suffices to return an error object of some static type `EC`, while `outcome<>` can also transport a polymorphic error object, using the pointer type `EP`. + + + +| | | +| --- | --- | +| | +In the default configuration of `outcome` the additional information — or the additional polymorphic object — is an exception object held by `std::exception_ptr`. This targets the use case when an exception thrown by a lower-level library function needs to be transported through some intermediate contexts that are not exception-safe, to a higher-level context able to handle it. LEAF directly supports this use as well, see [`exception_to_result`](#exception_to_result). + | + +Similar reasoning drives the design of LEAF as well. The difference is that while both libraries recognize the need to transport "something else" in addition to an "error code", LEAF provides an efficient solution to this problem, while Outcome shifts this burden to the user. + +The `leaf::result<>` template deletes both `EC` and `EP`, which decouples it from the type of the error objects that are transported in case of a failure. This enables lower-level functions to freely communicate anything and everything they "know" about the failure: error code, even multiple error codes, file names, URLs, port numbers, etc. At the same time, the higher-level error-handling functions control which of this information is needed in a specific client program and which is not. This is ideal, because: + +* Authors of lower-level library functions lack context to determine which of the information that is both relevant to the error *and* naturally available to them needs to be communicated in order for a particular client program to recover from that error; +* Authors of higher-level error-handling functions can easily and confidently make this determination, which they communicate naturally to LEAF, by simply writing the different error handlers. LEAF will transport the needed error objects while discarding the ones handlers don’t care to use, saving resources. + + + +| | | +| --- | --- | +| | +The LEAF examples include an adaptation of the program from the [Boost Outcome `result<>` tutorial](https://ned14.github.io/outcome/tutorial/essential/result/). You can [view it on GitHub](https://github.com/boostorg/leaf/blob/master/example/print_half.cpp?ts=4). + | + + + +| | | +| --- | --- | +| | +Programs using LEAF for error-handling are not required to use `leaf::result`; for example, it is possible to use `outcome::result` with LEAF. + | + + +#### The Interoperability Problem +The Boost Outcome documentation discusses the important problem of bringing together multiple libraries — each using its own error reporting mechanism — and incorporating them in a robust error handling infrastructure in a client program. + +Users are advised that whenever possible they should use a common error handling system throughout their entire codebase, but because this is not practical, both the `result<>` and the `outcome<>` templates can carry user-defined "payloads". + +The following analysis is from the Boost Outcome documentation: + + + +If library A uses `result`, and library B uses `result` and so on, there becomes a problem for the application writer who is bringing in these third party dependencies and tying them together into an application. As a general rule, each third party library author will not have built in explicit interoperation support for unknown other third party libraries. The problem therefore lands with the application writer. + +The application writer has one of three choices: + +1. In the application, the form of result used is `result>` where `E1, E2 …` are the failure types for every third party library in use in the application. This has the advantage of preserving the original information exactly, but comes with a certain amount of use inconvenience and maybe excessive coupling between high level layers and implementation detail. +2. One can translate/map the third party’s failure type into the application’s failure type at the point of the failure exiting the third party library and entering the application. One might do this, say, with a C preprocessor macro wrapping every invocation of the third party API from the application. This approach may lose the original failure detail, or mis-map under certain circumstances if the mapping between the two systems is not one-one. +3. One can type erase the third party’s failure type into some application failure type, which can later be reconstituted if necessary. **This is the cleanest solution with the least coupling issues and no problems with mis-mapping**, but it almost certainly requires the use of `malloc` which the previous two did not. + + + +The analysis above (emphasis added) is clear and precise, but LEAF and Boost Outcome tackle the interoperability problem differently: + +* The Boost Outcome design asserts that the "cleanest" solution based on type-erasure is suboptimal ("almost certainly requires the use of `malloc`"), and instead provides a system for injecting custom converters into the `outcome::convert` namespace, used to translate between library-specific and program-wide error types, even though this approach "may lose the original failure detail". +* The LEAF design asserts that coupling the signatures of [error-neutral](#rationale) functions with the static types of the error objects they need to forward to the caller [does not scale](#translation), and instead transports error objects directly to error-handling scopes where they are stored statically, effectively implementing the third choice outlined above (without the use of `malloc`). + +Further, consider that Outcome aims to hopefully become *the* one error-handling API all libraries would use, and in theory everyone would benefit from uniformity and standardization. But the reality is that this is wishful thinking. In fact, that reality is reflected in the design of `outcome::result<>`, in its lack of commitment to using `std::error_code` for its intended purpose: to be *the* standard type for transporting error codes. The fact is that `std::error_code` became *yet another* error code type programmers need to understand and support. + +In contrast, the design of LEAF acknowledges that C++ programmers don’t even agree on what a string is. If your project uses 10 different libraries, this probably means 15 different ways to report errors, sometimes across uncooperative interfaces (e.g. C APIs). LEAF helps you get the job done. + + +Benchmark +--------- + +[This benchmark](https://github.com/boostorg/leaf/blob/master/benchmark/benchmark.md) compares the performance of LEAF, Boost Outcome and `tl::expected`. + + + +Running the Unit Tests +---------------------- + +The unit tests can be run with [Meson Build](https://mesonbuild.com) or with Boost Build. To run the unit tests: + +### Meson Build +Clone LEAF into any local directory and execute: + + + +``` +cd leaf +meson bld/debug +cd bld/debug +meson test +``` + +See `meson_options.txt` found in the root directory for available build options. + + +### Boost Build +Assuming the current working directory is `/libs/leaf`: + + + +``` +../../b2 test +``` + +Configuration Macros +-------------------- + +The following configuration macros are recognized: + +* `BOOST_LEAF_DIAGNOSTICS`: Defining this macro to `0` stubs out both [`diagnostic_info`](#diagnostic_info) and [`verbose_diagnostic_info`](#verbose_diagnostic_info), which could improve the performance of the error path in some programs (if the macro is left undefined, LEAF defines it as `1`). +* `BOOST_LEAF_NO_EXCEPTIONS`: Disables all exception handling support. If left undefined, LEAF defines it based on the compiler configuration (e.g. `-fno-exceptions`). +* `BOOST_LEAF_NO_THREADS`: Disable all multi-thread support. + + + +Limitations +----------- + +LEAF requires C++11, including `thread_local` support, except when compiled with `BOOST_LEAF_NO_THREADS` (which can be useful on some embedded platforms). + +When using dynamic linking, it is required that error types are declared with `default` visibility, e.g.: + + + +``` +struct \_\_attribute\_\_ ((visibility ("default"))) my\_error\_info +{ + int value; +}; +``` + +This works as expected except on Windows, where thread-local storage is not shared between the individual binary modules. For this reason, to transport error objects across DLL boundaries, it is required that they’re captured in a [`polymorphic_context`](#polymorphic_context), just like when [Transporting Error Objects Between Threads](#tutorial-async). + + + +| | | +| --- | --- | +| | +When using dynamic linking, it is always best to define module interfaces in terms of C (and implement them in C++ if appropriate). + | + + + +Acknowledgements +---------------- + +Special thanks to Peter Dimov and Sorin Fetche. + +Ivo Belchev, Sean Palmer, Jason King, Vinnie Falco, Glen Fernandes, Augustín Bergé — thanks for the valuable feedback. + +Documentation rendered by [Asciidoctor](https://asciidoctor.org/) with [these customizations](https://github.com/zajo/asciidoctor_skin). + + + +--- +[1](#_footnoteref_1). + diff --git a/doc/libs/1_77_0/libs/qvm/doc/html/index.html b/doc/libs/1_77_0/libs/qvm/doc/html/index.html new file mode 100644 index 0000000..46839ec --- /dev/null +++ b/doc/libs/1_77_0/libs/qvm/doc/html/index.html @@ -0,0 +1,6070 @@ +--- +title: QVM +copyright: © 2008-2021 Emil Dotchevski. Distributed under the Boost Software License, Version 1.0. +revised: +--- + +QVM + +function switch\_style() +{ + var i, tag; + for( i=0, tag=document.getElementsByTagName("link"); i rx = rotx\_quat(3.14159f); +``` + +Similarly, a matrix that translates by a given vector can be created as follows: + + + +``` +vec v = {0,0,7}; +mat tr = translation\_mat(v); +``` + +The usual quaternion, vector and matrix operations work on these QVM types, however the operations are decoupled from any specific type: they work on any suitable type that has been registered by specializing the [`quat_traits`](#quat_traits), [`vec_traits`](#vec_traits) and [`mat_traits`](#mat_traits) templates. + +For example, a user-defined 3D vector type `float3` can be introduced to QVM as follows: + + + +``` +struct float3 { float a[3]; }; + +namespace boost { namespace qvm { + + template <> + struct vec\_traits { + + static int const dim=3; + typedef float scalar\_type; + + template + static inline scalar\_type & write\_element( float3 & v ) { + return v.a[I]; + } + + template + static inline scalar\_type read\_element( float3 const & v ) { + return v.a[I]; + } + + static inline scalar\_type & write\_element\_idx( int i, float3 & v ) { + return v.a[i]; + } //optional + + static inline scalar\_type read\_element\_idx( int i, float3 const & v ) { + return v.a[i]; + } //optional + + }; + +} } +``` + +Equivalently, using the [`vec_traits_defaults`](#vec_traits_defaults) template the above can be shortened to: + + + +``` +namespace boost { namespace qvm { + + template <> + struct vec\_traits: vec\_traits\_defaults { + + template + static inline scalar\_type & write\_element( float3 & v ) { + return v.a[I]; + } + + static inline scalar\_type & write\_element\_idx( int i, float3 & v ) { + return v.a[i]; + } //optional + + }; + +} } +``` + +After a similar specialization of the [`mat_traits`](#mat_traits) template for a user-defined 3x3 matrix type `float33`, the full range of vector and matrix operations defined by QVM headers becomes available automatically: + + + +``` +float3 v; +X(v) = 0; +Y(v) = 0; +Z(v) = 7; +float vmag = mag(v); +float33 m = rotx\_mat<3>(3.14159f); +float3 vrot = m \* v; +``` + +User-defined quaternion types are similarly introduced to QVM by specializing the [`quat_traits`](#quat_traits) template. + + +--- + +### C Arrays +In `boost/qvm/quat_traits_array.hpp`, `vec_traits_array.hpp` and `mat_traits_array.hpp`, QVM defines appropriate [`quat_traits`](#quat_traits), [`vec_traits`](#vec_traits) and [`mat_traits`](#mat_traits) specializations that allow QVM functions to operate directly on plain old C arrays: + + + +``` +float v[3] = {0,0,7}; +float3 vrot = rotx\_mat<3>(3.14159f) \* v; +``` + +Naturally, operator overloads cannot kick in if all elements of an expression are of built-in types. The following is still illegal: + + + +``` +float v[3] = {0,0,7}; +v \*= 42; +``` + +The [`vref`](#vref) and [`mref`](#mref) function templates can be used to work around this issue: + + + +``` +float v[3] = {0,0,7}; +vref(v) \*= 42; +``` + + +--- + +### View proxies +QVM defines various function templates that provide static mapping between (possibly user-defined) quaternion, vector and matrix types. The example below multiplies column 1 (QVM indexes are always zero-based) of the matrix `m` by a scalar: + + + +``` +void multiply\_column1( float33 & m, float scalar ) { + col<1>(m) \*= scalar; +} +``` + +The expression [`col<1>(m)`](#col) is an lvalue of an unspecified 3D vector type that refers to column 1 of `m`. Note however that this does not create any temporary objects; instead `operator*=` above works directly with a reference to `m`. + +Here is another example, multiplying a transposed view of a matrix by a vector of some user-defined type `float3`: + + + +``` +float3 v = {0,0,7}; +float3 vrot = transposed(rotx\_mat<3>(3.14159f)) \* v; +``` + +In general, the various view proxy functions return references of unspecified, non-copyable types that refer to the original object. They can be assigned from or converted to any compatible vector or matrix type. + + +--- + +### Swizzling +QVM allows accessing vector elements by swizzling, exposing vector views of different dimensions, and/or views with reordered elements. The example below rotates `v` around the X axis, and stores the resulting vector back in `v` but with the X and Y elements swapped: + + + +``` +float3 v = {0,0,7}; +YXZ(v) = rotx\_mat<3>(3.14159f) \* v; +``` + +A special case of swizzling provides next-dimension-view of a vector object, adding either 0 or 1 as its last component. Assuming `float3` is a 3D vector type, and `float4` is a 4D vector type, the following statements are valid: + + + +``` +float3 v = {0,0,7}; +float4 point = XYZ1(v); //{0,0,7,1} +float4 vector = XYZ0(v); //{0,0,7,0} +``` + +It is also valid for swizzling to address vector elements more than once: + + + +``` +float3 v = {0,0,7}; +float4 v1 = ZZZZ(v); //{7,7,7,7} +``` + +QVM defines all permutations of `X`, `Y`, `Z`, `W` for 1D, 2D, 3D and 4D swizzling, plus each dimension defines variants with 0 or 1 used at any position (if 0 or 1 appear at the first position, the swizzling function name begins with underscore, e.g. `_1XY`). + +The swizzling syntax can also be used to bind scalars as vectors. For example: + + + +``` +float3 v = \_00X(42.0f); //{0,0,42} +``` + + +--- + +### SFINAE/enable\_if +SFINAE stands for Substitution Failure Is Not An Error. This refers to a situation in C++ where an invalid substitution of template parameters (including when those parameters are deduced implicitly as a result of an unqualified call) is not in itself an error. + +In absence of concepts support, SFINAE can be used to disable function template overloads that would otherwise present a signature that is too generic. More formally, this is supported by the Boost `enable_if` library. + +For example, QVM defines `operator*` overload which works with any user-defined matrix and vector types. The naive approach would be to declare this overload as follows: + + + +``` +template +Vector operator\*( Matrix const & m, Vector const & v ); +``` + +Even if the function definition might contain code that would compile only for `Matrix` and `Vector` types, because the function declaration itself is valid, it will participate in overload rezolutions when multiplying objects of any two types whatsoever. This typically renders overload resolutions ambiguous and the compiler (correctly) issues an error. + +Using `enable_if`, QVM declares such overloads in a way that preserves their generic signature but only participate in overload resolutions if the passed parameters make sense depending on the semantics of the operation being defined: + + + +``` +template +typename enable\_if\_c< + is\_mat::value && is\_vec::value && mat\_traits::cols==vec\_traits::dim, //Condition + B>::type //Return type +operator\*( A const & a, B const & b ); +``` + +For brevity, function declarations throughout this documentation specify the condition which controls whether they are enabled or not without specifying exactly what `enable_if` construct is used to achieve this effect. + + +--- + +### Interoperability +An important design goal of QVM is that it works seamlessly with 3rd-party quaternion, vector and matrix types and libraries. Even when such libraries overload the same C++ operators as QVM, it is safe to bring the entire `boost::qvm` namespace in scope by specifying: + + + +``` +using namespace boost::qvm; +``` + +The above using directive does not introduce ambiguities with function and operator overloads defined by a 3rd-party library because: + +* Most `boost::qvm` function overloads and all operator overloads use SFINAE/`enable_if`, which makes them "disappear" unless an expression uses types that have the appropriate QVM-specific type traits defined; +* Whenever such overloads are compatible with a given expression, their signature is extremely generic, which means that any other (user-defined) compatible overload will be a better match in any overload resolution. + + + +| | | +| --- | --- | +| | +Bringing the entire boost::qvm namespace in scope may introduce ambiguities when accessing types (as opposed to functions) defined by 3rd-party libraries. In that case, you can safely bring namespace `boost::qvm::sfinae` in scope instead, which contains only function and operator overloads that use SFINAE/`enable_if`. + | + +#### Specifying return types for binary operations +Bringing the `boost::qvm` namespace in scope lets you mix vector and matrix types that come from different APIs into a common, type-safe framework. In this case however, it should be considered what types should be returned by binary operations that return an object by value. For example, if you multiply a 3x3 matrix `m1` of type `user_matrix1` by a 3x3 matrix `m2` of type `user_matrix2`, what type should that operation return? + +The answer is that by default, QVM returns some kind of compatible matrix type, so it is always safe to write: + + + +``` +auto & m = m1 \* m2; // auto requires C++11 +``` + +However, the type deduced by default converts implicitly to any compatible matrix type, so the following is also valid, at the cost of a temporary: + + + +``` +user\_matrix1 m = m1 \* m2; +``` + +While the temporary object can be optimized away by many compilers, it can be avoided altogether by specializing the [`deduce_mat2`](#deduce_mat2) template. For example, to specify that multiplying a `user_matrix1` by a `user_matrix2` should always produce a `user_matrix1` object, you could write: + + + +``` +namespace boost { namespace qvm { + + template <> + struct deduce\_mat2 { + typedef user\_matrix1 type; + }; + + template <> + struct deduce\_mat2 { + typedef user\_matrix1 type; + }; + +} } +``` + + + +| | | +| --- | --- | +| | +Be mindful of potential ODR violation when using [`deduce_quat2`](#deduce_quat2), [`deduce_vec2`](#deduce_vec2) and [`deduce_mat2`](#deduce_mat2) in independent libraries. For example, this could happen if `lib1` defines `deduce_vec2::type` as `lib1::vec` and in the same program `lib2` defines `deduce_vec2::type` as `lib2::vec`. + + +It is best to keep such specializations out of `lib1` and `lib2`. Of course, it is always safe for `lib1` and `lib2` to use [`convert_to`](#convert_to) to convert between the `lib1::vec` and `lib2::vec` types as needed. + | + + +#### Specifying return types for unary operations +Perhaps surprisingly, unary operations that return an object by value have a similar, though simpler issue. That’s because the argument they’re called with may not be copyable, as in: + + + +``` +float m[3][3]; +auto & inv = inverse(m); +``` + +Above, the object returned by [`inverse`](#mat_inverse) and captured by `inv` can not be of type `float[3][3]`, because that type isn’t copyable. By default, QVM "just works", returning an object of suitable matrix type that is copyable. This deduction process can be controlled, by specializing the [`deduce_mat`](#deduce_mat) template. + + +#### Converting between different quaternion, vector and matrix types +Any time you need to create a matrix of a particular C++ type from any other compatible matrix type, you can use the [`convert_to`](#convert_to) function: + + + +``` +user\_matrix2 m=convert\_to(m1 \* m2); +``` + + +Reference +--------- + +### Header Files +QVM is split into multiple headers to allow different compilation units to `#include` only the components they need. Each function in this document specifies the exact header that must be `#included` in order to use it. + +The tables below list commonly used components and the headers they’re found in. Header names containing a number define functions that only work with objects of that dimension; e.g. `vec_operations2.hpp` contains only functions for working with 2D vectors. + +The header `boost/qvm/all.hpp` is provided for convenience. It includes all other QVM headers. + +In addition, Boost QVM is available in single-header format for maximum portability. See [Distribution](#_distribution). + + +Table 1. Quaternion header files +| Quaternion traits | +``` +#include +#include +#include +``` + | +| Quaternion element access | +``` +#include +``` + | +| Quaternion operations | +``` +#include +``` + | +| [`quat`](#quat) class template | +``` +#include +``` + | + +Table 2. Vector header files +| Vector traits | +``` +#include +#include +#include +``` + | +| Vector element access | +``` +#include +``` + | +| Vector [swizzling](#swizzling) | +``` +#include +#include +#include +#include +``` + | +| Vector operations | +``` +#include +#include +#include +#include +``` + | +| Quaternion-vector operations | +``` +#include +``` + | +| Vector-matrix operations | +``` +#include +``` + | +| Vector-matrix [view proxies](#view_proxy) | +``` +#include +``` + | +| [`vec`](#vec) class template | +``` +#include +``` + | + +Table 3. Matrix header files +| Matrix traits | +``` +#include +#include +#include +``` + | +| Matrix element access | +``` +#include +``` + | +| Matrix operations | +``` +#include +#include +#include +#include +``` + | +| Matrix-matrix [view proxies](#view_proxy) | +``` +#include +``` + | +| Matrix-vector [view proxies](#view_proxy) | +``` +#include +``` + | +| [`mat`](#mat) class template | +``` +#include +``` + | + +### Type Traits System +QVM is designed to work with user-defined quaternion, vector and matrix types, as well as user-defined scalar types. This section formally defines the way such types can be integrated. + + +--- +#### Scalar Requirements +A valid scalar type `S` must have accessible destructor, default constructor, copy constructor and assignment operator, and must support the following operations: + + + +``` +S operator\*( S, S ); +S operator/( S, S ); +S operator+( S, S ); +S operator-( S, S ); + +S & operator\*=( S &, S ); +S & operator/=( S &, S ); +S & operator+=( S &, S ); +S & operator-=( S &, S ); + +bool operator==( S, S ); +bool operator!=( S, S ); +``` + +In addition, the expression `S(0)` should construct a scalar of value zero, and `S(1)` should construct a scalar of value one, or else the [`scalar_traits`](#scalar_traits) template must be specialized appropriately. + + +--- + +#### `is_scalar` +#include + + +``` +namespace boost { namespace qvm { + + template + struct is\_scalar { + static bool const value=false; + }; + + template <> struct is\_scalar { static bool const value=true; }; + template <> struct is\_scalar { static bool const value=true; }; + template <> struct is\_scalar { static bool const value=true; }; + template <> struct is\_scalar { static bool const value=true; }; + template <> struct is\_scalar { static bool const value=true; }; + template <> struct is\_scalar { static bool const value=true; }; + template <> struct is\_scalar { static bool const value=true; }; + template <> struct is\_scalar { static bool const value=true; }; + template <> struct is\_scalar { static bool const value=true; }; + template <> struct is\_scalar { static bool const value=true; }; + template <> struct is\_scalar { static bool const value=true; }; + template <> struct is\_scalar { static bool const value=true; }; + +} } +``` + +This template defines a compile-time boolean constant value which can be used to determine whether a type `T` is a valid scalar type. It must be specialized together with the [`scalar_traits`](#scalar_traits) template in order to introduce a user-defined scalar type to QVM. Such types must satisfy the [scalar requirements](#scalar_requirements). + + +--- + +#### `scalar_traits` +#include + + +``` +namespace boost { namespace qvm { + + template + struct scalar\_traits { + + BOOST\_QVM\_INLINE\_CRITICAL + static Scalar value( int v ) { + return Scalar(v); + } + + }; + +} } +``` + +This template may be specialized for user-defined scalar types to define the appropriate conversion from `int`; this is primarily used whenever QVM needs to deduce a zero or one value. + + +--- + +#### `deduce_scalar` +#include + + +``` +namespace boost { namespace qvm { + + template + struct deduce\_scalar + { + typedef typename /\*exact definition unspecified\*/ type; + }; + +} } +``` + + +Requires: + +`A` and `B` satisfy the [scalar requirements](#scalar_requirements). +Returns: + +If `A` and `B` are the same type, `scalar_traits::type` is defined as that type. Otherwise for the following types: +* `signed`/`unsigned char`, +* `signed`/`unsigned short`, +* `signed`/`unsigned int`, +* `signed`/`unsigned long`, +* `float`, +* `double`, + +the deduction logic is as follows: + +* if either of `A` and `B` is `double`, the result is `double`; +* else, if one of `A` or `B` is an integer type and the other is `float`, the result is `float`; +* else, if one of `A` or `B` is a signed integer and the other type is unsigned integer, the signed type is changed to unsigned, and then the lesser of the two integers is promoted to the other. + +For any other types `scalar_traits::type` is defined as `void`. It can be specialized for user-defined scalar types. + + + +| | | +| --- | --- | +| | +This template is used by generic binary operations that return a scalar, to deduce the return type based on the (possibly different) scalars of their arguments. + | + + +--- + +#### `scalar` +#include + + +``` +namespace boost { namespace qvm { + + template + struct scalar { + typedef /\*exact definition unspecified\*/ type; + }; + +} } +``` + +The expression [`quat_traits::scalar_type`](#quat_traits) evaluates to the scalar type of the quaternion type `T` (if [`is_quat::value`](#is_quat) is `true`). + +The expression [`vec_traits::scalar_type`](#vec_traits) evaluates to the scalar type of the vector type `T` (if [`is_vec::value`](#is_vec) is `true`). + +The expression [`mat_traits::scalar_type`](#mat_traits) evaluates to the scalar type of the matrix type `T` (if [`is_mat::value`](#is_mat) is `true`). + +The expression `scalar::type` is similar, except that it automatically detects whether `T` is a vector or a matrix or a quaternion type. + + +--- + +#### `is_quat` +#include + + +``` +namespace boost { namespace qvm { + + template + struct is\_quat { + + static bool const value = false; + + }; + +} } +``` + +This type template defines a compile-time boolean constant value which can be used to determine whether a type `T` is a quaternion type. For quaternion types, the [`quat_traits`](#quat_traits) template can be used to access their elements generically, or to obtain their `scalar type`. + + +--- + +#### `quat_traits` +#include + + +``` +namespace boost { namespace qvm { + + template + struct quat\_traits { + + /\*main template members unspecified\*/ + + }; + + /\* + User-defined (possibly partial) specializations: + + template <> + struct quat\_traits { + + typedef <> scalar\_type; + + template + static inline scalar\_type read\_element( Quaternion const & q ); + + template + static inline scalar\_type & write\_element( Quaternion & q ); + + }; + \*/ + +} } +``` + +The `quat_traits` template must be specialized for (user-defined) quaternion types in order to enable quaternion operations defined in QVM headers for objects of those types. + + + +| | | +| --- | --- | +| | +QVM quaternion operations do not require that quaternion types are copyable. + | + +The main `quat_traits` template members are not specified. Valid specializations are required to define the following members: + +* `scalar_type`: the expression `quat_traits::scalar_type` must be a value type which satisfies the [`scalar requirements`](#scalar_requirements). + +In addition, valid specializations of the `quat_traits` template must define at least one of the following access functions as static members, where `q` is an object of type `Quaternion`, and `I` is compile-time integer constant: + +* `read_element`: the expression `quat_traits::read_element(q)` returns either a copy of or a `const` reference to the `I`-th element of `q`. +* `write_element`: the expression `quat_traits::write_element(q)` returns mutable reference to the `I`-th element of `q`. + + + +| | | +| --- | --- | +| | +For the quaternion `a + bi + cj + dk`, the elements are assumed to be in the following order: `a`, `b`, `c`, `d`; that is, `I`=`0`/`1`/`2`/`3` would access `a`/`b`/`c`/`d`. + | + +It is illegal to call any of the above functions unless `is_quat::value` is true. Even then, quaternion types are allowed to define only a subset of the access functions. + +Below is an example of a user-defined quaternion type, and its corresponding specialization of the quat\_traits template: + + + +``` +#include + +struct fquat { float a[4]; }; + +namespace boost { namespace qvm { + + template <> + struct quat\_traits { + + typedef float scalar\_type; + + template + static inline scalar\_type & write\_element( fquat & q ) { + return q.a[I]; + } + + template + static inline scalar\_type read\_element( fquat const & q ) { + return q.a[I]; + } + + }; + +} } +``` + +Equivalently, using the [`quat_traits_defaults`](#quat_traits_defaults) template the above can be shortened to: + + + +``` +namespace boost { namespace qvm { + + template <> + struct quat\_traits: quat\_traits\_defaults { + + template + static inline scalar\_type & write\_element( fquat & q ) { + return q.a[I]; + } + + }; + +} } +``` + + +--- + +#### `quat_traits_defaults` +#include + + +``` +namespace boost { namespace qvm { + + template + struct quat\_traits\_defaults { + + typedef QuatType quat\_type; + + typedef ScalarType scalar\_type; + + template + static BOOST\_QVM\_INLINE\_CRITICAL + scalar\_type read\_element( quat\_type const & x ) { + return quat\_traits::template + write\_element(const\_cast(x)); + } + + }; + +} } +``` + +The `quat_traits_defaults` template is designed to be used as a public base for user-defined specializations of the [`quat_traits`](#quat_traits) template, to easily define the required members. If it is used, the only member that must be defined by the user in a `quat_traits` specialization is `write_element`; the `quat_traits_defaults` base will define `read_element`, as well as `scalar_type` automatically. + + +--- + +#### `deduce_quat` +#include + + +``` +namespace boost { namespace qvm { + + template ::scalar\_type> + struct deduce\_quat { + typedef Q type; + }; + +} } +``` + + +Requires: + + +* `[is\_quat](#is_quat)::value` is `true`; +* `[is\_scalar](#is_scalar)::value` is `true`; +* `[is\_quat](#is_quat)::type>::value` must be `true`; +* `[quat\_traits](#quat_traits)::type>::scalar_type` must be the same type as `S`; +* `deduce_quat::type` must be copyable. + +This template is used by QVM whenever it needs to deduce a copyable quaternion type from the quaternion type `Q`, with a scalar type `S`. Note that `Q` itself may be non-copyable. + +The main template definition returns an unspecified quaternion type, except if `S` is the same type as `[quat\_traits](#quat_traits)::scalar_type`, in which case it returns `Q`, which is only suitable if `Q` is copyable. QVM also defines (partial) specializations for the non-copyable quaternion types it produces. Users can define other (partial) specializations for their own types. + +A typical use of the `deduce_quat` template is for specifying the preferred quaternion type to be returned by the generic function template overloads in QVM depending on the type of their arguments. + + +--- + +#### `deduce_quat2` +#include + + +``` +namespace boost { namespace qvm { + + template ::type, + typename scalar::type>::type> + struct deduce\_quat2 { + typedef /\*unspecified\*/ type; + }; + +} } +``` + + +Requires: + + +* Both `[scalar](#scalar)::type` and `scalar::type` are well defined; +* `[is\_quat](#is_quat)::value` || `is_quat::value` is `true`; +* `[is\_scalar](#is_scalar)::value` is `true`; +* `is_quat::type>::value` must be `true`; +* `[quat\_traits](#quat_traits)::type>::scalar_type` must be the same type as `S`; +* `deduce_quat2::type` must be copyable. + +This template is used by QVM whenever it needs to deduce a quaternion type from the types of two user-supplied function parameters, with scalar type `S`. The returned type must have accessible copy constructor (the `A` and `B` types themselves could be non-copyable, and either one of them may not be a quaternion type.) + +The main template definition returns an unspecified quaternion type with [`scalar_type`](#quat_traits) `S`, except if `A` and `B` are the same quaternion type `Q`, in which case `Q` is returned, which is only suitable for copyable types. QVM also defines (partial) specializations for the non-copyable quaternion types it produces. Users can define other (partial) specializations for their own types. + +A typical use of the `deduce_quat2` template is for specifying the preferred quaternion type to be returned by the generic function template overloads in QVM depending on the type of their arguments. + + +--- + +#### `is_vec` +#include + + +``` +namespace boost { namespace qvm { + + template + struct is\_vec { + + static bool const value = false; + + }; + + } } +``` + +This type template defines a compile-time boolean constant value which can be used to determine whether a type `T` is a vector type. For vector types, the [`vec_traits`](#vec_traits) template can be used to access their elements generically, or to obtain their dimension and `scalar type`. + + +--- + +#### `vec_traits` +#include + + +``` +namespace boost { namespace qvm { + + template + struct vec\_traits { + + /\*main template members unspecified\*/ + + }; + + /\* + User-defined (possibly partial) specializations: + + template <> + struct vec\_traits { + + static int const dim = <>; + + typedef <> scalar\_type; + + template + static inline scalar\_type read\_element( Vector const & v ); + + template + static inline scalar\_type & write\_element( Vector & v ); + + static inline scalar\_type read\_element\_idx( int i, Vector const & v ); + static inline scalar\_type & write\_element\_idx( int i, Vector & v ); + + }; + \*/ + +} } +``` + +The `vec_traits` template must be specialized for (user-defined) vector types in order to enable vector and matrix operations defined in QVM headers for objects of those types. + + + +| | | +| --- | --- | +| | +QVM vector operations do not require that vector types are copyable. + | + +The main `vec_traits` template members are not specified. Valid specializations are required to define the following members: + +* `dim`: the expression `vec_traits::dim` must evaluate to a compile-time integer constant greater than 0 that specifies the vector size. +* `scalar_type`: the expression `vec_traits::scalar_type` must be a value type which satisfies the [`scalar requirements`](#scalar_requirements). + +In addition, valid specializations of the `vec_traits` template may define the following access functions as static members, where `v` is an object of type `Vector`, `I` is a compile-time integer constant, and `i` is a variable of type `int`: + +* `read_element`: the expression `vec_traits::read_element(v)` returns either a copy of or a const reference to the `I`-th element of `v`. +* `write_element`: the expression `vec_traits::write_element(v)` returns mutable reference to the `I`-th element of `v`. +* `read_element_idx`: the expression `vec_traits::read_element_idx(i,v)` returns either a copy of or a `const` reference to the `i`-th element of `v`. +* `write_element_idx`: the expression `vec_traits::write_element_idx(i,v)` returns mutable reference to the `i`-th element of `v`. + +It is illegal to call any of the above functions unless `is_vec::value` is true. Even then, vector types are allowed to define only a subset of the access functions. The general requirements are: + +* At least one of `read_element` or `write_element` must be defined; +* If `read_element_idx` is defined, `read_element` must also be defined; +* If `write_element_idx` is defined, `write_element` must also be defined. + +Below is an example of a user-defined 3D vector type, and its corresponding specialization of the `vec_traits` template: + + + +``` +#include + +struct float3 { float a[3]; }; + +namespace boost { namespace qvm { + + template <> + struct vec\_traits { + + static int const dim=3; + + typedef float scalar\_type; + + template + static inline scalar\_type & write\_element( float3 & v ) { + return v.a[I]; + } + + template + static inline scalar\_type read\_element( float3 const & v ) { + return v.a[I]; + } + + static inline scalar\_type & write\_element\_idx( int i, float3 & v ) { + return v.a[i]; + } //optional + + static inline scalar\_type read\_element\_idx( int i, float3 const & v ) { + return v.a[i]; + } //optional + + }; + +} } +``` + +Equivalently, using the [`vec_traits_defaults`](#vec_traits_defaults) template the above can be shortened to: + + + +``` +namespace boost { namespace qvm { + + template <> + struct vec\_traits: vec\_traits\_defaults + { + + template + static inline scalar\_type & write\_element( float3 & v ) { + return v.a[I]; + } + + static inline scalar\_type & write\_element\_idx( int i, float3 & v ) { + return v.a[i]; + } //optional + + }; + +} } +``` + + +--- + +#### `vec_traits_defaults` +#include + + +``` +namespace boost { namespace qvm { + + template + struct vec\_traits\_defaults { + + typedef VecType vec\_type; + typedef ScalarType scalar\_type; + static int const dim=Dim; + + template + static BOOST\_QVM\_INLINE\_CRITICAL + scalar\_type write\_element( vec\_type const & x ) { + return vec\_traits::template write\_element(const\_cast(x)); + } + + static BOOST\_QVM\_INLINE\_CRITICAL + scalar\_type read\_element\_idx( int i, vec\_type const & x ) { + return vec\_traits::write\_element\_idx(i,const\_cast(x)); + } + + protected: + + static BOOST\_QVM\_INLINE\_TRIVIAL + scalar\_type & write\_element\_idx( int i, vec\_type & m ) { + /\* unspecified \*/ + } + }; + +} } +``` + +The `vec_traits_defaults` template is designed to be used as a public base for user-defined specializations of the [`vec_traits`](#vec_traits) template, to easily define the required members. If it is used, the only member that must be defined by the user in a `vec_traits` specialization is `write_element`; the `vec_traits_defaults` base will define `read_element`, as well as `scalar_type` and `dim` automatically. + +Optionally, the user may also define `write_element_idx`, in which case the `vec_traits_defaults` base will provide a suitable `read_element_idx` definition automatically. If not, `vec_traits_defaults` defines a protected implementation of `write_element_idx` which may be made publicly available by the deriving `vec_traits` specialization in case the vector type for which it is being specialized can not be indexed efficiently. This `write_element_idx` function is less efficient (using meta-programming), implemented in terms of the required user-defined `write_element`. + + +--- + +#### `deduce_vec` +#include + + +``` +namespace boost { namespace qvm { + + template ::dim, + class S=typename vec\_traits::scalar\_type> + struct deduce\_vec { + + typedef /\*unspecified\*/ type; + + }; + +} } +``` + + +Requires: + + +* `[is\_vec](#is_vec)::value` is `true`; +* `[is\_scalar](#is_scalar)::value` is `true`; +* `is_vec::type>::value` must be `true`; +* `deduce_vec::type` must be copyable; +* `vec_traits::type>::dim==D`; +* `vec_traits::type>::scalar_type` is the same type as `S`. + +This template is used by QVM whenever it needs to deduce a copyable vector type of certain dimension from a single user-supplied function parameter of vector type. The returned type must have accessible copy constructor. Note that `V` may be non-copyable. + +The main template definition returns an unspecified copyable vector type of size `D` and scalar type `S`, except if `[vec\_traits](#vec_traits)::dim==D` and `[vec\_traits](#vec_traits)::scalar_type` is the same type as `S`, in which case it returns `V`, which is suitable only if `V` is a copyable type. QVM also defines (partial) specializations for the non-copyable vector types it produces. Users can define other (partial) specializations for their own types. + +A typical use of the `deduce_vec` template is for specifying the preferred vector type to be returned by the generic function template overloads in QVM depending on the type of their arguments. + + +--- + +#### `deduce_vec2` +#include + + +``` +namespace boost { namespace qvm { + + template ::type, + typename scalar::type>::type> + struct deduce\_vec2 { + typedef /\*unspecified\*/ type; + }; + +} } +``` + + +Requires: + + +* Both `[scalar](#scalar)::type` and `scalar::type` are well defined; +* `[is\_vec](#is_vec)::value || is_vec::value` is `true`; +* `[is\_scalar](#is_scalar)::value` is `true`; +* `is_vec::type>::value` must be `true`; +* `deduce_vec2::type` must be copyable; +* `vec_traits::type>::dim==D`. +* `vec_traits::type>::scalar_type` is the same type as `S`. + +This template is used by QVM whenever it needs to deduce a vector type of certain dimension from the types of two user-supplied function parameters. The returned type must have accessible copy constructor (the `A` and `B` types themselves could be non-copyable, and either one of them may be a non-vector type.) + +The main template definition returns an unspecified vector type of the requested dimension with [`scalar_type`](#vec_traits) `S`, except if `A` and `B` are the same vector type `V`, in which case `V` is returned, which is only suitable for copyable types. QVM also defines (partial) specializations for the non-copyable vector types it produces. Users can define other (partial) specializations for their own types. + +A typical use of the `deduce_vec2` template is for specifying the preferred vector type to be returned by the generic function template overloads in QVM depending on the type of their arguments. + + +--- + +#### `is_mat` +#include + + +``` +namespace boost { namespace qvm { + + template + struct is\_mat { + + static bool const value = false; + + }; + +} } +``` + +This type template defines a compile-time boolean constant value which can be used to determine whether a type `T` is a matrix type. For matrix types, the [`mat_traits`](#mat_traits) template can be used to access their elements generically, or to obtain their dimensions and scalar type. + + +--- + +#### `mat_traits` +#include + + +``` +namespace boost { namespace qvm { + + template + struct mat\_traits { + + /\*main template members unspecified\*/ + + }; + + /\* + User-defined (possibly partial) specializations: + + template <> + struct mat\_traits { + + static int const rows = <>; + static int const cols = <>; + typedef <> scalar\_type; + + template + static inline scalar\_type read\_element( Matrix const & m ); + + template + static inline scalar\_type & write\_element( Matrix & m ); + + static inline scalar\_typeread\_element\_idx( int r, int c, Matrix const & m ); + static inline scalar\_type & write\_element\_idx( int r, int c, Matrix & m ); + + }; + \*/ + +} } +``` + +The `mat_traits` template must be specialized for (user-defined) matrix types in order to enable vector and matrix operations defined in QVM headers for objects of those types. + + + +| | | +| --- | --- | +| | +The matrix operations defined by QVM do not require matrix types to be copyable. + | + +The main `mat_traits` template members are not specified. Valid specializations are required to define the following members: + +* `rows`: the expression `mat_traits::rows` must evaluate to a compile-time integer constant greater than 0 that specifies the number of rows in a matrix. +* `cols` must evaluate to a compile-time integer constant greater than 0 that specifies the number of columns in a matrix. +* `scalar_type`: the expression `mat_traits::scalar_type` must be a value type which satisfies the scalar requirements. + +In addition, valid specializations of the `mat_traits` template may define the following access functions as static members, where `m` is an object of type `Matrix`, `R` and `C` are compile-time integer constants, and `r` and `c` are variables of type `int`: + +* `read_element`: the expression `mat_traits::read_element(m)` returns either a copy of or a const reference to the element at row `R` and column `C` of `m`. +* `write_element`: the expression `mat_traits::write_element(m)` returns mutable reference to the element at row `R` and column `C` of `m`. +* `read_element_idx`: the expression `mat_traits::read_element_idx(r,c,m)` returns either a copy of or a const reference to the element at row `r` and column `c` of `m`. +* `write_element_idx`: the expression `mat_traits::write_element_idx(r,c,m)` returns mutable reference to the element at row `r` and column `c` of `m`. + +It is illegal to call any of the above functions unless `is_mat::value` is true. Even then, matrix types are allowed to define only a subset of the access functions. The general requirements are: + +* At least one of `read_element` or `write_element` must be defined; +* If `read_element_idx` is defined, `read_element` must also be defined; +* If `write_element_idx` is defined, `write_element` must also be defined. + +Below is an example of a user-defined 3x3 matrix type, and its corresponding specialization of the `mat_traits` template: + + + +``` +#include + +struct float33 { float a[3][3]; }; + +namespace boost { namespace qvm { + + template <> + struct mat\_traits { + + static int const rows=3; + static int const cols=3; + typedef float scalar\_type; + + template + static inline scalar\_type & write\_element( float33 & m ) { + return m.a[R][C]; + } + + template + static inline scalar\_type read\_element( float33 const & m ) { + return m.a[R][C]; + } + + static inline scalar\_type & write\_element\_idx( int r, int c, float33 & m ) { + return m.a[r][c]; + } + + static inline scalar\_type read\_element\_idx( int r, int c, float33 const & m ) { + return m.a[r][c]; + } + + }; + +} } +``` + +Equivalently, we could use the < + struct mat\_traits: mat\_traits\_defaults { + + template static inline scalar\_type & write\_element( float33 & m ) { return m.a[R][C]; } + + static inline scalar\_type & write\_element\_idx( int r, int c, float33 & m ) { + return m.a[r][c]; + } + + }; + +} } +``` + + +--- + +#### `mat_traits_defaults` +#include + + +``` +namespace boost { namespace qvm { + + template + struct mat\_traits\_defaults + { + typedef MatType mat\_type; + typedef ScalarType scalar\_type; + static int const rows=Rows; + static int const cols=Cols; + + template + static BOOST\_QVM\_INLINE\_CRITICAL + scalar\_type write\_element( mat\_type const & x ) { + return mat\_traits::template write\_element(const\_cast(x)); + } + + static BOOST\_QVM\_INLINE\_CRITICAL + scalar\_type read\_element\_idx( int r, int c, mat\_type const & x ) { + return mat\_traits::write\_element\_idx(r,c,const\_cast(x)); + } + + protected: + + static BOOST\_QVM\_INLINE\_TRIVIAL + scalar\_type & write\_element\_idx( int r, int c, mat\_type & m ) { + /\* unspecified \*/ + } + }; + +} } +``` + +The `mat_traits_defaults` template is designed to be used as a public base for user-defined specializations of the [`mat_traits`](#mat_traits) template, to easily define the required members. If it is used, the only member that must be defined by the user in a `mat_traits` specialization is `write_element`; the `mat_traits_defaults` base will define `read_element`, as well as `scalar_type`, `rows` and `cols` automatically. + +Optionally, the user may also define `write_element_idx`, in which case the `mat_traits_defaults` base will provide a suitable `read_element_idx` definition automatically. Otherwise, `mat_traits_defaults` defines a protected implementation of `write_element_idx` which may be made publicly available by the deriving `mat_traits` specialization in case the matrix type for which it is being specialized can not be indexed efficiently. This `write_element_idx` function is less efficient (using meta-programming), implemented in terms of the required user-defined `write_element`. + + +--- + +#### `deduce_mat` +#include + + +``` +namespace boost { namespace qvm { + + template < + class M, + int R=mat\_traits::rows, + int C=mat\_traits::cols, + class S=typename mat\_traits::scalar\_type> + struct deduce\_mat { + + typedef /\*unspecified\*/ type; + + }; + +} } +``` + + +Requires: + + +* `[is\_mat](#is_mat)::value` is `true`; +* `is_mat::type>::value` must be `true`; +* `deduce_mat::type` must be copyable; +* `[mat\_traits](#mat_traits)::type>::rows==R`; +* `mat_traits::type>::cols==C`, +* `mat_traits::type::scalar_type` is the same type as `S`. + +This template is used by QVM whenever it needs to deduce a copyable matrix type of certain dimensions from a single user-supplied function parameter of matrix type. The returned type must have accessible copy constructor. Note that M itself may be non-copyable. + +The main template definition returns an unspecified copyable matrix type of size `R` x `C` and scalar type `S`, except if `[mat\_traits](#mat_traits)::rows==R` and `mat_traits::cols==Cols` and `mat_traits::scalar_type` is S, in which case it returns `M`, which is suitable only if `M` is a copyable type. QVM also defines (partial) specializations for the non-copyable matrix types it produces. Users can define other (partial) specializations for their own types. + +A typical use of the deduce\_mat template is for specifying the preferred matrix type to be returned by the generic function template overloads in QVM depending on the type of their arguments. + + +--- + +#### `deduce_mat2` +#include + + +``` +namespace boost { namespace qvm { + + template ::type, + typename scalar::type>::type + struct deduce\_mat2 { + + typedef /\*unspecified\*/ type; + + }; + +} } +``` + + +Requires: + + +* Both `[scalar](#scalar)::type` and `scalar::type` are well defined; +* `[is\_mat](#is_mat)::value || is_mat::value` is `true`; +* `[is\_scalar](#is_scalar)::value` is `true`; +* `is_mat::type>::value` must be `true`; +* `deduce_mat2::type` must be copyable; +* `[mat\_traits](#mat_traits)::type>::rows==R`; +* `mat_traits::type>::cols==C`; +* `mat_traits::type>::scalar_type` is the same type as `S`. + +This template is used by QVM whenever it needs to deduce a matrix type of certain dimensions from the types of two user-supplied function parameters. The returned type must have accessible copy constructor (the `A` and `B` types themselves could be non-copyable, and either one of them may be a non-matrix type.) + +The main template definition returns an unspecified matrix type of the requested dimensions with [`scalar_type`](#mat_traits) `S`, except if `A` and `B` are the same matrix type `M`, in which case `M` is returned, which is only suitable for copyable types. QVM also defines (partial) specializations for the non-copyable matrix types it produces. Users can define other (partial) specializations for their own types. + +A typical use of the `deduce_mat2` template is for specifying the preferred matrix type to be returned by the generic function template overloads in QVM depending on the type of their arguments. + + +--- + + +### Built-in Quaternion, Vector and Matrix Types +QVM defines several class templates (together with appropriate specializations of [`quat_traits`](#quat_traits), [`vec_traits`](#vec_traits) and [`mat_traits`](#mat_traits) templates) which can be used as generic quaternion, vector and matrix types. Using these types directly wouldn’t be typical though, the main design goal of QVM is to allow users to plug in their own quaternion, vector and matrix types. + +#### `quat` +#include + + +``` +namespace boost { namespace qvm { + + template + struct quat { + + T a[4]; + + template + operator R() const { + R r; + assign(r,\*this); + return r; + } + + }; + + template + struct quat\_traits; + + template + struct quat\_traits< quat > { + + typedef T scalar\_type; + + template + static scalar\_type read\_element( quat const & x ) { + return x.a[I]; + } + + template + static scalar\_type & write\_element( quat & x ) { + return x.a[I]; + } + + }; + +} } +``` + +This is a simple quaternion type. It converts to any other quaternion type. + +The partial specialization of the [`quat_traits`](#quat_traits) template makes the `quat` template compatible with the generic operations defined by QVM. + + +--- + +#### `vec` +#include + + +``` +namespace boost { namespace qvm { + + template + struct vec { + + T a[Dim]; + + template + operator R() const { + R r; + assign(r,\*this); + return r; + } + + }; + + template + struct vec\_traits; + + template + struct vec\_traits< vec > { + + typedef T scalar\_type; + static int const dim=Dim; + + template + static scalar\_type read\_element( vec const & x ) { + return x.a[I]; + } + + template + static scalar\_type & write\_element( vec & x ) { + return x.a[I]; + } + + static scalar\_type read\_element\_idx( int i, vec const & x ) { + return x.a[i]; + } + + static scalar\_type & write\_element\_idx( int i, vec & x ) { + return x.a[i]; + } + }; + +} } +``` + +This is a simple vector type. It converts to any other vector type of compatible size. + +The partial specialization of the [`vec_traits`](#vec_traits) template makes the `vec` template compatible with the generic operations defined by QVM. + + +--- + +#### `mat` +#include + + +``` +namespace boost { namespace qvm { + + template + struct mat { + + T a[Rows][Cols]; + + template + operator R() const { + R r; + assign(r,\*this); + return r; + } + + }; + + template + struct mat\_traits; + + template + struct mat\_traits< mat > { + + typedef T scalar\_type; + static int const rows=Rows; + static int const cols=Cols; + + template + static scalar\_type read\_element( mat const & x ) { + return x.a[Row][Col]; + } + + template + static scalar\_type & write\_element( mat & x ) { + return x.a[Row][Col]; + } + + static scalar\_type read\_element\_idx( int row, int col, mat const & x ) { + return x.a[row][col]; + } + + static scalar\_type & write\_element\_idx( int row, int col, mat & x ) { + return x.a[row][col]; + } + + }; + +} } +``` + +This is a simple matrix type. It converts to any other matrix type of compatible size. + +The partial specialization of the [`mat_traits`](#mat_traits) template makes the `mat` template compatible with the generic operations defined by QVM. + + +--- + + +### Element Access +#### Quaternions +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value + + template -unspecified-return-type- S( Q & q ); + template -unspecified-return-type- V( Q & q ); + template -unspecified-return-type- X( Q & q ); + template -unspecified-return-type- Y( Q & q ); + template -unspecified-return-type- Z( Q & q ); + +} } +``` + +An expression of the form `S(q)` can be used to access the scalar component of the quaternion `q`. For example, + + + +``` +S(q) \*= 42; +``` + +multiplies the scalar component of `q` by the scalar 42. + +An expression of the form `V(q)` can be used to access the vector component of the quaternion `q`. For example, + + + +``` +V(q) \*= 42 +``` + +multiplies the vector component of `q` by the scalar 42. + +The `X`, `Y` and `Z` elements of the vector component can also be accessed directly using `X(q)`, `Y(q)` and `Z(q)`. + + + +| | | +| --- | --- | +| | +The return types are lvalues. + | + + +#### Vectors +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value + + template -unspecified-return-type- A( V & v ); + template -unspecified-return-type- A0( V & v ); + template -unspecified-return-type- A1( V & v ); + ... + template -unspecified-return-type- A9( V & v ); + + template -unspecified-return-type- X( V & v ); + template -unspecified-return-type- Y( V & v ); + template -unspecified-return-type- Z( V & v ); + template -unspecified-return-type- W( V & v ); + +} } +``` + +An expression of the form of `A(v)` can be used to access the `I`-th element a vector object `v`. For example, the expression: + + + +``` +A<1>(v) \*= 42; +``` + +can be used to multiply the element at index 1 (indexing in QVM is always zero-based) of a vector `v` by 42. + +For convenience, there are also non-template overloads for `I` from 0 to 9; an alternative way to write the above expression is: + + + +``` +A1(v) \*= 42; +``` + +`X`, `Y`, `Z` and `W` act the same as `A0`/`A1`/`A2`/`A3`; yet another alternative way to write the above expression is: + + + +``` +Y(v) \*= 42; +``` + + + +| | | +| --- | --- | +| | +The return types are lvalues. + | + + +#### Vector Element Swizzling +#include + + +``` +namespace boost { namespace qvm { + + //\*\*\* Accessing vector elements by swizzling \*\*\* + + //2D view proxies, only enabled if: + // is\_vec::value + template -unspecified-2D-vector-type- XX( V & v ); + template -unspecified-2D-vector-type- XY( V & v ); + template -unspecified-2D-vector-type- XZ( V & v ); + template -unspecified-2D-vector-type- XW( V & v ); + template -unspecified-2D-vector-type- X0( V & v ); + template -unspecified-2D-vector-type- X1( V & v ); + template -unspecified-2D-vector-type- YX( V & v ); + template -unspecified-2D-vector-type- YY( V & v ); + template -unspecified-2D-vector-type- YZ( V & v ); + template -unspecified-2D-vector-type- YW( V & v ); + template -unspecified-2D-vector-type- Y0( V & v ); + template -unspecified-2D-vector-type- Y1( V & v ); + template -unspecified-2D-vector-type- ZX( V & v ); + template -unspecified-2D-vector-type- ZY( V & v ); + template -unspecified-2D-vector-type- ZZ( V & v ); + template -unspecified-2D-vector-type- ZW( V & v ); + template -unspecified-2D-vector-type- Z0( V & v ); + template -unspecified-2D-vector-type- Z1( V & v ); + template -unspecified-2D-vector-type- WX( V & v ); + template -unspecified-2D-vector-type- WY( V & v ); + template -unspecified-2D-vector-type- WZ( V & v ); + template -unspecified-2D-vector-type- WW( V & v ); + template -unspecified-2D-vector-type- W0( V & v ); + template -unspecified-2D-vector-type- W1( V & v ); + ... + //2D view proxies, only enabled if: + // is\_scalar::value + template -unspecified-2D-vector-type- X0( S & s ); + template -unspecified-2D-vector-type- X1( S & s ); + template -unspecified-2D-vector-type- XX( S & s ); + ... + -unspecified-2D-vector-type- \_00(); + -unspecified-2D-vector-type- \_01(); + -unspecified-2D-vector-type- \_10(); + -unspecified-2D-vector-type- \_11(); + + //3D view proxies, only enabled if: + // is\_vec::value + template -unspecified-3D-vector-type- XXX( V & v ); + ... + template -unspecified-3D-vector-type- XXW( V & v ); + template -unspecified-3D-vector-type- XX0( V & v ); + template -unspecified-3D-vector-type- XX1( V & v ); + template -unspecified-3D-vector-type- XYX( V & v ); + ... + template -unspecified-3D-vector-type- XY1( V & v ); + ... + template -unspecified-3D-vector-type- WW1( V & v ); + ... + //3D view proxies, only enabled if: + // is\_scalar::value + template -unspecified-3D-vector-type- X00( S & s ); + template -unspecified-3D-vector-type- X01( S & s ); + ... + template -unspecified-3D-vector-type- XXX( S & s ); + template -unspecified-3D-vector-type- XX0( S & s ); + ... + -unspecified-3D-vector-type- \_000(); + -unspecified-3D-vector-type- \_001(); + -unspecified-3D-vector-type- \_010(); + ... + -unspecified-3D-vector-type- \_111(); + + //4D view proxies, only enabled if: + // is\_vec::value + template -unspecified-4D-vector-type- XXXX( V & v ); + ... + template -unspecified-4D-vector-type- XXXW( V & v ); + template -unspecified-4D-vector-type- XXX0( V & v ); + template -unspecified-4D-vector-type- XXX1( V & v ); + template -unspecified-4D-vector-type- XXYX( V & v ); + ... + template -unspecified-4D-vector-type- XXY1( V & v ); + ... + template -unspecified-4D-vector-type- WWW1( V & v ); + ... + //4D view proxies, only enabled if: + // is\_scalar::value + template -unspecified-4D-vector-type- X000( S & s ); + template -unspecified-4D-vector-type- X001( S & s ); + ... + template -unspecified-4D-vector-type- XXXX( S & s ); + template -unspecified-4D-vector-type- XX00( S & s ); + ... + -unspecified-4D-vector-type- \_0000(); + -unspecified-4D-vector-type- \_0001(); + -unspecified-4D-vector-type- \_0010(); + ... + -unspecified-4D-vector-type- \_1111(); + +} } +``` + +Swizzling allows zero-overhead direct access to a (possibly rearranged) subset of the elements of 2D, 3D and 4D vectors. For example, if `v` is a 4D vector, the expression `YX(v) is a 2D view proxy whose `X` element refers to the `Y` element of `v`, and whose `Y` element refers to the `X` element of `v`. Like other view proxies `YX` is an lvalue, that is, if `v2` is a 2D vector, one could write: + + + +``` +YX(v) = v2; +``` + +The above will leave the `Z` and `W` elements of `v` unchanged but assign the `Y` element of `v2` to the `X` element of `v` and the `X` element of `v2` to the `Y` element of `v`. + +All permutations of `X`, `Y`, `Z`, `W`, `0`, `1` for 2D, 3D and 4D swizzling are available (if the first character of the swizzle identifier is `0` or `1`, it is preceded by a `_`, for example `_11XY`). + +It is valid to use the same vector element more than once: the expression `ZZZ(v)` is a 3D vector whose `X`, `Y` and `Z` elements all refer to the `Z` element of `v`. + +Finally, scalars can be "swizzled" to access them as vectors: the expression `_0X01(42.0f)` is a 4D vector with `X`=0, `Y`=42.0, `Z`=0, `W`=1. + + +#### Matrices +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value + + template -unspecified-return-type- A( M & m ); + + template -unspecified-return-type- A00( M & m ); + template -unspecified-return-type- A01( M & m ); + ... + template -unspecified-return-type- A09( M & m ); + template -unspecified-return-type- A10( M & m ); + ... + template -unspecified-return-type- A99( M & m ); + +} } +``` + +An expression of the form `A(m)` can be used to access the element at row `R` and column `C` of a matrix object `m`. For example, the expression: + + + +``` +A<4,2>(m) \*= 42; +``` + +can be used to multiply the element at row 4 and column 2 of a matrix `m` by 42. + +For convenience, there are also non-template overloads for `R` from `0` to `9` and `C` from `0` to `9`; an alternative way to write the above expression is: + + + +``` +A42(m) \*= 42; +``` + + + +| | | +| --- | --- | +| | +The return types are lvalues. + | + + +--- + + +### Quaternion Operations +#### `assign` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value && is\_quat::value + template + A & assign( A & a, B const & b ); + +} } +``` + + +Effects: + +Copies all elements of the quaternion `b` to the quaternion `a`. +Returns: + +`a`. + +--- + +#### `convert_to` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value && is\_quat::value + template + R convert\_to( A const & a ); + + //Only enabled if: + // is\_quat::value && is\_mat::value && + // mat\_traits::rows==3 && mat\_traits::cols==3 + template + R convert\_to( A const & m ); + +} } +``` + + +Requires: + +`R` must be copyable. +Effects: + + +* The first overload is equivalent to: `R r; assign(r,a); return r;` +* The second overload assumes that `m` is an orthonormal rotation matrix and converts it to a quaternion that performs the same rotation. + + +--- + +#### `operator-=` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value && is\_quat::value + template + A & operator-=( A & a, B const & b ); + +} } +``` + + +Effects: + +Subtracts the elements of `b` from the corresponding elements of `a`. +Returns: + +`a`. + +--- + +#### `operator-` (unary) +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value + template + typename deduce\_quat::type + operator-( A const & a ); + +} } +``` + + +Returns: + +A quaternion of the negated elements of `a`. + + +| | | +| --- | --- | +| | +The [`deduce_quat`](#deduce_quat) template can be specialized to deduce the desired return type from the type `A`. + | + + +--- + +#### `operator-` (binary) +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value && is\_quat::value + template + typename deduce\_quat2::type + operator-( A const & a, B const & b ); + +} } +``` + + +Returns: + +A quaternion with elements equal to the elements of `b` subtracted from the corresponding elements of `a`. + + +| | | +| --- | --- | +| | +The [`deduce_quat2`](#deduce_quat2) template can be specialized to deduce the desired return type, given the types `A` and `B`. + | + + +--- + +#### `operator+=` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value && is\_quat::value + template + A & operator+=( A & a, B const & b ); + +} } +``` + + +Effects: + +Adds the elements of `b` to the corresponding elements of `a`. +Returns: + +`a`. + +--- + +#### `operator+` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value && is\_quat::value && + template + typename deduce\_quat2::type + operator+( A const & a, B const & b ); + +} } +``` + + +Returns: + +A quaternion with elements equal to the elements of `a` added to the corresponding elements of `b`. + + +| | | +| --- | --- | +| | +The [`deduce_quat2`](#deduce_quat2) template can be specialized to deduce the desired return type, given the types `A` and `B`. + | + + +--- + +#### `operator/=` (scalar) +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value && is\_scalar::value + template + A & operator/=( A & a, B b ); + +} } +``` + + +Effects: + +This operation divides a quaternion by a scalar. +Returns: + +`a`. + +--- + +#### `operator/` (scalar) +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value && is\_scalar::value + template + typename deduce\_quat2>::type + operator/( A const & a, B b ); + +} } +``` + + +Returns: + +A quaternion that is the result of dividing the quaternion `a` by the scalar `b`. + + +| | | +| --- | --- | +| | +The [`deduce_quat2`](#deduce_quat2) template can be specialized to deduce the desired return type from the types `A` and `B`. + | + + +--- + +#### `operator*=` (scalar) +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value && is\_scalar::value + template + A & operator\*=( A & a, B b ); + +} } +``` + + +Effects: + +This operation multiplies the quaternion `a` by the scalar `b`. +Returns: + +`a`. + +--- + +#### `operator*=` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value && is\_quat::value + template + A & operator\*=( A & a, B const & b ); + +} } +``` + + +Effects: + +As if: + + +``` +A tmp(a); +a = tmp \* b; +return a; +``` + + +--- + +#### `operator*` (scalar) +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value && is\_scalar::value + template + typename deduce\_quat2::type + operator\*( A const & a, B b ); + +} } +``` + + +Returns: + +A quaternion that is the result of multiplying the quaternion `a` by the scalar `b`. + + +| | | +| --- | --- | +| | +The [`deduce_quat2`](#deduce_quat2) template can be specialized to deduce the desired return type from the types `A` and `B`. + | + + +--- + +#### `operator*` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value && is\_quat::value + template + typename deduce\_quat2::type + operator\*( A const & a, B const & b ); + +} } +``` + + +Returns: + +The result of multiplying the quaternions `a` and `b`. + + +| | | +| --- | --- | +| | +The [`deduce_quat2`](#deduce_quat2) template can be specialized to deduce the desired return type, given the types `A` and `B`. + | + + +--- + +#### `operator==` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value && is\_quat::value + template + bool operator==( A const & a, B const & b ); + +} } +``` + + +Returns: + +`true` if each element of `a` compares equal to its corresponding element of `b`, `false` otherwise. + +--- + +#### `operator!=` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value && is\_quat::value + template + bool operator!=( A const & a, B const & b ); + +} } +``` + + +Returns: + +`!(a == b)`. + +--- + +#### `cmp` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value && is\_quat::value + template + bool cmp( A const & a, B const & b, Cmp pred ); + +} } +``` + + +Returns: + +Similar to [`operator==`](#quat_eq), except that it uses the binary predicate `pred` to compare the individual quaternion elements. + +--- + +#### `mag_sqr` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value + template + typename quat\_traits::scalar\_type + mag\_sqr( A const & a ); + +} } +``` + + +Returns: + +The squared magnitude of the quaternion `a`. + +--- + +#### `mag` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value + template + typename quat\_traits::scalar\_type + mag( A const & a ); + +} } +``` + + +Returns: + +The magnitude of the quaternion `a`. + +--- + +#### `normalized` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value + template + typename deduce\_quat::type + normalized( A const & a ); + +} } +``` + + +Effects: + +As if: + + +``` +typename deduce\_quat::type tmp; +assign(tmp,a); +normalize(tmp); +return tmp; +``` + + + +| | | +| --- | --- | +| | +The [`deduce_quat`](#deduce_quat) template can be specialized to deduce the desired return type from the type `A`. + | + + +--- + +#### `normalize` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value + template + void normalize( A & a ); + +} } +``` + + +Effects: + +Normalizes `a`. +Ensures: + +`mag(a)==scalar_traits::scalar_type>::value(1).` +Throws: + +If the magnitude of `a` is zero, throws [`zero_magnitude_error`](#zero_magnitude_error). + +--- + +#### `dot` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value && is\_quat::value + template + typename deduce\_scalar::type + dot( A const & a, B const & b ); + +} } +``` + + +Returns: + +The dot product of the quaternions `a` and `b`. + + +| | | +| --- | --- | +| | +The [`deduce_scalar`](#deduce_scalar) template can be specialized to deduce the desired return type, given the types `A` and `B`. + | + + +--- + +#### `conjugate` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value + template + typename deduce\_quat::type + conjugate( A const & a ); + +} } +``` + + +Returns: + +Computes the conjugate of `a`. + + +| | | +| --- | --- | +| | +The [`deduce_quat`](#deduce_quat) template can be specialized to deduce the desired return type from the type `A`. + | + + +--- + +#### `inverse` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value + template + typename deduce\_quat::type + inverse( A const & a ); + +} } +``` + + +Returns: + +Computes the multiplicative inverse of `a`, or the conjugate-to-norm ratio. +Throws: + +If the magnitude of `a` is zero, throws [`zero_magnitude_error`](#zero_magnitude_error). + + +| | | +| --- | --- | +| | +If `a` is known to be unit length, `conjugate` is equivalent to [`inverse`](#quat_inverse), yet it is faster to compute. + | + + + +| | | +| --- | --- | +| | +The [`deduce_quat`](#deduce_quat) template can be specialized to deduce the desired return type from the type `A`. + | + + +--- + +#### `slerp` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value && is\_quat::value && is\_scalar + template + typename deduce\_quat2 >::type + slerp( A const & a, B const & b, C c ); + +} } +``` + + +Preconditions: + +`t>=0 && t<=1`. +Returns: + +A quaternion that is the result of Spherical Linear Interpolation of the quaternions `a` and `b` and the interpolation parameter `c`. When `slerp` is applied to unit quaternions, the quaternion path maps to a path through 3D rotations in a standard way. The effect is a rotation with uniform angular velocity around a fixed rotation axis. + + +| | | +| --- | --- | +| | +The [`deduce_quat2`](#deduce_quat2) template can be specialized to deduce the desired return type, given the types `A` and `B`. + | + + +--- + +#### `zero_quat` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- zero\_quat(); + +} } +``` + + +Returns: + +A read-only quaternion of unspecified type with [`scalar_type`](#scalar_traits) `T`, with all elements equal to [`scalar_traits::value(0)`](#scalar_traits). + +--- + +#### `set_zero` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value + template + void set\_zero( A & a ); + +} } +``` + + +Effects: + +As if: + + +``` +assign(a, + zero\_quat::scalar\_type>()); +``` + + +--- + +#### `identity_quat` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- identity\_quat(); + +} } +``` + + +Returns: + +An identity quaternion with scalar type `S`. + +--- + +#### `set_identity` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value + template + void set\_identity( A & a ); + +} } +``` + + +Effects: + +As if: + + +``` +assign( + a, + identity\_quat::scalar\_type>()); +``` + + +--- + +#### `rot_quat` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value && vec\_traits::dim==3 + template + -unspecified-return-type- rot\_quat( A const & axis, typename vec\_traits::scalar\_type angle ); + +} } +``` + + +Returns: + +A quaternion of unspecified type which performs a rotation around the `axis` at `angle` radians. +Throws: + +In case the axis vector has zero magnitude, throws [`zero_magnitude_error`](#zero_magnitude_error). + + +| | | +| --- | --- | +| | +The `rot_quat` function is not a [view proxy](#view_proxy); it returns a temp object. + | + + +--- + +#### `set_rot` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value && + // is\_vec::value && vec\_traits::dim==3 + template + void set\_rot( A & a, B const & axis, typename vec\_traits::scalar\_type angle ); + +} } +``` + + +Effects: + +As if: + + +``` +assign( + a, + rot\_quat(axis,angle)); +``` + + +--- + +#### `rotate` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value && + // is\_vec::value && vec\_traits::dim==3 + template + void rotate( A & a, B const & axis, typename quat\_traits::scalar\_type angle ); + +} } +``` + + +Effects: + +As if: `a *= [rot\_quat](#rot_quat)(axis,angle)`. + +--- + +#### `rotx_quat` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- rotx\_quat( Angle const & angle ); + +} } +``` + + +Returns: + +A [view proxy](#view_proxy) quaternion of unspecified type and scalar type `Angle`, which performs a rotation around the X axis at `angle` radians. + +--- + +#### `set_rotx` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value + template + void set\_rotx( A & a, typename quat\_traits::scalar\_type angle ); + +} } +``` + + +Effects: + +As if: + + +``` +assign( + a, + rotx\_quat(angle)); +``` + + +--- + +#### `rotate_x` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value + template + void rotate\_x( A & a, typename quat\_traits::scalar\_type angle ); + +} } +``` + + +Effects: + +As if: `a *= [rotx\_quat](#rotx_quat)(angle)`. + +--- + +#### `roty_quat` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- roty\_quat( Angle const & angle ); + +} } +``` + + +Returns: + +A [view proxy](#view_proxy) quaternion of unspecified type and scalar type `Angle`, which performs a rotation around the Y axis at `angle` radians. + +--- + +#### `set_roty` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value + template + void set\_rotz( A & a, typename quat\_traits::scalar\_type angle ); + +} } +``` + + +Effects: + +As if: + + +``` +assign( + a, + roty\_quat(angle)); +``` + + +--- + +#### `rotate_y` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value + template + void rotate\_y( A & a, typename quat\_traits::scalar\_type angle ); + +} } +``` + + +Effects: + +As if: `a *= [roty\_quat](#roty_quat)(angle)`. + +--- + +#### `rotz_quat` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- rotz\_quat( Angle const & angle ); + +} } +``` + + +Returns: + +A [view proxy](#view_proxy) quaternion of unspecified type and scalar type `Angle`, which performs a rotation around the Z axis at `angle` radians. + +--- + +#### `set_rotz` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value + template + void set\_rotz( A & a, typename quat\_traits::scalar\_type angle ); + +} } +``` + + +Effects: + +As if: + + +``` +assign( + a, + rotz\_quat(angle)); +``` + + +--- + +#### `rotate_z` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value + template + void rotate\_z( A & a, typename quat\_traits::scalar\_type angle ); + +} } +``` + + +Effects: + +As if: `a *= [rotz\_quat](#rotz_quat)(angle)`. + +--- + +#### `scalar_cast` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value + template + -unspecified-return\_type- scalar\_cast( A const & a ); + +} } +``` + + +Returns: + +A read-only [view proxy](#view_proxy) of `a` that looks like a quaternion of the same dimensions as `a`, but with [`scalar_type`](#quat_traits) `Scalar` and elements constructed from the corresponding elements of `a`. + +--- + +#### `qref` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_quat::value + template + -unspecified-return-type- qref( A & a ); + +} } +``` + + +Returns: + +An identity view proxy of `a`; that is, it simply accesses the elements of `a`. + + +| | | +| --- | --- | +| | `qref` allows calling QVM operations when `a` is of built-in type, for example a plain old C array. + | + + +--- + + +### Vector Operations +#### `assign` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value && is\_vec::value && + // vec\_traits::dim==vec\_traits::dim + template + A & assign( A & a, B const & b ); + +} } +``` + + +Effects: + +Copies all elements of the vector `b` to the vector `a`. +Returns: + +`a`. + +--- + +#### `convert_to` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value && is\_vec::value && + // vec\_traits::dim==vec\_traits::dim + template + R convert\_to( A const & a ); + +} } +``` + + +Requires: + +`R` must be copyable. +Effects: + +As if: `R r; assign(r,a); return r;` + +--- + +#### `operator-=` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value && is\_vec::value && + // vec\_traits::dim==vec\_traits::dim + template + A & operator-=( A & a, B const & b ); + +} } +``` + + +Effects: + +Subtracts the elements of `b` from the corresponding elements of `a`. +Returns: + +`a`. + +--- + +#### `operator-` (unary) +operator-(vec) + +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_vec::value + template + typename deduce\_vec::type + operator-( A const & a ); + +} } +``` + + +Returns: + +A vector of the negated elements of `a`. + + +| | | +| --- | --- | +| | +The [`deduce_vec`](#deduce_vec) template can be specialized to deduce the desired return type from the type `A`. + | + + +--- + +#### `operator-` (binary) +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value && is\_vec::value && + // vec\_traits::dim==vec\_traits::dim + template + typename deduce\_vec2::dim>::type + operator-( A const & a, B const & b ); + +} } +``` + + +Returns: + +A vector of the same size as `a` and `b`, with elements the elements of `b` subtracted from the corresponding elements of `a`. + + +| | | +| --- | --- | +| | +The [`deduce_vec2`](#deduce_vec2) template can be specialized to deduce the desired return type, given the types `A` and `B`. + | + + +--- + +#### `operator+=` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value && is\_vec::value && + // vec\_traits::dim==vec\_traits::dim + template + A & operator+=( A & a, B const & b ); + +} } +``` + + +Effects: + +Adds the elements of `b` to the corresponding elements of `a`. +Returns: + +`a`. + +--- + +#### `operator+` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value && is\_vec::value && + // vec\_traits::dim==vec\_traits::dim + template + typename deduce\_vec2::dim>::type + operator+( A const & a, B const & b ); + +} } +``` + + +Returns: + +A vector of the same size as `a` and `b`, with elements the elements of `b` added to the corresponding elements of `a`. + + +| | | +| --- | --- | +| | +The [`deduce_vec2`](#deduce_vec2) template can be specialized to deduce the desired return type, given the types `A` and `B`. + | + + +--- + +#### `operator/=` (scalar) +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_vec::value && is\_scalar::value + template + A & operator/=( A & a, B b ); + +} } +``` + + +Effects: + +This operation divides a vector by a scalar. +Returns: + +`a`. + +--- + +#### `operator/` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_vec::value && is\_scalar::value + template + typename deduce\_vec2::dim>::type + operator/( A const & a, B b ); + +} } +``` + + +Returns: + +A vector that is the result of dividing the vector `a` by the scalar `b`. + + +| | | +| --- | --- | +| | +The [`deduce_vec2`](#deduce_vec2) template can be specialized to deduce the desired return type from the types `A` and `B`. + | + + +--- + +#### `operator*=` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_vec::value && is\_scalar::value + template + A & operator\*=( A & a, B b ); + +} } +``` + + +Effects: + +This operation multiplies the vector `a` by the scalar `b`. +Returns: + +`a`. + +--- + +#### `operator*` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_vec::value && is\_scalar::value + template + typename deduce\_vec2::dim>::type + operator\*( A const & a, B b ); + + //Only enabled if: is\_scalar::value && is\_vec::value + template + typename deduce\_vec2::dim>::type + operator\*( B b, A const & a ); + +} } +``` + + +Returns: + +A vector that is the result of multiplying the vector `a` by the scalar `b`. + + +| | | +| --- | --- | +| | +The [`deduce_vec2`](#deduce_vec2) template can be specialized to deduce the desired return type from the types `A` and `B`. + | + + +--- + +#### `operator==` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value && is\_vec::value && + // vec\_traits::dim==vec\_traits::dim + template + bool operator==( A const & a, B const & b ); + +} } +``` + + +Returns: + +`true` if each element of `a` compares equal to its corresponding element of `b`, `false` otherwise. + +--- + +#### `operator!=` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value && is\_vec::value && + // vec\_traits::dim==vec\_traits::dim + template + bool operator!=( A const & a, B const & b ); + +} } +``` + + +Returns: + +`!(a == b)`. + +--- + +#### `cmp` + + +``` +.#include + +namespace boost +{ + namespace qvm + { + //Only enabled if: + // is\_mat::value && is\_mat::value && + // mat\_traits::rows==mat\_traits::rows && + // mat\_traits::cols==mat\_traits::cols + template + bool cmp( A const & a, B const & b, Cmp pred ); + +} } +``` + + +Returns: + +Similar to [`operator==`](#vec_eq), except that the individual elements of `a` and `b` are passed to the binary predicate `pred` for comparison. + +--- + +#### `mag_sqr` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value + template + typename vec\_traits::scalar\_type + mag\_sqr( A const & a ); + +} } +``` + + +Returns: + +The squared magnitude of the vector `a`. + +--- + +#### `mag` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value + template + typename vec\_traits::scalar\_type + mag( A const & a ); + +} } +``` + + +Returns: + +The magnitude of the vector `a`. + +--- + +#### `normalized` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value + template + typename deduce\_vec::type + normalized( A const & a ); + +} } +``` + + +Effects: + +As if: + + +``` +typename deduce\_vec::type tmp; +assign(tmp,a); +normalize(tmp); +return tmp; +``` + + + +| | | +| --- | --- | +| | +The [`deduce_vec`](#deduce_vec) template can be specialized to deduce the desired return type from the type `A`. + | + + +--- + +#### `normalize` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value + template + void normalize( A & a ); + +} } +``` + + +Effects: + +Normalizes `a`. + + + +Ensures: + +`mag(a)==[scalar\_traits](#scalar_traits)::scalar\_type](#vec_traits)>::value(1)`. + + +Throws: + +If the magnitude of `a` is zero, throws [`zero_magnitude_error`](#zero_magnitude_error). + +--- + +#### `dot` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value && is\_vec::value && + // vec\_traits::dim==vec\_traits::dim + template + typename deduce\_scalar::type + dot( A const & a, B const & b ); + +} } +``` + + +Returns: + +The dot product of the vectors `a` and `b`. + + +| | | +| --- | --- | +| | +The [`deduce_scalar`](#deduce_scalar) template can be specialized to deduce the desired return type, given the types `A` and `B`. + | + + +--- + +#### `cross` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value && is\_vec::value && + // vec\_traits::dim==3 && vec\_traits::dim==3 + template + typename deduce\_vec2::type + cross( A const & a, B const & b ); + + //Only enabled if: + // is\_vec::value && is\_vec::value && + // vec\_traits::dim==2 && vec\_traits::dim==2 + template + typename deduce\_scalar< + typename vec\_traits::scalar\_type, + typename vec\_traits::scalar\_type>::type + cross( A const & a, B const & b ); + +} } +``` + + +Returns: + +The cross product of the vectors `a` and `b`. + + +| | | +| --- | --- | +| | +The [`deduce_vec2`](#deduce_vec2) (and [`deduce_scalar`](#deduce_scalar)) templates can be specialized to deduce the desired return type, given the types `A` and `B`. + | + + +--- + +#### `zero_vec` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- zero\_vec(); + +} } +``` + + +Returns: + +A read-only vector of unspecified type with [`scalar_type`](#vec_traits) `T` and size `S`, with all elements equal to [`scalar_traits::value(0)`](#scalar_traits). + +--- + +#### `set_zero` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value + template + void set\_zero( A & a ); + +} } +``` + + +Effects: + +As if: + + +``` +assign(a, + zero\_vec< + typename vec\_traits::scalar\_type, + vec\_traits::dim>()); +``` + + +--- + +#### `scalar_cast` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_vec::value + template + -unspecified-return\_type- scalar\_cast( A const & a ); + +} } +``` + + +Returns: + +A read-only [view proxy](#view_proxy) of `a` that looks like a vector of the same dimensions as `a`, but with [`scalar_type`](#vec_traits) `Scalar` and elements constructed from the corresponding elements of `a`. + +--- + +#### `vref` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_vec::value + template + -unspecified-return-type- vref( A & a ); + +} } +``` + + +Returns: + +An identity [view proxy](#view_proxy) of `a`; that is, it simply accesses the elements of `a`. + + +| | | +| --- | --- | +| | `vref` allows calling QVM operations when `a` is of built-in type, for example a plain old C array. + | + + +--- + + +### Matrix Operations +#### `assign` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && is\_mat::value && + // mat\_traits::rows==mat\_traits::rows && + // mat\_traits::cols==mat\_traits::cols + template + A & assign( A & a, B const & b ); + +} } +``` + + +Effects: + +Copies all elements of the matrix `b` to the matrix `a`. +Returns: + +`a`. + +--- + +#### `convert_to` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && is\_mat::value && + // mat\_traits::rows==mat\_traits::rows && + // mat\_traits::cols==mat\_traits::cols + template + R convert\_to( A const & a ); + +} } +``` + + +Requires: + +`R` must be copyable. + + + +Effects: + +As if: `R r; [assign](#mat_assign)(r,a); return r;` + + +--- + +#### `operator-=` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && is\_mat::value && + // mat\_traits::rows==mat\_traits::rows && + // mat\_traits::cols==mat\_traits::cols + template + A & operator-=( A & a, B const & b ); + +} } +``` + + +Effects: + +Subtracts the elements of `b` from the corresponding elements of `a`. +Returns: + +`a`. + +--- + +#### `operator-` (unary) +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_mat::value + template + typename deduce\_mat::type + operator-( A const & a ); + +} } +``` + + +Returns: + +A matrix of the negated elements of `a`. + + +| | | +| --- | --- | +| | +The [`deduce_mat`](#deduce_mat) template can be specialized to deduce the desired return type from the type `A`. + | + + +--- + +#### `operator-` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && is\_mat::value && + // mat\_traits::rows==mat\_traits::rows && + // mat\_traits::cols==mat\_traits::cols + template + typename deduce\_mat2::rows,mat\_traits::cols>::type + operator-( A const & a, B const & b ); + +} } +``` + + +Returns: + +A matrix of the same size as `a` and `b`, with elements the elements of `b` subtracted from the corresponding elements of `a`. + + +| | | +| --- | --- | +| | +The [`deduce_mat2`](#deduce_mat2) template can be specialized to deduce the desired return type, given the types `A` and `B`. + | + + +--- + +#### `operator+=` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && is\_mat::value && + // mat\_traits::rows==mat\_traits::rows && + // mat\_traits::cols==mat\_traits::cols + template + A & operator+=( A & a, B const & b ); + +} } +``` + + +Effects: + +Adds the elements of `b` to the corresponding elements of `a`. +Returns: + +`a`. + +--- + +#### `operator+` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && is\_mat::value && + // mat\_traits::rows==mat\_traits::rows && + // mat\_traits::cols==mat\_traits::cols + template + typename deduce\_mat2::rows,mat\_traits::cols>::type + operator+( A const & a, B const & b ); + +} } +``` + + +Returns: + +A matrix of the same size as `a` and `b`, with elements the elements of `b` added to the corresponding elements of `a`. + + +| | | +| --- | --- | +| | +The [`deduce_mat2`](#deduce_mat2) template can be specialized to deduce the desired return type, given the types `A` and `B`. + | + + +--- + +#### `operator/=` (scalar) +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_mat::value && is\_scalar::value + template + A & operator/=( A & a, B b ); + +} } +``` + + +Effects: + +This operation divides a matrix by a scalar. +Returns: + +`a`. + +--- + +#### `operator/` (scalar) +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_mat::value && is\_scalar::value + template + typename deduce\_mat2::rows,mat\_traits::cols>::type + operator/( A const & a, B b ); + +} } +``` + + +Returns: + +A matrix that is the result of dividing the matrix `a` by the scalar `b`. + + +| | | +| --- | --- | +| | +The [`deduce_mat2`](#deduce_mat2) template can be specialized to deduce the desired return type from the types `A` and `B`. + | + + +--- + +#### `operator*=` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && is\_mat::value && + // mat\_traits::rows==mat\_traits::cols && + // mat\_traits::rows==mat\_traits::rows && + // mat\_traits::cols==mat\_traits::cols + template + A & operator\*=( A & a, B const & b ); + +} } +``` + + +Effects: + +As if: + + +``` +A tmp(a); +a = tmp \* b; +return a; +``` + + +--- + +#### `operator*=` (scalar) +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_mat::value && is\_scalar::value + template + A & operator\*=( A & a, B b ); + +} } +``` + + +Effects: + +This operation multiplies the matrix `a` matrix by the scalar `b`. +Returns: + +`a`. + +--- + +#### `operator*` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && is\_mat::value && + // mat\_traits::cols==mat\_traits::rows + template + typename deduce\_mat2::rows,mat\_traits::cols>::type + operator\*( A const & a, B const & b ); + +} } +``` + + +Returns: + +The result of [multiplying](https://en.wikipedia.org/wiki/Matrix_multiplication) the matrices `a` and `b`. + + +| | | +| --- | --- | +| | +The [`deduce_mat2`](#deduce_mat2) template can be specialized to deduce the desired return type, given the types `A` and `B`. + | + + +--- + +#### `operator*` (scalar) +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_mat::value && is\_scalar::value + template + typename deduce\_mat2::rows,mat\_traits::cols>::type + operator\*( A const & a, B b ); + + //Only enabled if: is\_scalar::value && is\_mat::value + template + typename deduce\_mat2::rows,mat\_traits::cols>::type + operator\*( B b, A const & a ); + +} } +``` + + +Returns: + +A matrix that is the result of multiplying the matrix `a` by the scalar `b`. + + +| | | +| --- | --- | +| | +The [`deduce_mat2`](#deduce_mat2) template can be specialized to deduce the desired return type from the types `A` and `B`. + | + + +--- + +#### `operator==` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && is\_mat::value && + // mat\_traits::rows==mat\_traits::rows && + // mat\_traits::cols==mat\_traits::cols + template + bool operator==( A const & a, B const & b ); + +} } +``` + + +Returns: + +`true` if each element of `a` compares equal to its corresponding element of `b`, `false` otherwise. + +--- + +#### `operator!=` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && is\_mat::value && + // mat\_traits::rows==mat\_traits::rows && + // mat\_traits::cols==mat\_traits::cols + template + bool operator!=( A const & a, B const & b ); + +} } +``` + + +Returns: + +`!( a [==](#mat_eq) b )`. + +--- + +#### `cmp` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && is\_mat::value && + // mat\_traits::rows==mat\_traits::rows && + // mat\_traits::cols==mat\_traits::cols + template + bool cmp( A const & a, B const & b, Cmp pred ); + +} } +``` + + +Returns: + +Similar to [`operator==`](#mat_eq), except that the individual elements of `a` and `b` are passed to the binary predicate `pred` for comparison. + +--- + +#### `inverse` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && is\_scalar::value + // mat\_traits::rows==mat\_traits::cols + + template + typename deduce\_mat2::rows,mat\_traits::cols>::type + inverse( A const & a, B det ); + + template + typename deduce\_mat::type + inverse( A const & a ); + +} } +``` + + +Preconditions: + +`det!=0` +Returns: + +Both overloads compute the inverse of `a`. The first overload takes the pre-computed determinant of `a`. +Throws: + +The second overload computes the determinant automatically and throws [`zero_determinant_error`](#zero_determinant_error) if the computed determinant is zero. + + +| | | +| --- | --- | +| | +The [`deduce_mat`](#deduce_mat) (and [`deduce_mat2`](#deduce_mat2)) templates can be specialized to deduce the desired return type from the type `A` (and `B`). + | + + +--- + +#### `zero_mat` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- zero\_mat(); + + template + -unspecified-return-type- zero\_mat(); + +} } +``` + + +Returns: + +A read-only matrix of unspecified type with [`scalar_type`](#mat_traits) `T`, `R` rows and `C` columns (or `D` rows and `D` columns), with all elements equal to [`scalar_traits::value(0)`](#scalar_traits). + +--- + +#### `set_zero` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value + template + void set\_zero( A & a ); + +} } +``` + + +Effects: + +As if: + + +``` +assign(a, + zero\_mat< + typename mat\_traits::scalar\_type, + mat\_traits::rows, + mat\_traits::cols>()); +``` + + +--- + +#### `identity_mat` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- identity\_mat(); + +} } +``` + + +Returns: + +An identity matrix of size `D` x `D` and scalar type `S`. + +--- + +#### `set_identity` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && + // mat\_traits::cols==mat\_traits::rows + template + void set\_identity( A & a ); + +} } +``` + + +Effects: + +As if: + + +``` +assign( + a, + identity\_mat< + typename mat\_traits::scalar\_type, + mat\_traits::rows, + mat\_traits::cols>()); +``` + + +--- + +#### `rot_mat` / Euler angles +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_vec::value && vec\_traits::dim==3 + template + -unspecified-return-type- + rot\_mat( A const & axis, Angle angle ); + + template + -unspecified-return-type- + rot\_mat\_xzy( Angle x1, Angle z2, Angle y3 ); + + template + -unspecified-return-type- + rot\_mat\_xyz( Angle x1, Angle y2, Angle z3 ); + + template + -unspecified-return-type- + rot\_mat\_yxz( Angle y1, Angle x2, Angle z3 ); + + template + -unspecified-return-type- + rot\_mat\_yzx( Angle y1, Angle z2, Angle x3 ); + + template + -unspecified-return-type- + rot\_mat\_zyx( Angle z1, Angle y2, Angle x3 ); + + template + -unspecified-return-type- + rot\_mat\_zxy( Angle z1, Angle x2, Angle y3 ); + + template + -unspecified-return-type- + rot\_mat\_xzx( Angle x1, Angle z2, Angle x3 ); + + template + -unspecified-return-type- + rot\_mat\_xyx( Angle x1, Angle y2, Angle x3 ); + + template + -unspecified-return-type- + rot\_mat\_yxy( Angle y1, Angle x2, Angle y3 ); + + template + -unspecified-return-type- + rot\_mat\_yzy( Angle y1, Angle z2, Angle y3 ); + + template + -unspecified-return-type- + rot\_mat\_zyz( Angle z1, Angle y2, Angle z3 ); + + template + -unspecified-return-type- + rot\_mat\_zxz( Angle z1, Angle y2, Angle z3 ); + +} } +``` + + +Returns: + +A matrix of unspecified type, of `Dim` rows and `Dim` columns parameter, which performs a rotation around the `axis` at `angle` radians, or Tait–Bryan angles (x-y-z, y-z-x, z-x-y, x-z-y, z-y-x, y-x-z), or proper Euler angles (z-x-z, x-y-x, y-z-y, z-y-z, x-z-x, y-x-y). See [Euler angles](https://en.wikipedia.org/wiki/Euler_angles). +Throws: + +In case the axis vector has zero magnitude, throws [`zero_magnitude_error`](#zero_magnitude_error). + + +| | | +| --- | --- | +| | +These functions are not view proxies; they return a temp object. + | + + +--- + +#### `set_rot` / Euler angles +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols && + // is\_vec::value && vec\_traits::dim==3 + template + void set\_rot( A & a, B const & axis, typename vec\_traits::scalar\_type angle ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void set\_rot\_xzy( A & a, Angle x1, Angle z2, Angle y3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void set\_rot\_xyz( A & a, Angle x1, Angle y2, Angle z3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void set\_rot\_yxz( A & a, Angle y1, Angle x2, Angle z3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void set\_rot\_yzx( A & a, Angle y1, Angle z2, Angle x3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void set\_rot\_zyx( A & a, Angle z1, Angle y2, Angle x3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void set\_rot\_zxy( A & a, Angle z1, Angle x2, Angle y3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void set\_rot\_xzx( A & a, Angle x1, Angle z2, Angle x3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void set\_rot\_xyx( A & a, Angle x1, Angle y2, Angle x3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void set\_rot\_yxy( A & a, Angle y1, Angle x2, Angle y3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void set\_rot\_yzy( A & a, Angle y1, Angle z2, Angle y3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void set\_rot\_zyz( A & a, Angle z1, Angle y2, Angle z3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void set\_rot\_zxz( A & a, Angle z1, Angle x2, Angle z3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void set\_rot\_xzy( A & a, Angle x1, Angle z2, Angle y3 ); + +} } +``` + + +Effects: + +Assigns the return value of the corresponding [`rot_mat`](#rot_mat) function to `a`. + +--- + +#### `rotate` / Euler angles +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols && + // is\_vec::value && vec\_traits::dim==3 + template + void rotate( A & a, B const & axis, typename mat\_traits::scalar\_type angle ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void rotate\_xzy( A & a, Angle x1, Angle z2, Angle y3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void rotate\_xyz( A & a, Angle x1, Angle y2, Angle z3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void rotate\_yxz( A & a, Angle y1, Angle x2, Angle z3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void rotate\_yzx( A & a, Angle y1, Angle z2, Angle x3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void rotate\_zyx( A & a, Angle z1, Angle y2, Angle x3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void rotate\_zxy( A & a, Angle z1, Angle x2, Angle y3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void rotate\_xzx( A & a, Angle x1, Angle z2, Angle x3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void rotate\_xyx( A & a, Angle x1, Angle y2, Angle x3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void rotate\_yxy( A & a, Angle y1, Angle x2, Angle y3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void rotate\_yzy( A & a, Angle y1, Angle z2, Angle y3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void rotate\_zyz( A & a, Angle z1, Angle y2, Angle z3 ); + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void rotate\_zxz( A & a, Angle z1, Angle x2, Angle z3 ); + +} } +``` + + +Effects: + +Multiplies the matrix `a` in-place by the return value of the corresponding [`rot_mat`](#rot_mat) function. + +--- + +#### `rotx_mat` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- rotx\_mat( Angle const & angle ); + +} } +``` + + +Returns: + +A [view proxy](#view_proxy) matrix of unspecified type, of `Dim` rows and `Dim` columns and scalar type `Angle`, which performs a rotation around the `X` axis at `angle` radians. + +--- + +#### `set_rotx` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void set\_rotx( A & a, typename mat\_traits::scalar\_type angle ); + +} } +``` + + +Effects: + +As if: + + +``` +assign( + a, + rotx\_mat::rows>(angle)); +``` + + +--- + +#### `rotate_x` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void rotate\_x( A & a, typename mat\_traits::scalar\_type angle ); + +} } +``` + + +Effects: + +As if: `a [\*=](#mat_mul_eq) [rotx\_mat](#rotx_mat)<[mat\_traits::rows](#mat_traits)>(angle)`. + +--- + +#### `roty_mat` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- roty\_mat( Angle const & angle ); + +} } +``` + + +Returns: + +A [view proxy](#view_proxy) matrix of unspecified type, of `Dim` rows and `Dim` columns and scalar type `Angle`, which performs a rotation around the `Y` axis at `angle` radians. + +--- + +#### `set_roty` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void set\_roty( A & a, typename mat\_traits::scalar\_type angle ); + +} } +``` + + +Effects: + +As if: + + +``` +assign( + a, + roty\_mat::rows>(angle)); +``` + + +--- + +#### `rotate_y` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void rotate\_y( A & a, typename mat\_traits::scalar\_type angle ); + +} } +``` + + +Effects: + +As if: `a [\*=](#mat_mul_eq) [roty\_mat](#roty_mat)<[mat\_traits::rows](#mat_traits)>(angle)`. + +--- + +#### `rotz_mat` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- rotz\_mat( Angle const & angle ); + +} } +``` + + +Returns: + +A [view proxy](#view_proxy) matrix of unspecified type, of `Dim` rows and `Dim` columns and scalar type `Angle`, which performs a rotation around the `Z` axis at `angle` radians. + +--- + +#### `set_rotz` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void set\_rotz( A & a, typename mat\_traits::scalar\_type angle ); + +} } +``` + + +Effects: + +As if: + + +``` +assign( + a, + rotz\_mat::rows>(angle)); +``` + + +--- + +#### `rotate_z` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && mat\_traits::rows>=3 && + // mat\_traits::rows==mat\_traits::cols + template + void rotate\_z( A & a, typename mat\_traits::scalar\_type angle ); + +} } +``` + + +Effects: + +As if: `a [\*=](#mat_mul_eq) [rotz\_mat](#rotz_mat)<[mat\_traits::rows](#mat_traits)>(angle)`. + +--- + +#### `determinant` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && mat\_traits::rows==mat\_traits::cols + template + mat\_traits::scalar\_type + determinant( A const & a ); + +} } +``` + +This function computes the [determinant](https://en.wikipedia.org/wiki/Determinant) of the square matrix `a`. + + +--- + +#### `perspective_lh` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- + perspective\_lh( T fov\_y, T aspect, T zn, T zf ); + +} } +``` + + +Returns: + +A 4x4 projection matrix of unspecified type of the following form: + + + +| `xs` | 0 | 0 | 0 | +| 0 | `ys` | 0 | 0 | +| 0 | 0 | `zf`/(`zf`-`zn`) | -`zn`\*`zf`/(`zf`-`zn`) | +| 0 | 0 | 1 | 0 | +where `ys` = cot(`fov_y`/2) and `xs` = `ys`/`aspect`. + + +--- + +#### `perspective_rh` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- + perspective\_rh( T fov\_y, T aspect, T zn, T zf ); + +} } +``` + + +Returns: + +A 4x4 projection matrix of unspecified type of the following form: + + + +| `xs` | 0 | 0 | 0 | +| 0 | `ys` | 0 | 0 | +| 0 | 0 | `zf`/(`zn`-`zf`) | `zn`\*`zf`/(`zn`-`zf`) | +| 0 | 0 | -1 | 0 | +where `ys` = cot(`fov_y`/2), and `xs` = `ys`/`aspect`. + + +--- + +#### `scalar_cast` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_mat::value + template + -unspecified-return\_type- scalar\_cast( A const & a ); + +} } +``` + + +Returns: + +A read-only [view proxy](#view_proxy) of `a` that looks like a matrix of the same dimensions as `a`, but with [`scalar_type`](#mat_traits) `Scalar` and elements constructed from the corresponding elements of `a`. + +--- + +#### `mref` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_mat::value + template + -unspecified-return-type- mref( A & a ); + +} } +``` + + +Returns: + +An identity view proxy of `a`; that is, it simply accesses the elements of `a`. + + +| | | +| --- | --- | +| | `mref` allows calling QVM operations when `a` is of built-in type, for example a plain old C array. + | + + +--- + + +### Quaternion-Vector Operations +#### `operator*` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_quat::value && is\_vec::value && + // is\_vec::value && vec\_traits::dim==3 + template + typename deduce\_vec2::rows>::type + operator\*( A const & a, B const & b ); + +} } +``` + + +Returns: + +The result of transforming the vector `b` by the quaternion `a`. + + +| | | +| --- | --- | +| | +The [`deduce_vec2`](#deduce_vec2) template can be specialized to deduce the desired return type, given the types `A` and `B`. + | + + +--- + + +### Matrix-Vector Operations +#### `operator*` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && is\_vec::value && + // mat\_traits::cols==vec\_traits::dim + template + typename deduce\_vec2::rows>::type + operator\*( A const & a, B const & b ); + +} } +``` + + +Returns: + +The result of multiplying the matrix `a` and the vector `b`, where `b` is interpreted as a matrix-column. The resulting matrix-row is returned as a vector type. + + +| | | +| --- | --- | +| | +The [`deduce_vec2`](#deduce_vec2) template can be specialized to deduce the desired return type, given the types `A` and `B`. + | + + +--- + +#### `transform_vector` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && is\_vec::value && + // mat\_traits::rows==4 && mat\_traits::cols==4 && + // vec\_traits::dim==3 + template + deduce\_vec2 >::type + transform\_vector( A const & a, B const & b ); + +} } +``` + + +Effects: + +As if: `return a [\*](#mat_vec_mul) [XYZ0](#swizzling)(b)`. + +--- + +#### `transform_point` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && is\_vec::value && + // mat\_traits::rows==4 && mat\_traits::cols==4 && + // vec\_traits::dim==3 + template + deduce\_vec2 >::type + transform\_point( A const & a, B const & b ); + +} } +``` + + +Effects: + +As if: `return a [\*](#mat_vec_mul) [XYZ1](#swizzling)(b)`. + +--- + + +### Matrix-to-Matrix View Proxies +#### `del_row` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- del\_row(); + +} } +``` + +The expression `del_row(m)` returns an lvalue [view proxy](#view_proxy) that looks like the matrix `m` with row `R` deleted. + + +--- + +#### `del_col` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- del\_col(); + +} } +``` + +The expression `del_col(m)` returns an lvalue [view proxy](#view_proxy) that looks like the matrix `m` with column `C` deleted. + + +--- + +#### `del_row_col` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- del\_row\_col(); + +} } +``` + +The expression `del_row_col(m)` returns an lvalue [view proxy](#view_proxy) that looks like the matrix `m` with row `R` and column `C` deleted. + + +--- + +#### `neg_row` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- neg\_row(); + +} } +``` + +The expression `neg_row(m)` returns a read-only [view proxy](#view_proxy) that looks like the matrix `m` with row `R` negated. + + +--- + +#### `neg_col` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- neg\_col(); + +} } +``` + + + +``` +The expression `neg\_col(m)` returns a read-only <> that looks like the matrix `m` with column `C` negated. +``` + + +--- + +#### `swap_rows` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- swap\_rows(); + +} } +``` + +The expression `swap_rows(m)` returns an lvalue [view proxy](#view_proxy) that looks like the matrix `m` with rows `R1` and `R2` swapped. + + +--- + +#### `swap_cols` +#include + + +``` +namespace boost { namespace qvm { + + template + -unspecified-return-type- swap\_cols(); + +} } +``` + +The expression `swap_cols(m)` returns an lvalue [view proxy](#view_proxy) that looks like the matrix `m` with columns `C1` and `C2` swapped. + + +--- + +#### `transposed` +#include + + +``` +namespace boost { namespace qvm { + + -unspecified-return-type- transposed(); + +} } +``` + +The expression `transposed(m)` returns an lvalue [view proxy](#view_proxy) that transposes the matrix `m`. + + +--- + + +### Vector-to-Matrix View Proxies +#### `col_mat` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_vec::value + template + -unspecified-return-type- col\_mat( A & a ); + +} } +``` + +The expression `col_mat(v)` returns an lvalue [view proxy](#view_proxy) that accesses the vector `v` as a matrix-column. + + +--- + +#### `row_mat` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_vec::value + template + -unspecified-return-type- row\_mat( A & a ); + +} } +``` + +The expression `row_mat(v)` returns an lvalue [view proxy](#view_proxy) that accesses the vector `v` as a matrix-row. + + +--- + +#### `translation_mat` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_vec::value + template + -unspecified-return-type- translation\_mat( A & a ); + +} } +``` + +The expression `translation_mat(v)` returns an lvalue [view proxy](#view_proxy) that accesses the vector `v` as translation matrix of size 1 + [`vec_traits::dim`](#vec_traits). + + +--- + +#### `diag_mat` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_vec::value + template + -unspecified-return-type- diag\_mat( A & a ); + +} } +``` + +The expression `diag_mat(v)` returns an lvalue [view proxy](#view_proxy) that accesses the vector `v` as a square matrix of the same dimensions in which the elements of `v` appear as the main diagonal and all other elements are zero. + + + +| | | +| --- | --- | +| | +If `v` is a 3D vector, the expression `diag_mat(XYZ1(v))` can be used as a scaling 4D matrix. + | + + +--- + + +### Matrix-to-Vector View Proxies +#### `col` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_mat::value + template + -unspecified-return-type- col( A & a ); + +} } +``` + +The expression `col(m)` returns an lvalue [view proxy](#view_proxy) that accesses column `C` of the matrix `m` as a vector. + + +--- + +#### `row` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_mat::value + template + -unspecified-return-type- row( A & a ); + +} } +``` + +The expression `row(m)` returns an lvalue [view proxy](#view_proxy) that accesses row `R` of the matrix `m` as a vector. + + +--- + +#### `diag` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: is\_mat::value + template + -unspecified-return-type- diag( A & a ); + +} } +``` + +The expression `diag(m)` returns an lvalue [view proxy](#view_proxy) that accesses the main diagonal of the matrix `m` as a vector. + + +--- + +#### `translation` +#include + + +``` +namespace boost { namespace qvm { + + //Only enabled if: + // is\_mat::value && + // mat\_traits::rows==mat\_traits::cols && mat\_traits::rows>=3 + template + -unspecified-return-type- translation( A & a ); + +} } +``` + +The expression `translation(m)` returns an lvalue [view proxy](#view_proxy) that accesses the translation component of the square matrix `m`, which is a vector of size `D`-1, where `D` is the size of `m`. + + +--- + + +### Exceptions +#### `error` +#include + + +``` +namespace boost { namespace qvm { + + struct error: virtual boost::exception, virtual std::exception { }; + +} } +``` + +This is the base for all exceptions thorwn by QVM. + + +--- + +#### `zero_magnitude_error` +#include + + +``` +namespace boost { namespace qvm { + + struct zero\_magnitude\_error: virtual error { }; + +} } +``` + +This exception indicates that an operation requires a vector or a quaternion with non-zero magnitude, but the computed magnitude is zero. + + +--- + +#### `zero_determinant_error` +#include + + +``` +namespace boost { namespace qvm { + + struct zero\_determinant\_error: virtual error { }; + +} } +``` + +This exception indicates that an operation requires a matrix with non-zero determinant, but the computed determinant is zero. + + +--- + + +### Macros and Configuration: BOOST\_QVM\_ +#### `INLINE` +##### `BOOST_QVM_INLINE` +#include + + +``` +namespace boost { namespace qvm { + + #ifndef BOOST\_QVM\_INLINE + #define BOOST\_QVM\_INLINE inline + #endif + +} } +``` + +This macro is not used directly by QVM, except as the default value of other macros from ``. A user-defined `BOOST_QVM_INLINE` should expand to a value that is valid substitution of the `inline` keyword in function definitions. + + +--- + + +#### `FORCE_INLINE` +##### `BOOST_QVM_FORCE_INLINE` +#include + + +``` +namespace boost { namespace qvm { + + #ifndef BOOST\_QVM\_FORCE\_INLINE + #define BOOST\_QVM\_FORCE\_INLINE /\*platform-specific\*/ + #endif + +} } +``` + +This macro is not used directly by QVM, except as the default value of other macros from ``. A user-defined `BOOST_QVM_FORCE_INLINE` should expand to a value that is valid substitution of the `inline` keyword in function definitions, to indicate that the compiler must inline the function. Of course, actual inlining may or may not occur. + + +--- + + +#### `INLINE_TRIVIAL` +##### `BOOST_QVM_INLINE_TRIVIAL` +#include + + +``` +namespace boost { namespace qvm { + + #ifndef BOOST\_QVM\_INLINE\_TRIVIAL + #define BOOST\_QVM\_INLINE\_TRIVIAL BOOST\_QVM\_FORCE\_INLINE + #endif + +} } +``` + +QVM uses `BOOST_QVM_INLINE_TRIVIAL` in definitions of functions that are not critical for the overall performance of the library but are extremely simple (such as one-liners) and therefore should always be inlined. + + +--- + + +#### `INLINE_CRITICAL` +##### `BOOST_QVM_INLINE_CRITICAL` +#include + + +``` +namespace boost { namespace qvm { + + #ifndef BOOST\_QVM\_INLINE\_CRITICAL + #define BOOST\_QVM\_INLINE\_CRITICAL BOOST\_QVM\_FORCE\_INLINE + #endif + +} } +``` + +QVM uses `BOOST_QVM_INLINE_CRITICAL` in definitions of functions that are critical for the overall performance of the library, such as functions that access individual vector and matrix elements. + + +--- + + +#### `INLINE_OPERATIONS` +##### `BOOST_QVM_INLINE_OPERATIONS` +#include + + +``` +namespace boost { namespace qvm { + + #ifndef BOOST\_QVM\_INLINE\_OPERATIONS + #define BOOST\_QVM\_INLINE\_OPERATIONS BOOST\_QVM\_INLINE + #endif + +} } +``` + +QVM uses `BOOST_QVM_INLINE_OPERATIONS` in definitions of functions that implement various high-level operations, such as matrix multiplication, computing the magnitude of a vector, etc. + + +--- + + +#### `INLINE_RECURSION` +##### `BOOST_QVM_INLINE_RECURSION` +#include + + +``` +namespace boost { namespace qvm { + + #ifndef BOOST\_QVM\_INLINE\_RECURSION + #define BOOST\_QVM\_INLINE\_RECURSION BOOST\_QVM\_INLINE\_OPERATIONS + #endif + +} } +``` + +QVM uses `BOOST_QVM_INLINE_RECURSION` in definitions of recursive functions that are not critical for the overall performance of the library (definitions of all critical functions, including critical recursive functions, use [`BOOST_QVM_INLINE_CRITICAL`](#BOOST_QVM_INLINE_CRITICAL)). + + +--- + + +#### `ASSERT` +##### `BOOST_QVM_ASSERT` +#include + + +``` +namespace boost { namespace qvm { + +#ifndef BOOST\_QVM\_ASSERT +#include +#define BOOST\_QVM\_ASSERT BOOST\_ASSERT +#endif + +} } +``` + +This is the macro QVM uses to assert on precondition violations and logic errors. A user-defined `BOOST_QVM_ASSERT` should have the semantics of the standard `assert`. + + +--- + + +#### `STATIC_ASSERT` +##### `BOOST_QVM_STATIC_ASSERT` +#include + + +``` +namespace boost { namespace qvm { + + #ifndef BOOST\_QVM\_STATIC\_ASSERT + #include + #define BOOST\_QVM\_STATIC\_ASSERT BOOST\_STATIC\_ASSERT + #endif + +} } +``` + +All static assertions in QVM use the `BOOST_QVM_STATIC_ASSERT` macro. + + +--- + + +#### `THROW_EXCEPTION` +##### `BOOST_QVM_THROW_EXCEPTION` +#include + + +``` +namespace boost { namespace qvm { + + #ifndef BOOST\_QVM\_THROW\_EXCEPTION + #include + #define BOOST\_QVM\_THROW\_EXCEPTION BOOST\_THROW\_EXCEPTION + #endif + +} } +``` + +This macro is used whenever QVM throws an exception. Users who override the standard `BOOST_QVM_THROW_EXCEPTION` behavior must ensure that when invoked, the substituted implementation does not return control to the caller. Below is a list of all QVM functions that invoke `BOOST_QVM_THROW_EXCEPTION`: + +* Quaternion operations: + + + [`inverse`](#quat_inverse) + + [`rot_quat`](#rot_quat) + + [`normalize`](#quat_normalize) + + [`normalized`](#quat_normalized) +* Vector operations: + + + [`normalize`](#vec_normalize) + + [`normalized`](#vec_normalized) +* Matrix operations: + + + [`inverse`](#mat_inverse) + + [`rot_mat`](#rot_mat) + + + +Design Rationale +---------------- + +C++ is ideal for 3D graphics and other domains that require 3D transformations: define vector and matrix types and then overload the appropriate operators to implement the standard algebraic operations. Because this is relatively straight-forward, there are many libraries that do this, each providing custom vector and matrix types, and then defining the same operations (e.g. matrix multiply) for these types. + +Often these libraries are part of a higher level system. For example, video game programmers typically use one set of vector/matrix types with the rendering engine, and another with the physics simulation engine. + +QVM proides interoperability between all these different types and APIs by decoupling the standard algebraic functions from the types they operate on — without compromising type safety. The operations work on any type for which proper traits have been specialized. Using QVM, there is no need to translate between the different quaternion, vector or matrix types; they can be mixed in the same expression safely and efficiently. + +This design enables QVM to generate types and adaptors at compile time, compatible with any other QVM or user-defined type. For example, transposing a matrix needs not store the result: rather than modifying its argument or returning a new object, it simply binds the original matrix object through a generated type which remaps element access on the fly. + +In addition, QVM can be helpful in selectively optimizing individual types or operations for maximum performance where that matters. For example, users can overload a specific operation for specific types, or define highly optimized, possibly platform-specific or for some reason cumbersome to use types, then mix and match them with more user-friendly types in parts of the program where performance isn’t critical. + + + +Code Generator +-------------- + +While QVM defines generic functions that operate on matrix and vector types of arbitrary static dimensions, it also provides a code generator that can be used to create compatible header files that define much simpler specializations of these functions for specific dimensions. This is useful during debugging since the generated code is much easier to read than the template metaprogramming-heavy generic implementations. It is also potentially friendlier to the optimizer. + +The code generator is a command-line utility program. Its source code can be found in the `boost/libs/qvm/gen` directory. It was used to generate the following headers that ship with QVM: + +* 2D, 3D and 4D matrix operations: + + + `boost/qvm/gen/mat_operations2.hpp` (matrices of size 2x2, 2x1 and 1x2, included by `boost/qvm/mat_operations2.hpp`) + + `boost/qvm/gen/mat_operations3.hpp` (matrices of size 3x3, 3x1 and 1x3, included by `boost/qvm/mat_operations3.hpp`) + + `boost/qvm/gen/mat_operations4.hpp` (matrices of size 4x4, 4x1 and 1x4, included by `boost/qvm/mat_operations4.hpp`) +* 2D, 3D and 4D vector operations: + + + `boost/qvm/gen/v2.hpp` (included by `boost/qvm/vec_operations2.hpp`) + + `boost/qvm/gen/v3.hpp` (included by `boost/qvm/vec_operations3.hpp`) + + `boost/qvm/gen/v4.hpp` (included by `boost/qvm/vec_operations4.hpp`) +* 2D, 3D and 4D vector-matrix operations: + + + `boost/qvm/gen/vm2.hpp` (included by `boost/qvm/vec_mat_operations2.hpp`) + + `boost/qvm/gen/vm3.hpp` (included by `boost/qvm/vec_mat_operations3.hpp`) + + `boost/qvm/gen/vm4.hpp` (included by `boost/qvm/vec_mat_operations4.hpp`) +* 2D, 3D and 4D vector swizzling operations: + + + `boost/qvm/gen/sw2.hpp` (included by `boost/qvm/swizzle2.hpp`) + + `boost/qvm/gen/sw3.hpp` (included by `boost/qvm/swizzle3.hpp`) + + `boost/qvm/gen/sw4.hpp` (included by `boost/qvm/swizzle4.hpp`) + +Any such generated headers must be included before the corresponding generic header file is included. For example, if one creates a header `boost/qvm/gen/m5.hpp`, it must be included before `boost/qvm/mat_operations.hpp` in included. However, the generic headers (`boost/qvm/mat_operations.hpp`, `boost/qvm/vec_operations.hpp`, `boost/qvm/vec_mat_operations.hpp` and `boost/qvm/swizzle.hpp`) already include the generated headers from the list above, so the generated headers don’t need to be included manually. + + + +| | | +| --- | --- | +| | +headers under `boost/qvm/gen` are not part of the public interface of QVM. For example, `boost/qvm/gen/mat_operations2.hpp` should not be included directly; `#include ` instead. + | + + + +Known Quirks and Issues +----------------------- + +### Capturing View Proxies with `auto` +By design, [view proxies](#view_proxy) must not return temporary objects. They return reference to an argument they take by (`const`) reference, cast to reference of unspecified type that is not copyable. Because of this, the return value of a view proxy can not be captured by value with `auto`: + + + +``` +auto tr = transposed(m); //Error: the return type of transposed can not be copied. +``` + +The correct use of auto with view proxies is: + + + +``` +auto & tr = transposed(m); +``` + + + +| | | +| --- | --- | +| | +Many view proxies are not read-only, that is, they’re lvalues; changes made on the view proxy operate on the original object. This is another reason why they can not be captured by value with `auto`. + | + + +--- + +### Binding QVM Overloads From an Unrelated Namespace +The operator overloads in namespace `boost::qvm` are designed to work with user-defined types. Typically it is sufficient to make these operators available in the namespace where the operator is used, by `using namespace boost::qvm`. A problem arises if the scope that uses the operator is not controlled by the user. For example: + + + +``` +namespace ns1 { + + struct float2 { float x, y; }; + +} + +namespace ns2 { + + using namespace boost::qvm; + + void f() { + ns1::float2 a, b; + a==b; //OK + ns1::float2 arr1[2], arr2[2]; + std::equal(arr1,arr1+2,arr2); //Error: operator== is inaccessible from namespace std + } + +} +``` + +In the `std::equal` expression above, even though `boost::qvm::operator==` is made visible in namespace `ns2` by `using namespace boost::qvm`, the call originates from namespace `std`. In this case the compiler can’t bind `boost::qvm::operator==` because only namespace `ns1` is visible through ADL, and it does not contain a suitable declaration. The solution is to declare `operator==` in namespace ns1, which can be done like this: + + + +``` +namespace ns1 { + + using boost::qvm::operator==; + +} +``` + + +--- + +### Link Errors When Calling Math Functions with `int` Arguments +QVM does not call standard math functions (e.g. sin, cos, etc.) directly. Instead, it calls function templates declared in `boost/qvm/math.hpp` in namespace `boost::qvm`. This allows the user to specialize these templates for user-defined scalar types. + +QVM itself defines specializations of the math function templates only for `float` and `double`, but it does not provide generic definitions. This is done to protect the user from unintentionally writing code that binds standard math functions that take `double` when passing arguments of lesser types, which would be suboptimal. + +Because of this, a call to e.g. `[rot\_mat](#rot_mat)(axis,1)` will compile successfully but fail to link, since it calls e.g. `boost::qvm::sin`, which is undefined. Because rotations by integer number of radians are rarely needed, in QVM there is no protection against such errors. In such cases the solution is to use `rot_mat(axis,1.0f)` instead. + +Q&A +--- + +1. *What is the motivation behind QVM? Why not just use uBLAS/Eigen/CML/GLM/etc?* + + +The primary domain of QVM is realtime graphics and simulation applications, so it is not a complete linear algebra library. While (naturally) there is some overlap with such libraries, QVM puts the emphasis on 2, 3 and 4 dimensional zero-overhead operations (hence domain-specific features like Swizzling). +2. *How does the `qvm::[vec](#vec)` (or `qvm::[mat](#mat)`, or `qvm::[quat](#quat)`) template compare to vector types from other libraries?* + + +The `qvm::vec` template is not in any way central to the vector operations defined by QVM. The operations are designed to work with any user-defined vector type or with 3rd-party vector types (e.g. `D3DVECTOR`), while the `qvm::vec` template is simply a default return type for expressions that use arguments of different types that would be incompatible outside of QVM. For example, if the [`deduce_mat2`](#deduce_mat2) hasn’t been specialized, calling [`cross`](#cross) with a user-defined type `vec3` and a user-defined type `float3` returns a `qvm::vec`. +3. *Why doesn’t QVM use [] or () to access vector and matrix elements?* + + +Because it’s designed to work with user-defined types, and the C++ standard requires these operators to be members. Of course if a user-defined type defines `operator[]` or `operator()` they are available for use with other QVM functions, but QVM defines its own mechanisms for [accessing quaternion elements](#quat_access), [accessing vector elements](#vec_access) (as well as [swizzling](#swizzling)), and [accessing matrix elements](#mat_access). + + +--- +Documentation rendered by [Asciidoctor](https://asciidoctor.org/) with [these customizations](https://github.com/zajo/asciidoctor_skin). + +© 2008-2020 Emil Dotchevski and Reverge Studios, Inc. + + diff --git a/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BA_idm35151229096240.html b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BA_idm35151229096240.html new file mode 100644 index 0000000..1963a3b --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BA_idm35151229096240.html @@ -0,0 +1,42 @@ +--- +title: Macro BOOST_BASE_FROM_MEMBER_MAX_ARITY +copyright: +revised: +--- + + +Macro BOOST\_BASE\_FROM\_MEMBER\_MAX\_ARITY + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../index.html) | [Libraries](../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../more/index.htm) | + +--- +[![Prev](../../../../doc/src/images/prev.png)](boost/base_fro_idm35151229100080.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/base_from_member.html#header.boost.utility.base_from_member_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](utility/utilities/binary_integer_literals.html) + +Macro BOOST\_BASE\_FROM\_MEMBER\_MAX\_ARITY +------------------------------------------- + + +BOOST\_BASE\_FROM\_MEMBER\_MAX\_ARITY +Synopsis +-------- +``` +// In header: <[boost/utility/base\_from\_member.hpp](utility/utilities/base_from_member.html#header.boost.utility.base_from_member_hpp "Header ")> + +BOOST\_BASE\_FROM\_MEMBER\_MAX\_ARITY +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../doc/src/images/prev.png)](boost/base_fro_idm35151229100080.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/base_from_member.html#header.boost.utility.base_from_member_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](utility/utilities/binary_integer_literals.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY.html b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY.html new file mode 100644 index 0000000..9baac23 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY.html @@ -0,0 +1,42 @@ +--- +title: Macro BOOST_BINARY +copyright: +revised: +--- + + +Macro BOOST\_BINARY + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../index.html) | [Libraries](../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../more/index.htm) | + +--- +[![Prev](../../../../doc/src/images/prev.png)](utility/utilities/binary_integer_literals.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_BINARY_U.html) + +Macro BOOST\_BINARY +------------------- + + +BOOST\_BINARY +Synopsis +-------- +``` +// In header: <[boost/utility/binary.hpp](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp "Header ")> + +BOOST\_BINARY(bit\_groupings) +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../doc/src/images/prev.png)](utility/utilities/binary_integer_literals.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_BINARY_U.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_L.html b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_L.html new file mode 100644 index 0000000..d8d246d --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_L.html @@ -0,0 +1,42 @@ +--- +title: Macro BOOST_BINARY_L +copyright: +revised: +--- + + +Macro BOOST\_BINARY\_L + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../index.html) | [Libraries](../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../more/index.htm) | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_BINARY_U.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_BINARY_UL.html) + +Macro BOOST\_BINARY\_L +---------------------- + + +BOOST\_BINARY\_L +Synopsis +-------- +``` +// In header: <[boost/utility/binary.hpp](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp "Header ")> + +BOOST\_BINARY\_L(bit\_groupings) +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_BINARY_U.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_BINARY_UL.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_LITERAL_D.html b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_LITERAL_D.html new file mode 100644 index 0000000..42ca003 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_LITERAL_D.html @@ -0,0 +1,42 @@ +--- +title: Macro BOOST_BINARY_LITERAL_D +copyright: +revised: +--- + + +Macro BOOST\_BINARY\_LITERAL\_D + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../index.html) | [Libraries](../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../more/index.htm) | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_SU_idm35151229112752.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](utility/utilities/call_traits.html) + +Macro BOOST\_BINARY\_LITERAL\_D +------------------------------- + + +BOOST\_BINARY\_LITERAL\_D +Synopsis +-------- +``` +// In header: <[boost/utility/binary.hpp](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp "Header ")> + +BOOST\_BINARY\_LITERAL\_D(d, bit\_groupings) +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_SU_idm35151229112752.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](utility/utilities/call_traits.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_LL.html b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_LL.html new file mode 100644 index 0000000..80a0a9c --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_LL.html @@ -0,0 +1,42 @@ +--- +title: Macro BOOST_BINARY_LL +copyright: +revised: +--- + + +Macro BOOST\_BINARY\_LL + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../index.html) | [Libraries](../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../more/index.htm) | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_BINARY_LU.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_BINARY_ULL.html) + +Macro BOOST\_BINARY\_LL +----------------------- + + +BOOST\_BINARY\_LL +Synopsis +-------- +``` +// In header: <[boost/utility/binary.hpp](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp "Header ")> + +BOOST\_BINARY\_LL(bit\_groupings) +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_BINARY_LU.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_BINARY_ULL.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_LLU.html b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_LLU.html new file mode 100644 index 0000000..d28e9e9 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_LLU.html @@ -0,0 +1,42 @@ +--- +title: Macro BOOST_BINARY_LLU +copyright: +revised: +--- + + +Macro BOOST\_BINARY\_LLU + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../index.html) | [Libraries](../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../more/index.htm) | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_BINARY_ULL.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_SU_idm35151229114032.html) + +Macro BOOST\_BINARY\_LLU +------------------------ + + +BOOST\_BINARY\_LLU +Synopsis +-------- +``` +// In header: <[boost/utility/binary.hpp](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp "Header ")> + +BOOST\_BINARY\_LLU(bit\_groupings) +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_BINARY_ULL.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_SU_idm35151229114032.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_LU.html b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_LU.html new file mode 100644 index 0000000..35dd3f4 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_LU.html @@ -0,0 +1,42 @@ +--- +title: Macro BOOST_BINARY_LU +copyright: +revised: +--- + + +Macro BOOST\_BINARY\_LU + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../index.html) | [Libraries](../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../more/index.htm) | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_BINARY_UL.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_BINARY_LL.html) + +Macro BOOST\_BINARY\_LU +----------------------- + + +BOOST\_BINARY\_LU +Synopsis +-------- +``` +// In header: <[boost/utility/binary.hpp](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp "Header ")> + +BOOST\_BINARY\_LU(bit\_groupings) +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_BINARY_UL.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_BINARY_LL.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_U.html b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_U.html new file mode 100644 index 0000000..6090d47 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_U.html @@ -0,0 +1,42 @@ +--- +title: Macro BOOST_BINARY_U +copyright: +revised: +--- + + +Macro BOOST\_BINARY\_U + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../index.html) | [Libraries](../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../more/index.htm) | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_BINARY.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_BINARY_L.html) + +Macro BOOST\_BINARY\_U +---------------------- + + +BOOST\_BINARY\_U +Synopsis +-------- +``` +// In header: <[boost/utility/binary.hpp](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp "Header ")> + +BOOST\_BINARY\_U(bit\_groupings) +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_BINARY.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_BINARY_L.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_UL.html b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_UL.html new file mode 100644 index 0000000..349c19c --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_UL.html @@ -0,0 +1,42 @@ +--- +title: Macro BOOST_BINARY_UL +copyright: +revised: +--- + + +Macro BOOST\_BINARY\_UL + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../index.html) | [Libraries](../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../more/index.htm) | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_BINARY_L.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_BINARY_LU.html) + +Macro BOOST\_BINARY\_UL +----------------------- + + +BOOST\_BINARY\_UL +Synopsis +-------- +``` +// In header: <[boost/utility/binary.hpp](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp "Header ")> + +BOOST\_BINARY\_UL(bit\_groupings) +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_BINARY_L.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_BINARY_LU.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_ULL.html b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_ULL.html new file mode 100644 index 0000000..3b5333d --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_BINARY_ULL.html @@ -0,0 +1,42 @@ +--- +title: Macro BOOST_BINARY_ULL +copyright: +revised: +--- + + +Macro BOOST\_BINARY\_ULL + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../index.html) | [Libraries](../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../more/index.htm) | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_BINARY_LL.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_BINARY_LLU.html) + +Macro BOOST\_BINARY\_ULL +------------------------ + + +BOOST\_BINARY\_ULL +Synopsis +-------- +``` +// In header: <[boost/utility/binary.hpp](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp "Header ")> + +BOOST\_BINARY\_ULL(bit\_groupings) +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_BINARY_LL.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_BINARY_LLU.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/BOOST_SU_idm35151229112752.html b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_SU_idm35151229112752.html new file mode 100644 index 0000000..5edee04 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_SU_idm35151229112752.html @@ -0,0 +1,42 @@ +--- +title: Macro BOOST_SUFFIXED_BINARY_LITERAL_D +copyright: +revised: +--- + + +Macro BOOST\_SUFFIXED\_BINARY\_LITERAL\_D + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../index.html) | [Libraries](../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../more/index.htm) | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_SU_idm35151229114032.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_BINARY_LITERAL_D.html) + +Macro BOOST\_SUFFIXED\_BINARY\_LITERAL\_D +----------------------------------------- + + +BOOST\_SUFFIXED\_BINARY\_LITERAL\_D +Synopsis +-------- +``` +// In header: <[boost/utility/binary.hpp](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp "Header ")> + +BOOST\_SUFFIXED\_BINARY\_LITERAL\_D(d, bit\_groupings, suffix) +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_SU_idm35151229114032.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_BINARY_LITERAL_D.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/BOOST_SU_idm35151229114032.html b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_SU_idm35151229114032.html new file mode 100644 index 0000000..08c522d --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/BOOST_SU_idm35151229114032.html @@ -0,0 +1,42 @@ +--- +title: Macro BOOST_SUFFIXED_BINARY_LITERAL +copyright: +revised: +--- + + +Macro BOOST\_SUFFIXED\_BINARY\_LITERAL + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../index.html) | [Libraries](../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../more/index.htm) | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_BINARY_LLU.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_SU_idm35151229112752.html) + +Macro BOOST\_SUFFIXED\_BINARY\_LITERAL +-------------------------------------- + + +BOOST\_SUFFIXED\_BINARY\_LITERAL +Synopsis +-------- +``` +// In header: <[boost/utility/binary.hpp](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp "Header ")> + +BOOST\_SUFFIXED\_BINARY\_LITERAL(bit\_groupings, suffix) +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../doc/src/images/prev.png)](BOOST_BINARY_LLU.html)[![Up](../../../../doc/src/images/up.png)](utility/utilities/binary_integer_literals.html#header.boost.utility.binary_hpp)[![Home](../../../../doc/src/images/home.png)](index.html)[![Next](../../../../doc/src/images/next.png)](BOOST_SU_idm35151229112752.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/boost/base_fro_idm35151229100080.html b/doc/libs/1_78_0/libs/utility/doc/html/boost/base_fro_idm35151229100080.html new file mode 100644 index 0000000..c8169f1 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/boost/base_fro_idm35151229100080.html @@ -0,0 +1,62 @@ +--- +title: Class template base_from_member +copyright: +revised: +--- + + +Class template base\_from\_member + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](base_from_member.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/base_from_member.html#header.boost.utility.base_from_member_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](../BOOST_BA_idm35151229096240.html) + +Class template base\_from\_member +--------------------------------------------------------- + + +boost::base\_from\_member +Synopsis +-------- +``` +// In header: <[boost/utility/base\_from\_member.hpp](../utility/utilities/base_from_member.html#header.boost.utility.base_from_member_hpp "Header ")> + +template +class [base\_from\_member](base_fro_idm35151229100080.html "Class template base_from_member") { +public: + // [construct/copy/destruct](base_fro_idm35151229100080.html#boost.base_fro_idm35151229100080construct-copy-destruct) + explicit [base\_from\_member](base_fro_idm35151229100080.html#idm35151229097392-bb)(MemberType &) noexcept; +}; +``` + + +Description +----------- +### +`base_from_member` + public + construct/copy/destruct + + +1. ``` +explicit base\_from\_member(MemberType & x) noexcept; +``` + + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](base_from_member.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/base_from_member.html#header.boost.utility.base_from_member_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](../BOOST_BA_idm35151229096240.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/boost/base_from_member.html b/doc/libs/1_78_0/libs/utility/doc/html/boost/base_from_member.html new file mode 100644 index 0000000..74b50ab --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/boost/base_from_member.html @@ -0,0 +1,70 @@ +--- +title: Class template base_from_member +copyright: +revised: +--- + + +Class template base\_from\_member + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../utility/utilities/base_from_member.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/base_from_member.html#header.boost.utility.base_from_member_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](base_fro_idm35151229100080.html) + +Class template base\_from\_member +--------------------------------- + + +boost::base\_from\_member +Synopsis +-------- +``` +// In header: <[boost/utility/base\_from\_member.hpp](../utility/utilities/base_from_member.html#header.boost.utility.base_from_member_hpp "Header ")> + +template +class [base\_from\_member](base_from_member.html "Class template base_from_member") { +public: + // [construct/copy/destruct](base_from_member.html#boost.base_from_memberconstruct-copy-destruct) + template::type> + explicit [base\_from\_member](base_from_member.html#idm35151229103152-bb)(T &&...) noexcept(noexcept((::new((void \*) 0) MemberType(static\_cast< T && >(x)...))))); +}; +``` + + +Description +----------- +### +`base_from_member` + public + construct/copy/destruct + + +1. ``` +template::type> + explicit base\_from\_member(T &&... x) noexcept(noexcept((::new((void \*) 0) MemberType(static\_cast< T && >(x)...))))); +``` +### Specializations + + +* [Class template base\_from\_member](base_fro_idm35151229100080.html "Class template base_from_member") + + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../utility/utilities/base_from_member.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/base_from_member.html#header.boost.utility.base_from_member_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](base_fro_idm35151229100080.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/boost/basic_string_view.html b/doc/libs/1_78_0/libs/utility/doc/html/boost/basic_string_view.html new file mode 100644 index 0000000..38d94ed --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/boost/basic_string_view.html @@ -0,0 +1,406 @@ +--- +title: Class template basic_string_view +copyright: +revised: +--- + + +Class template basic\_string\_view + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../utility/utilities/string_view.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/string_view.html#header.boost.utility.string_view_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](../utility/utilities/value_init.html) + +Class template basic\_string\_view +---------------------------------- + + +boost::basic\_string\_view +Synopsis +-------- +``` +// In header: <[boost/utility/string\_view.hpp](../utility/utilities/string_view.html#header.boost.utility.string_view_hpp "Header ")> + +template +class [basic\_string\_view](basic_string_view.html "Class template basic_string_view") { +public: + // types + typedef traits traits\_type; + typedef charT value\_type; + typedef charT \* pointer; + typedef const charT \* const\_pointer; + typedef charT & reference; + typedef const charT & const\_reference; + typedef const\_pointer const\_iterator; + typedef const\_iterator iterator; + typedef std::reverse\_iterator< const\_iterator > const\_reverse\_iterator; + typedef const\_reverse\_iterator reverse\_iterator; + typedef std::size\_t size\_type; + typedef std::ptrdiff\_t difference\_type; + + // [construct/copy/destruct](basic_string_view.html#boost.basic_string_viewconstruct-copy-destruct) + [basic\_string\_view](basic_string_view.html#idm35151228455472-bb)() noexcept; + [basic\_string\_view](basic_string_view.html#idm35151228455088-bb)(const [basic\_string\_view](basic_string_view.html "Class template basic_string_view") &); + template + [basic\_string\_view](basic_string_view.html#idm35151228452272-bb)(const std::basic\_string< charT, traits, Allocator > &) noexcept; + [basic\_string\_view](basic_string_view.html#idm35151228450736-bb)(const charT \*); + [basic\_string\_view](basic_string_view.html#idm35151228449968-bb)(const charT \*, size\_type); + [basic\_string\_view](basic_string_view.html "Class template basic_string_view") & [operator=](basic_string_view.html#idm35151228453936-bb)(const [basic\_string\_view](basic_string_view.html "Class template basic_string_view") &); + + // [public member functions](basic_string_view.html#idm35151228357424-bb) + constexpr const\_iterator [begin](basic_string_view.html#idm35151228357040-bb)() const noexcept; + constexpr const\_iterator [cbegin](basic_string_view.html#idm35151228356272-bb)() const noexcept; + constexpr const\_iterator [end](basic_string_view.html#idm35151228355504-bb)() const noexcept; + constexpr const\_iterator [cend](basic_string_view.html#idm35151228354736-bb)() const noexcept; + const\_reverse\_iterator [rbegin](basic_string_view.html#idm35151228353968-bb)() const noexcept; + const\_reverse\_iterator [crbegin](basic_string_view.html#idm35151228353200-bb)() const noexcept; + const\_reverse\_iterator [rend](basic_string_view.html#idm35151228352432-bb)() const noexcept; + const\_reverse\_iterator [crend](basic_string_view.html#idm35151228351664-bb)() const noexcept; + constexpr size\_type [size](basic_string_view.html#idm35151228350896-bb)() const noexcept; + constexpr size\_type [length](basic_string_view.html#idm35151228350128-bb)() const noexcept; + constexpr size\_type [max\_size](basic_string_view.html#idm35151228349360-bb)() const noexcept; + constexpr bool [empty](basic_string_view.html#idm35151228348592-bb)() const noexcept; + constexpr const\_reference [operator[]](basic_string_view.html#idm35151228347824-bb)(size\_type) const noexcept; + constexpr const\_reference [at](basic_string_view.html#idm35151228346544-bb)(size\_t) const; + constexpr const\_reference [front](basic_string_view.html#idm35151228345264-bb)() const; + constexpr const\_reference [back](basic_string_view.html#idm35151228344496-bb)() const; + constexpr const\_pointer [data](basic_string_view.html#idm35151228343728-bb)() const noexcept; + void [clear](basic_string_view.html#idm35151228342960-bb)() noexcept; + constexpr void [remove\_prefix](basic_string_view.html#idm35151228342192-bb)(size\_type); + constexpr void [remove\_suffix](basic_string_view.html#idm35151228341040-bb)(size\_type); + constexpr void [swap](basic_string_view.html#idm35151228339888-bb)([basic\_string\_view](basic_string_view.html "Class template basic_string_view") &) noexcept; + template + explicit [operator std::basic\_string< charT, traits, Allocator >](basic_string_view.html#idm35151228338352-bb)() const; + template > + std::basic\_string< charT, traits, Allocator > + [to\_string](basic_string_view.html#idm35151228336816-bb)(const Allocator & = Allocator()) const; + size\_type [copy](basic_string_view.html#idm35151228334384-bb)(charT \*, size\_type, size\_type = 0) const; + constexpr [basic\_string\_view](basic_string_view.html "Class template basic_string_view") [substr](basic_string_view.html#idm35151228331824-bb)(size\_type, size\_type = npos) const; + constexpr int [compare](basic_string_view.html#idm35151228329520-bb)([basic\_string\_view](basic_string_view.html "Class template basic_string_view")) const noexcept; + constexpr int + [compare](basic_string_view.html#idm35151228393648-bb)(size\_type, size\_type, [basic\_string\_view](basic_string_view.html "Class template basic_string_view")) const noexcept; + constexpr int + [compare](basic_string_view.html#idm35151228391216-bb)(size\_type, size\_type, [basic\_string\_view](basic_string_view.html "Class template basic_string_view"), size\_type, size\_type) const; + constexpr int [compare](basic_string_view.html#idm35151228387760-bb)(const charT \*) const; + constexpr int [compare](basic_string_view.html#idm35151228386480-bb)(size\_type, size\_type, const charT \*) const; + constexpr int [compare](basic_string_view.html#idm35151228384176-bb)(size\_type, size\_type, const charT \*, size\_type) const; + constexpr bool [starts\_with](basic_string_view.html#idm35151228381360-bb)(charT) const noexcept; + constexpr bool [starts\_with](basic_string_view.html#idm35151228380080-bb)([basic\_string\_view](basic_string_view.html "Class template basic_string_view")) const noexcept; + constexpr bool [ends\_with](basic_string_view.html#idm35151228378672-bb)(charT) const noexcept; + constexpr bool [ends\_with](basic_string_view.html#idm35151228377392-bb)([basic\_string\_view](basic_string_view.html "Class template basic_string_view")) const noexcept; + constexpr size\_type [find](basic_string_view.html#idm35151228375984-bb)([basic\_string\_view](basic_string_view.html "Class template basic_string_view"), size\_type = 0) const noexcept; + constexpr size\_type [find](basic_string_view.html#idm35151228373808-bb)(charT, size\_type = 0) const noexcept; + constexpr size\_type [find](basic_string_view.html#idm35151228371760-bb)(const charT \*, size\_type, size\_type) const noexcept; + constexpr size\_type [find](basic_string_view.html#idm35151228369456-bb)(const charT \*, size\_type = 0) const noexcept; + constexpr size\_type + [rfind](basic_string_view.html#idm35151228367408-bb)([basic\_string\_view](basic_string_view.html "Class template basic_string_view"), size\_type = npos) const noexcept; + constexpr size\_type [rfind](basic_string_view.html#idm35151228365232-bb)(charT, size\_type = npos) const noexcept; + constexpr size\_type + [rfind](basic_string_view.html#idm35151228363184-bb)(const charT \*, size\_type, size\_type) const noexcept; + constexpr size\_type [rfind](basic_string_view.html#idm35151228426416-bb)(const charT \*, size\_type = npos) const noexcept; + constexpr size\_type + [find\_first\_of](basic_string_view.html#idm35151228424368-bb)([basic\_string\_view](basic_string_view.html "Class template basic_string_view"), size\_type = 0) const noexcept; + constexpr size\_type [find\_first\_of](basic_string_view.html#idm35151228422192-bb)(charT, size\_type = 0) const noexcept; + constexpr size\_type + [find\_first\_of](basic_string_view.html#idm35151228420144-bb)(const charT \*, size\_type, size\_type) const noexcept; + constexpr size\_type + [find\_first\_of](basic_string_view.html#idm35151228417840-bb)(const charT \*, size\_type = 0) const noexcept; + constexpr size\_type + [find\_last\_of](basic_string_view.html#idm35151228415792-bb)([basic\_string\_view](basic_string_view.html "Class template basic_string_view"), size\_type = npos) const noexcept; + constexpr size\_type [find\_last\_of](basic_string_view.html#idm35151228413616-bb)(charT, size\_type = npos) const noexcept; + constexpr size\_type + [find\_last\_of](basic_string_view.html#idm35151228411568-bb)(const charT \*, size\_type, size\_type) const noexcept; + constexpr size\_type + [find\_last\_of](basic_string_view.html#idm35151228409264-bb)(const charT \*, size\_type = npos) const noexcept; + constexpr size\_type + [find\_first\_not\_of](basic_string_view.html#idm35151228407216-bb)([basic\_string\_view](basic_string_view.html "Class template basic_string_view"), size\_type = 0) const noexcept; + constexpr size\_type [find\_first\_not\_of](basic_string_view.html#idm35151228405040-bb)(charT, size\_type = 0) const noexcept; + constexpr size\_type + [find\_first\_not\_of](basic_string_view.html#idm35151228402992-bb)(const charT \*, size\_type, size\_type) const noexcept; + constexpr size\_type + [find\_first\_not\_of](basic_string_view.html#idm35151228400688-bb)(const charT \*, size\_type = 0) const noexcept; + constexpr size\_type + [find\_last\_not\_of](basic_string_view.html#idm35151228398640-bb)([basic\_string\_view](basic_string_view.html "Class template basic_string_view"), size\_type = npos) const noexcept; + constexpr size\_type [find\_last\_not\_of](basic_string_view.html#idm35151228396464-bb)(charT, size\_type = npos) const noexcept; + constexpr size\_type + [find\_last\_not\_of](basic_string_view.html#idm35151228459952-bb)(const charT \*, size\_type, size\_type) const noexcept; + constexpr size\_type + [find\_last\_not\_of](basic_string_view.html#idm35151228457648-bb)(const charT \*, size\_type = npos) const noexcept; + + // [private member functions](basic_string_view.html#idm35151228448688-bb) + template + size\_type [reverse\_distance](basic_string_view.html#idm35151228448304-bb)(r\_iter, r\_iter) const noexcept; + template + Iterator [find\_not\_of](basic_string_view.html#idm35151228445872-bb)(Iterator, Iterator, [basic\_string\_view](basic_string_view.html "Class template basic_string_view")) const noexcept; + + // public data members + static constexpr size\_type npos; +}; +``` + + +Description +----------- +### +`basic_string_view` + public + construct/copy/destruct + + +1. ``` +basic\_string\_view() noexcept; +``` +2. ``` +basic\_string\_view(const [basic\_string\_view](basic_string_view.html "Class template basic_string_view") & rhs); +``` +3. ``` +template + basic\_string\_view(const std::basic\_string< charT, traits, Allocator > & str) noexcept; +``` +4. ``` +basic\_string\_view(const charT \* str); +``` +5. ``` +basic\_string\_view(const charT \* str, size\_type len); +``` +6. ``` +[basic\_string\_view](basic_string_view.html "Class template basic_string_view") & operator=(const [basic\_string\_view](basic_string_view.html "Class template basic_string_view") & rhs); +``` +### +`basic_string_view` public member functions + + +1. ``` +constexpr const\_iterator begin() const noexcept; +``` +2. ``` +constexpr const\_iterator cbegin() const noexcept; +``` +3. ``` +constexpr const\_iterator end() const noexcept; +``` +4. ``` +constexpr const\_iterator cend() const noexcept; +``` +5. ``` +const\_reverse\_iterator rbegin() const noexcept; +``` +6. ``` +const\_reverse\_iterator crbegin() const noexcept; +``` +7. ``` +const\_reverse\_iterator rend() const noexcept; +``` +8. ``` +const\_reverse\_iterator crend() const noexcept; +``` +9. ``` +constexpr size\_type size() const noexcept; +``` +10. ``` +constexpr size\_type length() const noexcept; +``` +11. ``` +constexpr size\_type max\_size() const noexcept; +``` +12. ``` +constexpr bool empty() const noexcept; +``` +13. ``` +constexpr const\_reference operator[](size\_type pos) const noexcept; +``` +14. ``` +constexpr const\_reference at(size\_t pos) const; +``` +15. ``` +constexpr const\_reference front() const; +``` +16. ``` +constexpr const\_reference back() const; +``` +17. ``` +constexpr const\_pointer data() const noexcept; +``` +18. ``` +void clear() noexcept; +``` +19. ``` +constexpr void remove\_prefix(size\_type n); +``` +20. ``` +constexpr void remove\_suffix(size\_type n); +``` +21. ``` +constexpr void swap([basic\_string\_view](basic_string_view.html "Class template basic_string_view") & s) noexcept; +``` +22. ``` +template + explicit operator std::basic\_string< charT, traits, Allocator >() const; +``` +23. ``` +template > + std::basic\_string< charT, traits, Allocator > + to\_string(const Allocator & a = Allocator()) const; +``` +24. ``` +size\_type copy(charT \* s, size\_type n, size\_type pos = 0) const; +``` +25. ``` +constexpr [basic\_string\_view](basic_string_view.html "Class template basic_string_view") substr(size\_type pos, size\_type n = npos) const; +``` +26. ``` +constexpr int compare([basic\_string\_view](basic_string_view.html "Class template basic_string_view") x) const noexcept; +``` +27. ``` +constexpr int +compare(size\_type pos1, size\_type n1, [basic\_string\_view](basic_string_view.html "Class template basic_string_view") x) const noexcept; +``` +28. ``` +constexpr int +compare(size\_type pos1, size\_type n1, [basic\_string\_view](basic_string_view.html "Class template basic_string_view") x, size\_type pos2, + size\_type n2) const; +``` +29. ``` +constexpr int compare(const charT \* x) const; +``` +30. ``` +constexpr int compare(size\_type pos1, size\_type n1, const charT \* x) const; +``` +31. ``` +constexpr int +compare(size\_type pos1, size\_type n1, const charT \* x, size\_type n2) const; +``` +32. ``` +constexpr bool starts\_with(charT c) const noexcept; +``` +33. ``` +constexpr bool starts\_with([basic\_string\_view](basic_string_view.html "Class template basic_string_view") x) const noexcept; +``` +34. ``` +constexpr bool ends\_with(charT c) const noexcept; +``` +35. ``` +constexpr bool ends\_with([basic\_string\_view](basic_string_view.html "Class template basic_string_view") x) const noexcept; +``` +36. ``` +constexpr size\_type +find([basic\_string\_view](basic_string_view.html "Class template basic_string_view") s, size\_type pos = 0) const noexcept; +``` +37. ``` +constexpr size\_type find(charT c, size\_type pos = 0) const noexcept; +``` +38. ``` +constexpr size\_type +find(const charT \* s, size\_type pos, size\_type n) const noexcept; +``` +39. ``` +constexpr size\_type find(const charT \* s, size\_type pos = 0) const noexcept; +``` +40. ``` +constexpr size\_type +rfind([basic\_string\_view](basic_string_view.html "Class template basic_string_view") s, size\_type pos = npos) const noexcept; +``` +41. ``` +constexpr size\_type rfind(charT c, size\_type pos = npos) const noexcept; +``` +42. ``` +constexpr size\_type +rfind(const charT \* s, size\_type pos, size\_type n) const noexcept; +``` +43. ``` +constexpr size\_type +rfind(const charT \* s, size\_type pos = npos) const noexcept; +``` +44. ``` +constexpr size\_type +find\_first\_of([basic\_string\_view](basic_string_view.html "Class template basic_string_view") s, size\_type pos = 0) const noexcept; +``` +45. ``` +constexpr size\_type find\_first\_of(charT c, size\_type pos = 0) const noexcept; +``` +46. ``` +constexpr size\_type +find\_first\_of(const charT \* s, size\_type pos, size\_type n) const noexcept; +``` +47. ``` +constexpr size\_type +find\_first\_of(const charT \* s, size\_type pos = 0) const noexcept; +``` +48. ``` +constexpr size\_type +find\_last\_of([basic\_string\_view](basic_string_view.html "Class template basic_string_view") s, size\_type pos = npos) const noexcept; +``` +49. ``` +constexpr size\_type find\_last\_of(charT c, size\_type pos = npos) const noexcept; +``` +50. ``` +constexpr size\_type +find\_last\_of(const charT \* s, size\_type pos, size\_type n) const noexcept; +``` +51. ``` +constexpr size\_type +find\_last\_of(const charT \* s, size\_type pos = npos) const noexcept; +``` +52. ``` +constexpr size\_type +find\_first\_not\_of([basic\_string\_view](basic_string_view.html "Class template basic_string_view") s, size\_type pos = 0) const noexcept; +``` +53. ``` +constexpr size\_type +find\_first\_not\_of(charT c, size\_type pos = 0) const noexcept; +``` +54. ``` +constexpr size\_type +find\_first\_not\_of(const charT \* s, size\_type pos, size\_type n) const noexcept; +``` +55. ``` +constexpr size\_type +find\_first\_not\_of(const charT \* s, size\_type pos = 0) const noexcept; +``` +56. ``` +constexpr size\_type +find\_last\_not\_of([basic\_string\_view](basic_string_view.html "Class template basic_string_view") s, size\_type pos = npos) const noexcept; +``` +57. ``` +constexpr size\_type +find\_last\_not\_of(charT c, size\_type pos = npos) const noexcept; +``` +58. ``` +constexpr size\_type +find\_last\_not\_of(const charT \* s, size\_type pos, size\_type n) const noexcept; +``` +59. ``` +constexpr size\_type +find\_last\_not\_of(const charT \* s, size\_type pos = npos) const noexcept; +``` +### +`basic_string_view` private member functions + + +1. ``` +template + size\_type reverse\_distance(r\_iter first, r\_iter last) const noexcept; +``` +2. ``` +template + Iterator find\_not\_of(Iterator first, Iterator last, [basic\_string\_view](basic_string_view.html "Class template basic_string_view") s) const noexcept; +``` + + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../utility/utilities/string_view.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/string_view.html#header.boost.utility.string_view_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](../utility/utilities/value_init.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/boost/call_tra_idm35151228605104.html b/doc/libs/1_78_0/libs/utility/doc/html/boost/call_tra_idm35151228605104.html new file mode 100644 index 0000000..5e8b674 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/boost/call_tra_idm35151228605104.html @@ -0,0 +1,49 @@ +--- +title: Struct template call_traits +copyright: +revised: +--- + + +Struct template call\_traits + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](call_tra_idm35151228608944.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/call_traits.html#header.boost.detail.call_traits_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](../utility/utilities/compressed_pair.html) + +Struct template call\_traits +---------------------------------- + + +boost::call\_traits +Synopsis +-------- +``` +// In header: <[boost/detail/call\_traits.hpp](../utility/utilities/call_traits.html#header.boost.detail.call_traits_hpp "Header ")> + +template +struct [call\_traits](call_tra_idm35151228605104.html "Struct template call_traits") { + // types + typedef const T \* value\_type; + typedef array\_type & reference; + typedef const array\_type & const\_reference; + typedef const T \*const param\_type; +}; +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](call_tra_idm35151228608944.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/call_traits.html#header.boost.detail.call_traits_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](../utility/utilities/compressed_pair.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/boost/call_tra_idm35151228608944.html b/doc/libs/1_78_0/libs/utility/doc/html/boost/call_tra_idm35151228608944.html new file mode 100644 index 0000000..bbfb97c --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/boost/call_tra_idm35151228608944.html @@ -0,0 +1,49 @@ +--- +title: Struct template call_traits +copyright: +revised: +--- + + +Struct template call\_traits + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](call_tra_idm35151228613424.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/call_traits.html#header.boost.detail.call_traits_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](call_tra_idm35151228605104.html) + +Struct template call\_traits +--------------------------------- + + +boost::call\_traits +Synopsis +-------- +``` +// In header: <[boost/detail/call\_traits.hpp](../utility/utilities/call_traits.html#header.boost.detail.call_traits_hpp "Header ")> + +template +struct [call\_traits](call_tra_idm35151228608944.html "Struct template call_traits") { + // types + typedef T & value\_type; + typedef T & reference; + typedef const T & const\_reference; + typedef T & param\_type; +}; +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](call_tra_idm35151228613424.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/call_traits.html#header.boost.detail.call_traits_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](call_tra_idm35151228605104.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/boost/call_tra_idm35151228613424.html b/doc/libs/1_78_0/libs/utility/doc/html/boost/call_tra_idm35151228613424.html new file mode 100644 index 0000000..e0e181e --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/boost/call_tra_idm35151228613424.html @@ -0,0 +1,49 @@ +--- +title: Struct template call_traits +copyright: +revised: +--- + + +Struct template call\_traits + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](call_traits.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/call_traits.html#header.boost.detail.call_traits_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](call_tra_idm35151228608944.html) + +Struct template call\_traits +---------------------------------------- + + +boost::call\_traits +Synopsis +-------- +``` +// In header: <[boost/detail/call\_traits.hpp](../utility/utilities/call_traits.html#header.boost.detail.call_traits_hpp "Header ")> + +template +struct [call\_traits](call_tra_idm35151228613424.html "Struct template call_traits") { + // types + typedef const T \* value\_type; + typedef array\_type & reference; + typedef const array\_type & const\_reference; + typedef const T \*const param\_type; +}; +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](call_traits.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/call_traits.html#header.boost.detail.call_traits_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](call_tra_idm35151228608944.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/boost/call_traits.html b/doc/libs/1_78_0/libs/utility/doc/html/boost/call_traits.html new file mode 100644 index 0000000..cc97d01 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/boost/call_traits.html @@ -0,0 +1,49 @@ +--- +title: Struct template call_traits +copyright: +revised: +--- + + +Struct template call\_traits + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../utility/utilities/call_traits.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/call_traits.html#header.boost.detail.call_traits_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](call_tra_idm35151228613424.html) + +Struct template call\_traits +---------------------------- + + +boost::call\_traits +Synopsis +-------- +``` +// In header: <[boost/detail/call\_traits.hpp](../utility/utilities/call_traits.html#header.boost.detail.call_traits_hpp "Header ")> + +template +struct [call\_traits](call_traits.html "Struct template call_traits") { + // types + typedef T value\_type; + typedef T & reference; + typedef const T & const\_reference; + typedef *unspecified* param\_type; +}; +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../utility/utilities/call_traits.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/call_traits.html#header.boost.detail.call_traits_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](call_tra_idm35151228613424.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/boost/compress_idm35151228634288.html b/doc/libs/1_78_0/libs/utility/doc/html/boost/compress_idm35151228634288.html new file mode 100644 index 0000000..88ad512 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/boost/compress_idm35151228634288.html @@ -0,0 +1,106 @@ +--- +title: Class template compressed_pair +copyright: +revised: +--- + + +Class template compressed\_pair + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](compressed_pair.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/compressed_pair.html#header.boost.detail.compressed_pair_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](../utility/utilities/in_place_factory.html) + +Class template compressed\_pair +------------------------------------- + + +boost::compressed\_pair +Synopsis +-------- +``` +// In header: <[boost/detail/compressed\_pair.hpp](../utility/utilities/compressed_pair.html#header.boost.detail.compressed_pair_hpp "Header ")> + +template +class [compressed\_pair](compress_idm35151228634288.html "Class template compressed_pair") { +public: + // types + typedef T first\_type; + typedef T second\_type; + typedef call\_traits< first\_type >::param\_type first\_param\_type; + typedef call\_traits< second\_type >::param\_type second\_param\_type; + typedef call\_traits< first\_type >::reference first\_reference; + typedef call\_traits< second\_type >::reference second\_reference; + typedef call\_traits< first\_type >::const\_reference first\_const\_reference; + typedef call\_traits< second\_type >::const\_reference second\_const\_reference; + + // [construct/copy/destruct](compress_idm35151228634288.html#boost.compress_idm35151228634288construct-copy-destruct) + [compressed\_pair](compress_idm35151228634288.html#idm35151228688304-bb)(); + [compressed\_pair](compress_idm35151228634288.html#idm35151228688048-bb)(first\_param\_type, second\_param\_type); + explicit [compressed\_pair](compress_idm35151228634288.html#idm35151228686768-bb)(first\_param\_type); + + // [public member functions](compress_idm35151228634288.html#idm35151228627632-bb) + first\_reference [first](compress_idm35151228634288.html#idm35151228627248-bb)(); + first\_const\_reference [first](compress_idm35151228634288.html#idm35151228626608-bb)() const; + second\_reference [second](compress_idm35151228634288.html#idm35151228625840-bb)(); + second\_const\_reference [second](compress_idm35151228634288.html#idm35151228625200-bb)() const; + void [swap](compress_idm35151228634288.html#idm35151228624432-bb)(::[boost::compressed\_pair](compressed_pair.html "Class template compressed_pair")< T, T > &); +}; +``` + + +Description +----------- +### +`compressed_pair` + public + construct/copy/destruct + + +1. ``` +compressed\_pair(); +``` +2. ``` +compressed\_pair(first\_param\_type x, second\_param\_type y); +``` +3. ``` +explicit compressed\_pair(first\_param\_type x); +``` +### +`compressed_pair` public member functions + + +1. ``` +first\_reference first(); +``` +2. ``` +first\_const\_reference first() const; +``` +3. ``` +second\_reference second(); +``` +4. ``` +second\_const\_reference second() const; +``` +5. ``` +void swap(::[boost::compressed\_pair](compressed_pair.html "Class template compressed_pair")< T, T > & y); +``` + + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](compressed_pair.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/compressed_pair.html#header.boost.detail.compressed_pair_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](../utility/utilities/in_place_factory.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/boost/compressed_pair.html b/doc/libs/1_78_0/libs/utility/doc/html/boost/compressed_pair.html new file mode 100644 index 0000000..9f59435 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/boost/compressed_pair.html @@ -0,0 +1,114 @@ +--- +title: Class template compressed_pair +copyright: +revised: +--- + + +Class template compressed\_pair + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../utility/utilities/compressed_pair.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/compressed_pair.html#header.boost.detail.compressed_pair_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](compress_idm35151228634288.html) + +Class template compressed\_pair +------------------------------- + + +boost::compressed\_pair +Synopsis +-------- +``` +// In header: <[boost/detail/compressed\_pair.hpp](../utility/utilities/compressed_pair.html#header.boost.detail.compressed_pair_hpp "Header ")> + +template +class [compressed\_pair](compressed_pair.html "Class template compressed_pair") { +public: + // types + typedef T1 first\_type; + typedef T2 second\_type; + typedef call\_traits< first\_type >::param\_type first\_param\_type; + typedef call\_traits< second\_type >::param\_type second\_param\_type; + typedef call\_traits< first\_type >::reference first\_reference; + typedef call\_traits< second\_type >::reference second\_reference; + typedef call\_traits< first\_type >::const\_reference first\_const\_reference; + typedef call\_traits< second\_type >::const\_reference second\_const\_reference; + + // [construct/copy/destruct](compressed_pair.html#boost.compressed_pairconstruct-copy-destruct) + [compressed\_pair](compressed_pair.html#idm35151228637616-bb)(); + [compressed\_pair](compressed_pair.html#idm35151228637360-bb)(first\_param\_type, second\_param\_type); + explicit [compressed\_pair](compressed_pair.html#idm35151228636080-bb)(first\_param\_type); + explicit [compressed\_pair](compressed_pair.html#idm35151228635184-bb)(second\_param\_type); + + // [public member functions](compressed_pair.html#idm35151228642352-bb) + first\_reference [first](compressed_pair.html#idm35151228641968-bb)(); + first\_const\_reference [first](compressed_pair.html#idm35151228641328-bb)() const; + second\_reference [second](compressed_pair.html#idm35151228640560-bb)(); + second\_const\_reference [second](compressed_pair.html#idm35151228639920-bb)() const; + void [swap](compressed_pair.html#idm35151228639152-bb)([compressed\_pair](compressed_pair.html "Class template compressed_pair") &); +}; +``` + + +Description +----------- +### +`compressed_pair` + public + construct/copy/destruct + + +1. ``` +compressed\_pair(); +``` +2. ``` +compressed\_pair(first\_param\_type x, second\_param\_type y); +``` +3. ``` +explicit compressed\_pair(first\_param\_type x); +``` +4. ``` +explicit compressed\_pair(second\_param\_type y); +``` +### +`compressed_pair` public member functions + + +1. ``` +first\_reference first(); +``` +2. ``` +first\_const\_reference first() const; +``` +3. ``` +second\_reference second(); +``` +4. ``` +second\_const\_reference second() const; +``` +5. ``` +void swap([compressed\_pair](compressed_pair.html "Class template compressed_pair") & y); +``` +### Specializations + + +* [Class template compressed\_pair](compress_idm35151228634288.html "Class template compressed_pair") + + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../utility/utilities/compressed_pair.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/compressed_pair.html#header.boost.detail.compressed_pair_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](compress_idm35151228634288.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/boost/in_place_factory_base.html b/doc/libs/1_78_0/libs/utility/doc/html/boost/in_place_factory_base.html new file mode 100644 index 0000000..ac0e927 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/boost/in_place_factory_base.html @@ -0,0 +1,44 @@ +--- +title: Class in_place_factory_base +copyright: +revised: +--- + + +Class in\_place\_factory\_base + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../utility/utilities/in_place_factory.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/in_place_factory.html#header.boost.utility.in_place_factory_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](typed_in_idm35151228676656.html) + +Class in\_place\_factory\_base +------------------------------ + + +boost::in\_place\_factory\_base +Synopsis +-------- +``` +// In header: <[boost/utility/in\_place\_factory.hpp](../utility/utilities/in_place_factory.html#header.boost.utility.in_place_factory_hpp "Header ")> + + +class [in\_place\_factory\_base](in_place_factory_base.html "Class in_place_factory_base") { +}; +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../utility/utilities/in_place_factory.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/in_place_factory.html#header.boost.utility.in_place_factory_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](typed_in_idm35151228676656.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/boost/initialized.html b/doc/libs/1_78_0/libs/utility/doc/html/boost/initialized.html new file mode 100644 index 0000000..6e07718 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/boost/initialized.html @@ -0,0 +1,92 @@ +--- +title: Class template initialized +copyright: +revised: +--- + + +Class template initialized + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../utility/utilities/value_init.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/value_init.html#header.boost.utility.value_init_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](initialized_value_t.html) + +Class template initialized +-------------------------- + + +boost::initialized +Synopsis +-------- +``` +// In header: <[boost/utility/value\_init.hpp](../utility/utilities/value_init.html#header.boost.utility.value_init_hpp "Header ")> + +template +class [initialized](initialized.html "Class template initialized") { +public: + // [construct/copy/destruct](initialized.html#boost.initializedconstruct-copy-destruct) + [initialized](initialized.html#idm35151228682032-bb)(); + explicit [initialized](initialized.html#idm35151228680240-bb)(T const &); + + // [public member functions](initialized.html#idm35151228840880-bb) + T const & [data](initialized.html#idm35151228840496-bb)() const; + T & [data](initialized.html#idm35151228839728-bb)(); + void [swap](initialized.html#idm35151228839088-bb)([initialized](initialized.html "Class template initialized") &); + [operator T const &](initialized.html#idm35151228837680-bb)() const; + [operator T&](initialized.html#idm35151228680112-bb)(); +}; +``` + + +Description +----------- +### +`initialized` + public + construct/copy/destruct + + +1. ``` +initialized(); +``` +2. ``` +explicit initialized(T const & arg); +``` +### +`initialized` public member functions + + +1. ``` +T const & data() const; +``` +2. ``` +T & data(); +``` +3. ``` +void swap([initialized](initialized.html "Class template initialized") & arg); +``` +4. ``` +operator T const &() const; +``` +5. ``` +operator T&(); +``` + + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../utility/utilities/value_init.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/value_init.html#header.boost.utility.value_init_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](initialized_value_t.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/boost/initialized_value.html b/doc/libs/1_78_0/libs/utility/doc/html/boost/initialized_value.html new file mode 100644 index 0000000..78b152d --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/boost/initialized_value.html @@ -0,0 +1,42 @@ +--- +title: Global initialized_value +copyright: +revised: +--- + + +Global initialized\_value + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](value_initialized.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/value_init.html#header.boost.utility.value_init_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](../utility/utilities0.html) + +Global initialized\_value +------------------------- + + +boost::initialized\_value +Synopsis +-------- +``` +// In header: <[boost/utility/value\_init.hpp](../utility/utilities/value_init.html#header.boost.utility.value_init_hpp "Header ")> + +[initialized\_value\_t](initialized_value_t.html "Class initialized_value_t") const initialized\_value; +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](value_initialized.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/value_init.html#header.boost.utility.value_init_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](../utility/utilities0.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/boost/initialized_value_t.html b/doc/libs/1_78_0/libs/utility/doc/html/boost/initialized_value_t.html new file mode 100644 index 0000000..a1c24ae --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/boost/initialized_value_t.html @@ -0,0 +1,61 @@ +--- +title: Class initialized_value_t +copyright: +revised: +--- + + +Class initialized\_value\_t + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](initialized.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/value_init.html#header.boost.utility.value_init_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](value_initialized.html) + +Class initialized\_value\_t +--------------------------- + + +boost::initialized\_value\_t +Synopsis +-------- +``` +// In header: <[boost/utility/value\_init.hpp](../utility/utilities/value_init.html#header.boost.utility.value_init_hpp "Header ")> + + +class [initialized\_value\_t](initialized_value_t.html "Class initialized_value_t") { +public: + + // [public member functions](initialized_value_t.html#idm35151228681264-bb) + template [operator T](initialized_value_t.html#idm35151228680368-bb)() const; +}; +``` + + +Description +----------- +### +`initialized_value_t` public member functions + + +1. ``` +template operator T() const; +``` + + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](initialized.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/value_init.html#header.boost.utility.value_init_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](value_initialized.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/boost/result_of.html b/doc/libs/1_78_0/libs/utility/doc/html/boost/result_of.html new file mode 100644 index 0000000..42736d9 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/boost/result_of.html @@ -0,0 +1,44 @@ +--- +title: Struct template result_of +copyright: +revised: +--- + + +Struct template result\_of + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../utility/utilities/result_of.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/result_of.html#header.boost.utility.result_of_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](tr1_result_of.html) + +Struct template result\_of +-------------------------- + + +boost::result\_of +Synopsis +-------- +``` +// In header: <[boost/utility/result\_of.hpp](../utility/utilities/result_of.html#header.boost.utility.result_of_hpp "Header ")> + +template +struct [result\_of](result_of.html "Struct template result_of") { +}; +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../utility/utilities/result_of.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/result_of.html#header.boost.utility.result_of_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](tr1_result_of.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/boost/tr1_result_of.html b/doc/libs/1_78_0/libs/utility/doc/html/boost/tr1_result_of.html new file mode 100644 index 0000000..d3033e5 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/boost/tr1_result_of.html @@ -0,0 +1,44 @@ +--- +title: Struct template tr1_result_of +copyright: +revised: +--- + + +Struct template tr1\_result\_of + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](result_of.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/result_of.html#header.boost.utility.result_of_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](../utility/utilities/string_view.html) + +Struct template tr1\_result\_of +------------------------------- + + +boost::tr1\_result\_of +Synopsis +-------- +``` +// In header: <[boost/utility/result\_of.hpp](../utility/utilities/result_of.html#header.boost.utility.result_of_hpp "Header ")> + +template +struct [tr1\_result\_of](tr1_result_of.html "Struct template tr1_result_of") { +}; +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](result_of.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/result_of.html#header.boost.utility.result_of_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](../utility/utilities/string_view.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/boost/typed_in_idm35151228676656.html b/doc/libs/1_78_0/libs/utility/doc/html/boost/typed_in_idm35151228676656.html new file mode 100644 index 0000000..668d63f --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/boost/typed_in_idm35151228676656.html @@ -0,0 +1,44 @@ +--- +title: Class typed_in_place_factory_base +copyright: +revised: +--- + + +Class typed\_in\_place\_factory\_base + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](in_place_factory_base.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/in_place_factory.html#header.boost.utility.typed_in_place_factory_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](../utility/utilities/operators.html) + +Class typed\_in\_place\_factory\_base +------------------------------------- + + +boost::typed\_in\_place\_factory\_base +Synopsis +-------- +``` +// In header: <[boost/utility/typed\_in\_place\_factory.hpp](../utility/utilities/in_place_factory.html#header.boost.utility.typed_in_place_factory_hpp "Header ")> + + +class [typed\_in\_place\_factory\_base](typed_in_idm35151228676656.html "Class typed_in_place_factory_base") { +}; +``` + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](in_place_factory_base.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/in_place_factory.html#header.boost.utility.typed_in_place_factory_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](../utility/utilities/operators.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/boost/value_initialized.html b/doc/libs/1_78_0/libs/utility/doc/html/boost/value_initialized.html new file mode 100644 index 0000000..fe176a1 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/boost/value_initialized.html @@ -0,0 +1,88 @@ +--- +title: Class template value_initialized +copyright: +revised: +--- + + +Class template value\_initialized + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](initialized_value_t.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/value_init.html#header.boost.utility.value_init_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](initialized_value.html) + +Class template value\_initialized +--------------------------------- + + +boost::value\_initialized +Synopsis +-------- +``` +// In header: <[boost/utility/value\_init.hpp](../utility/utilities/value_init.html#header.boost.utility.value_init_hpp "Header ")> + +template +class [value\_initialized](value_initialized.html "Class template value_initialized") { +public: + // [construct/copy/destruct](value_initialized.html#boost.value_initializedconstruct-copy-destruct) + [value\_initialized](value_initialized.html#idm35151228597808-bb)(); + + // [public member functions](value_initialized.html#idm35151228654640-bb) + T const & [data](value_initialized.html#idm35151228654256-bb)() const; + T & [data](value_initialized.html#idm35151228654128-bb)(); + void [swap](value_initialized.html#idm35151228652848-bb)([value\_initialized](value_initialized.html "Class template value_initialized") &); + [operator T const &](value_initialized.html#idm35151228651440-bb)() const; + [operator T&](value_initialized.html#idm35151228599600-bb)(); +}; +``` + + +Description +----------- +### +`value_initialized` + public + construct/copy/destruct + + +1. ``` +value\_initialized(); +``` +### +`value_initialized` public member functions + + +1. ``` +T const & data() const; +``` +2. ``` +T & data(); +``` +3. ``` +void swap([value\_initialized](value_initialized.html "Class template value_initialized") & arg); +``` +4. ``` +operator T const &() const; +``` +5. ``` +operator T&(); +``` + + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](initialized_value_t.html)[![Up](../../../../../doc/src/images/up.png)](../utility/utilities/value_init.html#header.boost.utility.value_init_hpp)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](initialized_value.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/index.html b/doc/libs/1_78_0/libs/utility/doc/html/index.html new file mode 100644 index 0000000..cf52a2f --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/index.html @@ -0,0 +1,64 @@ +--- +title: Chapter 1. Boost.Utility +copyright: +revised: +--- + + +Chapter 1. Boost.Utility + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../index.html) | [Libraries](../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../more/index.htm) | + +--- + + +[![Next](../../../../doc/src/images/next.png)](utility/overview.html) +Chapter 1. Boost.Utility +------------------------- + + +### +Beman Dawes + + +Copyright © 2001 Beman Dawes + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + + +**Table of Contents** +[Overview](utility/overview.html) +[Utilities](utility/utilities.html) + +[Base from Member](utility/utilities/base_from_member.html) +[Binary + Integer Literals](utility/utilities/binary_integer_literals.html) +[Call Traits](utility/utilities/call_traits.html) +[Compressed Pair](utility/utilities/compressed_pair.html) +[In-place + Factory](utility/utilities/in_place_factory.html) +[Operators](utility/utilities/operators.html) +[Result of](utility/utilities/result_of.html) +[String View](utility/utilities/string_view.html) +[Value + Init](utility/utilities/value_init.html) + +[More Utilities](utility/utilities0.html) +[Quick Reference](utility/ref.html) + + +| | | +| --- | --- | +| Last revised: December 09, 2021 at 01:40:56 GMT | | + +--- + + +[![Next](../../../../doc/src/images/next.png)](utility/overview.html) + + diff --git a/doc/libs/1_78_0/libs/utility/doc/html/utility/overview.html b/doc/libs/1_78_0/libs/utility/doc/html/utility/overview.html new file mode 100644 index 0000000..540aeb6 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/utility/overview.html @@ -0,0 +1,154 @@ +--- +title: Overview +copyright: +revised: +--- + + +Overview + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../index.html)[![Up](../../../../../doc/src/images/up.png)](../index.html)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](utilities.html) +[Overview](overview.html "Overview") +------------------------------------- + Boost.Utility is a collection of small, useful, and general-purpose components + for language support. + + Over time, + + + +* several components have been moved to more appropriate Boost libraries + and +* many of these components had variants accepted into the C++ standard + + + When the component has moved to another Boost library, Boost.Utility headers + still lead to the appropriate headers in other libraries. + +**Table 1.1. Components** + + +| + Boost.Utility + | + Moved to Boost + | + C++ Standard variant + | +| --- | --- | --- | +| +[`addressof`](../../../../../libs/core/doc/html/core/addressof.html) + | +[Boost.Core](../../../../../libs/core/index.html) + | + C++11 [`std::addressof`](https://en.cppreference.com/w/cpp/memory/addressof) + | +| +[`base\_from\_member`](../boost/base_from_member.html "Class template base_from_member") + | | | +| +[`BOOST\_BINARY`](utilities/binary_integer_literals.html#sec:BOOST_BINARY) + | | + C++14 [Binary + integer literal](https://en.cppreference.com/w/cpp/language/integer_literal) + | +| +[`call\_traits`](../boost/call_traits.html "Struct template call_traits") + | | | +| +[`checked\_delete`](../../../../../libs/core/doc/html/core/checked_delete.html) + | +[Boost.Core](../../../../../libs/core/index.html) + | | +| +[`compressed\_pair`](../boost/compressed_pair.html "Class template compressed_pair") + | | | +| +[`declval`](../../../../../libs/type_traits/doc/html/boost_typetraits/reference/declval.html) + | +[Boost.TypeTraits](../../../../../libs/type_traits/index.html) + | + C++11 [`std::declval`](https://en.cppreference.com/w/cpp/utility/declval) + | +| +[`enable\_if`](../../../../../libs/core/doc/html/core/enable_if.html) + | +[Boost.Core](../../../../../libs/core/index.html) + | + C++11 [`std::enable\_if`](https://en.cppreference.com/w/cpp/types/enable_if) + | +| +[generator + iterator adaptors](../../../../../libs/iterator/doc/generator_iterator.htm) + | +[Boost.Iterator](../../../../../libs/iterator/index.html) + | | +| +[`in\_place\_factory`](utilities/in_place_factory.html#sec:in_place_factory) + | | | +| +[`iterator\_adaptors`](../../../../../libs/iterator/index.html) + | +[Boost.Iterator](../../../../../libs/iterator/index.html) + | | +| +[`next` / `prior`](../../../../../libs/iterator/doc/html/iterator/algorithms/next_prior.html) + | +[Boost.Iterator](../../../../../libs/iterator/index.html) + | + C++11 [`std::next`](https://en.cppreference.com/w/cpp/iterator/next) / [`std::prev`](https://en.cppreference.com/w/cpp/iterator/prev) + | +| +[`noncopyable`](../../../../../libs/core/doc/html/core/noncopyable.html) + | +[Boost.Core](../../../../../libs/core/index.html) + | | +| +[`operators`](utilities/operators.html#sec:operators) + | | | +| +[`ostream\_string`](../../../../../libs/io/doc/html/io.html) + | +[Boost.IO](../../../../../libs/io/index.html) + | | +| +[`result\_of`](../boost/result_of.html "Struct template result_of") + | | + C++11 [`std::result\_of`](https://en.cppreference.com/w/cpp/types/result_of) + | +| +[`string\_view`](../boost/basic_string_view.html "Class template basic_string_view") + | | + C++17 [`std::string\_view`](https://en.cppreference.com/w/cpp/string/basic_string_view) + | +| +[`throw\_exception`](../../../../../libs/throw_exception/doc/html/throw_exception.html#using_boost_throw_exception) + | +[Boost.ThrowException](../../../../../libs/throw_exception/index.html) + | | +| +[`value\_init`](utilities/value_init.html#sec:value_init) + | | + C++11 [List + initialization](https://en.cppreference.com/w/cpp/language/list_initialization) + | + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../index.html)[![Up](../../../../../doc/src/images/up.png)](../index.html)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](utilities.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/utility/ref.html b/doc/libs/1_78_0/libs/utility/doc/html/utility/ref.html new file mode 100644 index 0000000..5bc0115 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/utility/ref.html @@ -0,0 +1,270 @@ +--- +title: Quick Reference +copyright: +revised: +--- + + +Quick Reference + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](utilities0.html)[![Up](../../../../../doc/src/images/up.png)](../index.html)[![Home](../../../../../doc/src/images/home.png)](../index.html) +[Quick Reference](ref.html "Quick Reference") +---------------------------------------------- + + + + +| +Base from Member | +Call Traits | +Compressed Pair | +In-place Factory | +| --- | --- | --- | --- | +| +Classes + +| | +| --- | +| [base\_from\_member](../boost/base_from_member.html "Class template base_from_member") | + + | +Type Traits + +| | +| --- | +| [call\_traits](../boost/call_traits.html "Struct template call_traits") | +| [call\_traits](../boost/call_traits.html "Struct template call_traits") | +| [call\_traits](../boost/call_traits.html "Struct template call_traits") | +| [call\_traits](../boost/call_traits.html "Struct template call_traits") | + + | +Classes + +| | +| --- | +| [compressed\_pair](../boost/compressed_pair.html "Class template compressed_pair") | + + +Functions + +| | +| --- | +| [swap](utilities/compressed_pair.html#header.boost.detail.compressed_pair_hpp "Header ") | + + | +Classes + +| | +| --- | +| [in\_place\_factory\_base](../boost/in_place_factory_base.html "Class in_place_factory_base") | +| [typed\_in\_place\_factory\_base](utilities/in_place_factory.html#boost.typed_in_place_factory_base) | + + | + + + + +| +Operators | +| --- | +| +Classes (1 of 5) + +| | +| --- | +| [additive1](utilities/operators.html#sec:arithmetic) | +| [additive2](utilities/operators.html#sec:arithmetic) | +| [arithmetic1](utilities/operators.html#sec:arithmetic) | +| [arithmetic2](utilities/operators.html#sec:arithmetic) | +| [bidirectional\_iteratable](utilities/operators.html#sec:arithmetic) | +| [bidirectional\_iterator\_helper](utilities/operators.html#sec:arithmetic) | +| [bitwise1](utilities/operators.html#sec:arithmetic) | +| [bitwise2](utilities/operators.html#sec:arithmetic) | +| [decrementable](utilities/operators.html#sec:arithmetic) | +| [dereferenceable](utilities/operators.html#sec:arithmetic) | +| [equality\_comparable1](utilities/operators.html#sec:arithmetic) | +| [equality\_comparable2](utilities/operators.html#sec:arithmetic) | +| [equivalent1](utilities/operators.html#sec:arithmetic) | + + | +Classes (2 of 5) + +| | +| --- | +| [equivalent2](utilities/operators.html#sec:arithmetic) | +| [euclidean\_ring\_operators1](utilities/operators.html#sec:arithmetic) | +| [euclidean\_ring\_operators2](utilities/operators.html#sec:arithmetic) | +| [field\_operators1](utilities/operators.html#sec:arithmetic) | +| [field\_operators2](utilities/operators.html#sec:arithmetic) | +| [forward\_iteratable](utilities/operators.html#sec:arithmetic) | +| [forward\_iterator\_helper](utilities/operators.html#sec:arithmetic) | +| [incrementable](utilities/operators.html#sec:arithmetic) | +| [indexable](utilities/operators.html#sec:arithmetic) | +| [input\_iteratable](utilities/operators.html#sec:arithmetic) | +| [input\_iterator\_helper](utilities/operators.html#sec:arithmetic) | +| [integer\_arithmetic1](utilities/operators.html#sec:arithmetic) | +| [integer\_arithmetic2](utilities/operators.html#sec:arithmetic) | + + | +Classes (3 of 5) + +| | +| --- | +| [integer\_multiplicative1](utilities/operators.html#sec:arithmetic) | +| [integer\_multiplicative2](utilities/operators.html#sec:arithmetic) | +| [is\_chained\_base](utilities/operators.html#sec:arithmetic) | +| [less\_than\_comparable1](utilities/operators.html#sec:arithmetic) | +| [less\_than\_comparable2](utilities/operators.html#sec:arithmetic) | +| [multiplicative1](utilities/operators.html#sec:arithmetic) | +| [multiplicative2](utilities/operators.html#sec:arithmetic) | +| [operators](utilities/operators.html#sec:arithmetic) | +| [operators2](utilities/operators.html#sec:arithmetic) | +| [operators](utilities/operators.html#sec:arithmetic) | +| [ordered\_euclidean\_ring\_operators1](utilities/operators.html#sec:arithmetic) | +| [ordered\_euclidean\_ring\_operators2](utilities/operators.html#sec:arithmetic) | +| [ordered\_euclidian\_ring\_operators1](utilities/operators.html#sec:arithmetic) | + + | +Classes (4 of 5) + +| | +| --- | +| [ordered\_euclidian\_ring\_operators2](utilities/operators.html#sec:arithmetic) | +| [ordered\_field\_operators1](utilities/operators.html#sec:arithmetic) | +| [ordered\_field\_operators2](utilities/operators.html#sec:arithmetic) | +| [ordered\_ring\_operators1](utilities/operators.html#sec:arithmetic) | +| [ordered\_ring\_operators2](utilities/operators.html#sec:arithmetic) | +| [output\_iteratable](utilities/operators.html#sec:arithmetic) | +| [output\_iterator\_helper](utilities/operators.html#sec:arithmetic) | +| [partially\_ordered1](utilities/operators.html#sec:arithmetic) | +| [partially\_ordered2](utilities/operators.html#sec:arithmetic) | +| [random\_access\_iteratable](utilities/operators.html#sec:arithmetic) | +| [random\_access\_iterator\_helper](utilities/operators.html#sec:arithmetic) | +| [ring\_operators1](utilities/operators.html#sec:arithmetic) | +| [ring\_operators2](utilities/operators.html#sec:arithmetic) | + + | +Classes (5 of 5) + +| | +| --- | +| [shiftable1](utilities/operators.html#sec:arithmetic) | +| [shiftable2](utilities/operators.html#sec:arithmetic) | +| [totally\_ordered1](utilities/operators.html#sec:arithmetic) | +| [totally\_ordered2](utilities/operators.html#sec:arithmetic) | +| [unit\_steppable](utilities/operators.html#sec:arithmetic) | + + +Type Traits + +| | +| --- | +| [is\_chained\_base](utilities/operators.html#sec:arithmetic) | + + | + + + + +| +Result of | +String View | +Value Init | +| --- | --- | --- | +| +Type Traits + +| | +| --- | +| [result\_of](../boost/result_of.html "Struct template result_of") | +| [tr1\_result\_of](../boost/tr1_result_of.html "Struct template tr1_result_of") | + + | +Aliases + +| | +| --- | +| [string\_view](../boost/basic_string_view.html "Class template basic_string_view") | +| [u16string\_ref](../boost/basic_string_view.html "Class template basic_string_view") | +| [u16string\_view](../boost/basic_string_view.html "Class template basic_string_view") | +| [u32string\_ref](../boost/basic_string_view.html "Class template basic_string_view") | +| [u32string\_view](../boost/basic_string_view.html "Class template basic_string_view") | +| [wstring\_ref](../boost/basic_string_view.html "Class template basic_string_view") | +| [wstring\_view](../boost/basic_string_view.html "Class template basic_string_view") | +| [string\_ref](../boost/basic_string_view.html "Class template basic_string_view") | + + | +Classes + +| | +| --- | +| [basic\_string\_ref](../boost/basic_string_view.html "Class template basic_string_view") | +| [basic\_string\_view](../boost/basic_string_view.html "Class template basic_string_view") | + + +Functions + +| | +| --- | +| [hash\_range](utilities/string_view.html#boost.hash_range) | +| [hash\_value](utilities/string_view.html#boost.hash_value) | + + | +Operators + +| | +| --- | +| [operator==](utilities/string_view.html#header.boost.utility.string_view_hpp "Header ") | +| [operator!=](utilities/string_view.html#header.boost.utility.string_view_hpp "Header ") | +| [operator<](utilities/string_view.html#header.boost.utility.string_view_hpp "Header ") | +| [operator<=](utilities/string_view.html#header.boost.utility.string_view_hpp "Header ") | +| [operator>](utilities/string_view.html#header.boost.utility.string_view_hpp "Header ") | +| [operator>=](utilities/string_view.html#header.boost.utility.string_view_hpp "Header ") | +| [operator<<](utilities/string_view.html#header.boost.utility.string_view_hpp "Header ") | + + | +Classes + +| | +| --- | +| [initialized](../boost/initialized.html "Class template initialized") | +| [initialized\_value\_t](../boost/initialized_value_t.html "Class initialized_value_t") | +| [value\_initialized](../boost/value_initialized.html "Class template value_initialized") | + + +Functions + +| | +| --- | +| [get](utilities/value_init.html#header.boost.utility.value_init_hpp "Header ") | +| [swap](utilities/value_init.html#header.boost.utility.value_init_hpp "Header ") | + + +Constants + +| | +| --- | +| [initialized\_value](../boost/initialized_value.html "Global initialized_value") | + + | + + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](utilities0.html)[![Up](../../../../../doc/src/images/up.png)](../index.html)[![Home](../../../../../doc/src/images/home.png)](../index.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities.html b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities.html new file mode 100644 index 0000000..727c3ba --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities.html @@ -0,0 +1,60 @@ +--- +title: Utilities +copyright: +revised: +--- + + +Utilities + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](overview.html)[![Up](../../../../../doc/src/images/up.png)](../index.html)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](utilities/base_from_member.html) +[Utilities](utilities.html "Utilities") +---------------------------------------- +[Base from Member](utilities/base_from_member.html) +[Binary + Integer Literals](utilities/binary_integer_literals.html) +[Call Traits](utilities/call_traits.html) +[Compressed Pair](utilities/compressed_pair.html) +[In-place + Factory](utilities/in_place_factory.html) +[Operators](utilities/operators.html) +[Result of](utilities/result_of.html) +[String View](utilities/string_view.html) +[Value + Init](utilities/value_init.html) + + + The entire contents of Boost.Utility are in `namespace +boost`. + + +| | | +| --- | --- | +| [Warning] | Warning | +| + Direct use of the header [``](../../../../../boost/utility.hpp) + is discouraged and it will be deprecated. + + + Please include the headers relative to individual components instead. + | + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](overview.html)[![Up](../../../../../doc/src/images/up.png)](../index.html)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](utilities/base_from_member.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/base_from_member.html b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/base_from_member.html new file mode 100644 index 0000000..5bcc71b --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/base_from_member.html @@ -0,0 +1,441 @@ +--- +title: Base from Member +copyright: +revised: +--- + + +Base from Member + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../../index.html) | [Libraries](../../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../../more/index.htm) | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](../utilities.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](../../boost/base_from_member.html) + + +### +[Base from Member](base_from_member.html "Base from Member") +[Introduction](base_from_member.html#utility.utilities.base_from_member.introduction) +[Synopsis](base_from_member.html#utility.utilities.base_from_member.synopsis) +[Basic + Usage](base_from_member.html#utility.utilities.base_from_member.basic_usage) +[Multiple + Sub-Objects](base_from_member.html#utility.utilities.base_from_member.multiple_sub_objects) +[Reference](base_from_member.html#base_from_member.reference) +[Acknowledgments](base_from_member.html#utility.utilities.base_from_member.acknowledgments) + + +#### +[Introduction](base_from_member.html#utility.utilities.base_from_member.introduction "Introduction") + The class templates [`base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member") support the base-from-member + idiom. When developing a class, sometimes a base class needs to be initialized + with a member of the current class. As a naïve example: + +``` +#include /\* for std::streambuf \*/ +#include /\* for std::ostream \*/ + +class fdoutbuf + : public [`std::streambuf`](https://en.cppreference.com/w/cpp/header/streambuf) +{ +public: + explicit fdoutbuf( int fd ); + //... +}; + +class fdostream + : public [`[`std::ostream`](https://en.cppreference.com/w/cpp/io/basic_ostream)`](https://en.cppreference.com/w/cpp/io/basic_ostream) +{ +protected: + fdoutbuf buf; +public: + explicit fdostream( int fd ) + : buf( fd ), [`[`std::ostream`](https://en.cppreference.com/w/cpp/io/basic_ostream)`](https://en.cppreference.com/w/cpp/io/basic_ostream)( &buf ) {} + //... +}; + +``` + + + This is undefined because C++'s initialization order mandates that the + base class is initialized before the member it uses. [R. + Samuel Klatchko](http://www.moocat.org) developed a way around this by using the initialization + order in his favor. Base classes are initialized in order of declaration, + so moving the desired member to another base class, that is initialized + before the desired base class, can ensure proper initialization. + + A custom base class can be made for this idiom: + +``` +#include /\* for std::streambuf \*/ +#include /\* for std::ostream \*/ + +class fdoutbuf + : public [`std::streambuf`](https://en.cppreference.com/w/cpp/header/streambuf) +{ +public: + explicit fdoutbuf( int fd ); + //... +}; + +struct fdostream\_pbase +{ + fdoutbuf sbuffer; + + explicit fdostream\_pbase( int fd ) + : sbuffer( fd ) {} +}; + +class fdostream + : private fdostream\_pbase + , public [`[`std::ostream`](https://en.cppreference.com/w/cpp/io/basic_ostream)`](https://en.cppreference.com/w/cpp/io/basic_ostream) +{ + typedef fdostream\_pbase pbase\_type; + typedef [`[`std::ostream`](https://en.cppreference.com/w/cpp/io/basic_ostream)`](https://en.cppreference.com/w/cpp/io/basic_ostream) base\_type; + +public: + explicit fdostream( int fd ) + : pbase\_type( fd ), base\_type( &sbuffer ) {} + //... +}; + +``` + + + Other projects can use similar custom base classes. The technique is basic + enough to make a template, with a sample template class in this library. + The main template parameter is the type of the enclosed member. The template + class has several (explicit) constructor member templates, which implicitly + type the constructor arguments and pass them to the member. The template + class uses implicit copy construction and assignment, cancelling them if + the enclosed member is non-copyable. + + Manually coding a base class may be better if the construction and/or copying + needs are too complex for the supplied template class, or if the compiler + is not advanced enough to use it. + + Since base classes are unnamed, a class cannot have multiple (direct) base + classes of the same type. The supplied template class has an extra template + parameter, an integer, that exists solely to provide type differentiation. + This parameter has a default value so a single use of a particular member + type does not need to concern itself with the integer. + + +#### +[Synopsis](base_from_member.html#utility.utilities.base_from_member.synopsis "Synopsis") +``` +#include /\* exposition only \*/ + +#ifndef BOOST\_BASE\_FROM\_MEMBER\_MAX\_ARITY +#define BOOST\_BASE\_FROM\_MEMBER\_MAX\_ARITY 10 +#endif + +template < typename MemberType, int UniqueID = 0 > +class [`base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member") +{ +protected: + MemberType member; + +#if *C++11 is in use* + template< typename ...T > + explicit constexpr [`base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member")( T&& ...x ) + noexcept( [`std::is\_nothrow\_constructible`](https://en.cppreference.com/w/cpp/types/is_constructible)::value ); +#else + [`base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member")(); + + template< typename T1 > + explicit [`base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member")( T1 x1 ); + + template< typename T1, typename T2 > + [`base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member")( T1 x1, T2 x2 ); + + //... + + template< typename T1, typename T2, typename T3, typename T4, + typename T5, typename T6, typename T7, typename T8, typename T9, + typename T10 > + [`base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member")( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, + T8 x8, T9 x9, T10 x10 ); +#endif +}; + +template < typename MemberType, int UniqueID > +class [`base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member") +{ +protected: + MemberType& member; + + explicit constexpr [`base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member")( MemberType& x ) + noexcept; +}; + +``` + + + The class template has a first template parameter `MemberType` + representing the type of the based-member. It has a last template parameter + `UniqueID`, that is an `int`, to differentiate between multiple base + classes that use the same based-member type. The last template parameter + has a default value of zero if it is omitted. The class template has a + protected data member called `member` + that the derived class can use for later base classes or itself. + + If the appropriate features of C++11 are present, there will be a single + constructor template. It implements *perfect forwarding* + to the best constructor call of `member` + if any. The constructor template is marked both `constexpr` + and `explicit`. The former will + be ignored if the corresponding inner constructor call of `member` does not have the marker. The + latter binds the other way; always taking effect, even when the inner constructor + call does not have the marker. The constructor template propagates the + `noexcept` status of the inner + constructor call. The constructor template has a trailing parameter with + a default value that disables the template when its signature is too close + to the signatures of the automatically-defined non-template copy- and/or + move-constructors of [`base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member"). + + On earlier-standard compilers, there is a default constructor and several + constructor member templates. These constructor templates can take as many + arguments (currently up to ten) as possible and pass them to a constructor + of the data member. + + A specialization for member references offers a single constructor taking + a `MemberType&`, + which is the only way to initialize a reference. + + Since C++ does not allow any way to explicitly state the template parameters + of a templated constructor, make sure that the arguments are already close + as possible to the actual type used in the data member's desired constructor. + Explicit conversions may be necessary. + + The `BOOST\_BASE\_FROM\_MEMBER\_MAX\_ARITY` + macro constant specifies the maximum argument length for the constructor + templates. The constant may be overridden if more (or less) argument configurations + are needed. The constant may be read for code that is expandable like the + class template and needs to maintain the same maximum size. (Example code + would be a class that uses this class template as a base class for a member + with a flexible set of constructors.) This constant is ignored when C++11 + features are present. + + +#### +[Basic + Usage](base_from_member.html#utility.utilities.base_from_member.basic_usage "Basic Usage") + With the starting example, the `fdoutbuf` + sub-object needs to be encapsulated in a base class that is inherited before + `[`[`std::ostream`](https://en.cppreference.com/w/cpp/io/basic_ostream)`](https://en.cppreference.com/w/cpp/io/basic_ostream)`. + +``` +#include + +#include // for std::streambuf +#include // for \_\_std\_ostream\_\_ + +class fdoutbuf + : public [`std::streambuf`](https://en.cppreference.com/w/cpp/header/streambuf) +{ +public: + explicit fdoutbuf( int fd ); + //... +}; + +class fdostream + : private [`boost::base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member") + , public [`[`std::ostream`](https://en.cppreference.com/w/cpp/io/basic_ostream)`](https://en.cppreference.com/w/cpp/io/basic_ostream) +{ + // Helper typedef's + typedef [`boost::base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member") pbase\_type; + typedef [`[`std::ostream`](https://en.cppreference.com/w/cpp/io/basic_ostream)`](https://en.cppreference.com/w/cpp/io/basic_ostream) base\_type; + +public: + explicit fdostream( int fd ) + : pbase\_type( fd ), base\_type( &member ){} + //... +}; + +``` + + + The base-from-member idiom is an implementation detail, so it should not + be visible to the clients (or any derived classes) of `fdostream`. + Due to the initialization order, the `fdoutbuf` + sub-object will get initialized before the `[`[`std::ostream`](https://en.cppreference.com/w/cpp/io/basic_ostream)`](https://en.cppreference.com/w/cpp/io/basic_ostream)` + sub-object does, making the former sub-object safe to use in the latter + sub-object's construction. Since the `fdoutbuf` + sub-object of the final type is the only sub-object with the name `member` that name can be used unqualified + within the final class. + + +#### +[Multiple + Sub-Objects](base_from_member.html#utility.utilities.base_from_member.multiple_sub_objects "Multiple Sub-Objects") + The base-from-member class templates should commonly involve only one base-from-member + sub-object, usually for attaching a stream-buffer to an I/O stream. The + next example demonstrates how to use multiple base-from-member sub-objects + and the resulting qualification issues. + +``` +#include + +#include /\* for NULL \*/ + +struct an\_int +{ + int y; + + an\_int( float yf ); +}; + +class switcher +{ +public: + switcher(); + switcher( double, int \* ); + //... +}; + +class flow\_regulator +{ +public: + flow\_regulator( switcher &, switcher & ); + //... +}; + +template < unsigned Size > +class fan +{ +public: + explicit fan( switcher ); + //... +}; + +class system + : private [`boost::base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member") + , private [`boost::base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member") + , private [`boost::base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member") + , private [`boost::base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member") + , protected flow\_regulator + , public fan<6> +{ + // Helper typedef's + typedef [`boost::base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member") pbase0\_type; + typedef [`boost::base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member") pbase1\_type; + typedef [`boost::base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member") pbase2\_type; + typedef [`boost::base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member") pbase3\_type; + + typedef flow\_regulator base1\_type; + typedef fan<6> base2\_type; + +public: + system( double x ); + //... +}; + +system::system( double x ) + : pbase0\_type( 0.2 ) + , pbase1\_type() + , pbase2\_type( -16, &this->pbase0\_type::member.y ) + , pbase3\_type( x, static\_cast(NULL) ) + , base1\_type( pbase3\_type::member, pbase1\_type::member ) + , base2\_type( pbase2\_type::member ) +{ + //... +} + +``` + + + The final class has multiple sub-objects with the name `member`, + so any use of that name needs qualification by a name of the appropriate + base type. Using `typedef`s + ease mentioning the base types. + + However, the fix introduces a new problem when a pointer is needed. Using + the address operator with a sub-object qualified with its class's name + results in a pointer-to-member (here, having a type of `an\_int +[`boost::base\_from\_member`](../../boost/base_from_member.html "Class template base_from_member")::\*`) + instead of a pointer to the member (having a type of `an\_int\*`). The new problem is fixed by qualifying + the sub-object with `this->` + and is needed just for pointers, and not for references or values. + + There are some argument conversions in the initialization. The constructor + argument for `pbase0\_type` + is converted from `double` to + `float`. The first constructor + argument for `pbase2\_type` + is converted from `int` to + `double`. + + The second constructor argument for `pbase3\_type` + is a special case of necessary conversion; all forms of the null-pointer + literal in C++ (except `nullptr` + from C++11) also look like compile-time integral expressions, so C++ always + interprets such code as an integer when it has overloads that can take + either an integer or a pointer. + + The last conversion is necessary for the compiler to call a constructor + form with the exact pointer type used in `switcher`'s + constructor. (If C++11's [`nullptr`](https://en.cppreference.com/w/cpp/language/nullptr) is used, it still needs + a conversion if multiple pointer types can be accepted in a constructor + call but `[`std::nullptr\_t`](https://en.cppreference.com/w/cpp/types/nullptr_t)` cannot.) + + +#### +Reference +##### +Header <[boost/utility/base\_from\_member.hpp](../../../../../../boost/utility/base_from_member.hpp)> +``` + + +[BOOST\_BASE\_FROM\_MEMBER\_MAX\_ARITY](../../BOOST_BA_idm35151229096240.html "Macro BOOST_BASE_FROM_MEMBER_MAX_ARITY") +``` + + +``` +namespace boost { + template class [base\_from\_member](../../boost/base_from_member.html "Class template base_from_member"); + + template + class [base\_from\_member](../../boost/base_fro_idm35151229100080.html "Class template base_from_member"); +} +``` + +#### +[Acknowledgments](base_from_member.html#utility.utilities.base_from_member.acknowledgments "Acknowledgments") + Author: Walker, Daryle + + Copyright 2001, 2003, 2004, 2012 Daryle Walker + + + +* [Ed Brey](http://www.boost.org/people/ed_brey.htm) + suggested some interface changes. +* [R. Samuel Klatchko](http://www.moocat.org) ([rsk@moocat.org](mailto:rsk%40moocat.org), [rsk@brightmail.com](mailto:rsk%40brightmail.com)) + invented the idiom of how to use a class member for initializing a + base class. +* [Dietmar + Kuehl](http://www.boost.org/people/dietmar_kuehl.htm) popularized the base-from-member idiom in his [IOStream + example classes](http://www.informatik.uni-konstanz.de/~kuehl/c++/iostream/). +* Jonathan Turkanis supplied an implementation of generating the constructor + templates that can be controlled and automated with macros. The implementation + uses the [Preprocessor + library](../../../../../../libs/preprocessor/index.html). +* [Walker](http://www.boost.org/people/daryle_walker.html%22%3eDaryle) + started the library. Contributed the test file [base\_from\_member\_test.cpp](../../../../../test/base_from_member_test.cpp). + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](../utilities.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](../../boost/base_from_member.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/binary_integer_literals.html b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/binary_integer_literals.html new file mode 100644 index 0000000..fdd2440 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/binary_integer_literals.html @@ -0,0 +1,121 @@ +--- +title: Binary Integer Literals +copyright: +revised: +--- + + +Binary Integer Literals + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../../index.html) | [Libraries](../../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../../more/index.htm) | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](../../BOOST_BA_idm35151229096240.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](../../BOOST_BINARY.html) + + +### +[Binary + Integer Literals](binary_integer_literals.html "Binary Integer Literals") +[Introduction](binary_integer_literals.html#utility.utilities.binary_integer_literals.introduction) +[Example](binary_integer_literals.html#utility.utilities.binary_integer_literals.example) +[Reference](binary_integer_literals.html#boost_binary.reference) +[Acknowledgments](binary_integer_literals.html#utility.utilities.binary_integer_literals.acknowledgments) + + +#### +[Introduction](binary_integer_literals.html#utility.utilities.binary_integer_literals.introduction "Introduction") + The macro `BOOST\_BINARY` + is used for the representation of binary literals. It takes as an argument + a binary number arranged as an arbitrary amount of 1s and 0s in groupings + of length 1 to 8, with groups separated by spaces. The macro serves as + a replacement for [binary + integer literals](https://en.cppreference.com/w/cpp/language/integer_literal), adopted in C++14. + + The type of the literal yielded is determined by the same rules as those + of [hex + and octal literals](https://en.cppreference.com/w/cpp/language/integer_literal). By implementation, this macro expands directly + to an octal literal during preprocessing, so there is no overhead at runtime + and the result is usable in any place that an octal literal would be. + + In order to directly support binary literals with suffixes, additional + macros of the form `BOOST\_BINARY\_XXX` + are also provided, where `XXX` + is a standard integer suffix in all capital letters. + + In addition, LL and ULL suffixes may be used for representing `long long` + and `unsigned long +long` types in compilers which provide + them as an extension. + + The `BOOST\_BINARY` family + of macros resides in the header [](../../../../../../boost/utility/binary.hpp). + + +#### +[Example](binary_integer_literals.html#utility.utilities.binary_integer_literals.example "Example") +``` +void foo( int ); + +void foo( unsigned long ); + +void bar() +{ + int value1 = BOOST\_BINARY( 100 111000 01 1 110 ); + + unsigned long value2 = BOOST\_BINARY\_UL( 100 001 ); // unsigned long + + long long value3 = BOOST\_BINARY\_LL( 11 000 ); // long long if supported + + [`assert`](https://en.cppreference.com/w/cpp/error/assert)( BOOST\_BINARY( 10010 ) + & BOOST\_BINARY( 11000 ) + == BOOST\_BINARY( 10000 ) + ); + + foo( BOOST\_BINARY( 1010 ) ); // calls the first foo + + foo( BOOST\_BINARY\_LU( 1010 ) ); // calls the second foo +} + +``` +#### +Reference +##### +Header <[boost/utility/binary.hpp](../../../../../../boost/utility/binary.hpp)> +``` + + +[BOOST\_BINARY](../../BOOST_BINARY.html "Macro BOOST_BINARY")(bit\_groupings) +[BOOST\_BINARY\_U](../../BOOST_BINARY_U.html "Macro BOOST_BINARY_U")(bit\_groupings) +[BOOST\_BINARY\_L](../../BOOST_BINARY_L.html "Macro BOOST_BINARY_L")(bit\_groupings) +[BOOST\_BINARY\_UL](../../BOOST_BINARY_UL.html "Macro BOOST_BINARY_UL")(bit\_groupings) +[BOOST\_BINARY\_LU](../../BOOST_BINARY_LU.html "Macro BOOST_BINARY_LU")(bit\_groupings) +[BOOST\_BINARY\_LL](../../BOOST_BINARY_LL.html "Macro BOOST_BINARY_LL")(bit\_groupings) +[BOOST\_BINARY\_ULL](../../BOOST_BINARY_ULL.html "Macro BOOST_BINARY_ULL")(bit\_groupings) +[BOOST\_BINARY\_LLU](../../BOOST_BINARY_LLU.html "Macro BOOST_BINARY_LLU")(bit\_groupings) +[BOOST\_SUFFIXED\_BINARY\_LITERAL](../../BOOST_SU_idm35151229114032.html "Macro BOOST_SUFFIXED_BINARY_LITERAL")(bit\_groupings, suffix) +[BOOST\_SUFFIXED\_BINARY\_LITERAL\_D](../../BOOST_SU_idm35151229112752.html "Macro BOOST_SUFFIXED_BINARY_LITERAL_D")(d, bit\_groupings, suffix) +[BOOST\_BINARY\_LITERAL\_D](../../BOOST_BINARY_LITERAL_D.html "Macro BOOST_BINARY_LITERAL_D")(d, bit\_groupings) +``` + +#### +[Acknowledgments](binary_integer_literals.html#utility.utilities.binary_integer_literals.acknowledgments "Acknowledgments") + Contributed by Matt Calabrese. + + + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](../../BOOST_BA_idm35151229096240.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](../../BOOST_BINARY.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/call_traits.html b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/call_traits.html new file mode 100644 index 0000000..bf6cdf4 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/call_traits.html @@ -0,0 +1,766 @@ +--- +title: Call Traits +copyright: +revised: +--- + + +Call Traits + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../../index.html) | [Libraries](../../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../../more/index.htm) | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](../../BOOST_BINARY_LITERAL_D.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](../../boost/call_traits.html) + + +### +[Call Traits](call_traits.html "Call Traits") +[Introduction](call_traits.html#utility.utilities.call_traits.introduction) +[Copy + constructibility](call_traits.html#utility.utilities.call_traits.copy_constructibility) +[Examples](call_traits.html#utility.utilities.call_traits.examples) +[Rationale](call_traits.html#utility.utilities.call_traits.rationale) +[Reference](call_traits.html#call_traits.reference) + + +#### +[Introduction](call_traits.html#utility.utilities.call_traits.introduction "Introduction") + All of the contents of [``](../../../../../../boost/call_traits.hpp) are defined inside `namespace boost`. + + The template class [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") encapsulates the "best" + method to pass a parameter of some type `T` + to or from a function, and consists of a collection of `typedef`s + defined as in the table below. The purpose of [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") is to ensure that + problems like ["references to references"](call_traits.html#sec:refs) + never occur, and that parameters are passed in the most efficient manner + possible, as in the [examples](call_traits.html#sec:examples). In each + case, if your existing practice is to use the type defined on the left, + then replace it with the [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") defined type on the + right. + + Note that for compilers that do not support either partial specialization + or member templates, no benefit will occur from using [`call\_traits`](../../boost/call_traits.html "Struct template call_traits"): the [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") defined types will + always be the same as the existing practice in this case. In addition if + only member templates and not partial template specialisation is support + by the compiler (for example Visual C++ 6) then [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") cannot be used with + array types, although it can still be used to solve the reference to reference + problem. + +**Table 1.2. [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") + types** + + + +| + Existing practice + | +[`call\_traits`](../../boost/call_traits.html "Struct template call_traits") + equivalent + | + Description + | + Notes + | +| --- | --- | --- | --- | +| +`T` + + + (return by value) + | +[`call\_traits`](../../boost/call_traits.html "Struct template call_traits")`::value\_type` + | + Defines a type that represents the "value" of type + `T`. + + + Use this for functions that return by value, or possibly for + stored values of type `T`. + | + 2 + | +| +`T&` + + + (return value) + | +[`call\_traits`](../../boost/call_traits.html "Struct template call_traits")`::reference` + | + Defines a type that represents a reference to type `T`. + + + Use for functions that would normally return a `T&`. + | + 1 + | +| +`const T&` + + + (return value) + | +[`call\_traits`](../../boost/call_traits.html "Struct template call_traits")`::const\_reference` + | + Defines a type that represents a constant reference to type + `T`. + + + Use for functions that would normally return a `const T&`. + | + 1 + | +| +`const T&` + + + (function parameter) + | +[`call\_traits`](../../boost/call_traits.html "Struct template call_traits")`::param\_type` + | + Defines a type that represents the "best" way to pass + a parameter of type `T` + to a function. + | + 1,3 + | + + + Notes: + + + +1. If `T` is already reference + type, then [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") + is defined such that ["references to references"](call_traits.html#sec:refs) + do not occur (requires partial specialization). +2. If `T` is an array type, + then [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") + defines `value\_type` + as a "constant pointer to type" rather than an "array + of type" (requires partial specialization). Note that if you are + using `value\_type` as + a stored value then this will result in storing a "constant pointer + to an array" rather than the array itself. This may or may not + be a good thing depending upon what you actually need (in other words + take care!). +3. If `T` is a small built + in type or a pointer, then `param\_type` + is defined as `T const`, + instead of `T const&`. This can improve the ability + of the compiler to optimize loops in the body of the function if they + depend upon the passed parameter, the semantics of the passed parameter + is otherwise unchanged (requires partial specialization). +#### +[Copy + constructibility](call_traits.html#utility.utilities.call_traits.copy_constructibility "Copy constructibility") + The following table defines which [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") types can always be + copy-constructed from which other types: + +**Table 1.3. Which [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") + types can always be copy-constructed from which other types** + + +| | + To `T` + | + To `value\_type` + | + To `reference` + | + To `const\_reference` + | + To `param\_type` + | +| --- | --- | --- | --- | --- | --- | +| + From `T` + | + iff `T` is copy + constructible + | + iff `T` is copy + constructible + | + Yes + | + Yes + | + Yes + | +| + From `value\_type` + | + iff `T` is copy + constructible + | + iff `T` is copy + constructible + | + No + | + No + | + Yes + | +| + From `reference` + | + iff `T` is copy + constructible + | + iff `T` is copy + constructible + | + Yes + | + Yes + | + Yes + | +| + From `const\_reference` + | + iff `T` is copy + constructible + | + No + | + No + | + Yes + | + Yes + | +| + From `param\_type` + | + iff `T` is copy + constructible + | + iff `T` is copy + constructible + | + No + | + No + | + Yes + | + + + If `T` is an assignable type + the following assignments are possible: + +**Table 1.4. Which [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") + types are assignable from which other types** + + +| | + To `T` + | + To `value\_type` + | + To `reference` + | + To `const\_reference` + | + To `param\_type` + | +| --- | --- | --- | --- | --- | --- | +| + From `T` + | + Yes + | + Yes + | + - + | + - + | + - + | +| + From `value\_type` + | + Yes + | + Yes + | + - + | + - + | + - + | +| + From `reference` + | + Yes + | + Yes + | + - + | + - + | + - + | +| + From `const\_reference` + | + Yes + | + Yes + | + - + | + - + | + - + | +| + From `param\_type` + | + Yes + | + Yes + | + - + | + - + | + - + | + +#### +[Examples](call_traits.html#utility.utilities.call_traits.examples "Examples") + The following table shows the effect that [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") has on various types. + +**Table 1.5. Examples of [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") + types** + + +| | +[`call\_traits`](../../boost/call_traits.html "Struct template call_traits")::`value\_type` + | +[`call\_traits`](../../boost/call_traits.html "Struct template call_traits")::`reference` + | +[`call\_traits`](../../boost/call_traits.html "Struct template call_traits")::`const\_reference` + | +[`call\_traits`](../../boost/call_traits.html "Struct template call_traits")::`param\_type` + | + Applies to: + | +| --- | --- | --- | --- | --- | --- | +| + From `my\_class` + | +`my\_class` + | +`my\_class&` + | +`const my\_class&` + | +`my\_class const&` + | + All user-defined types + | +| + From `int` + | +`int` + | +`int&` + | +`const int&` + | +`int const` + | + All small built-in types + | +| + From `int\*` + | +`int\*` + | +`int\*&` + | +`int\* +const &` + | +`int\* +const` + | + All pointer types + | +| + From `int&` + | +`int&` + | +`int&` + | +`const int&` + | +`int&` + | + All reference types + | +| + From `const int&` + | +`const int&` + | +`const int&` + | +`const int&` + | +`const int&` + | + All constant reference types + | +| + From `int[3]` + | +`const int\*` + | +`int(&)[3]` + | +`const int(&)[3]` + | +`const int\* const` + | + All array types + | +| + From `const int[3]` + | +`const int\*` + | +`const int(&)[3]` + | +`const int(&)[3]` + | +`const int\* const` + | + All constant array types + | + + + The table assumes the compiler supports partial specialization: if it does + not then all types behave in the same way as the entry for "`my\_class`", and [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") can not be used with + reference or array types. + +##### +[Example + 1:](call_traits.html#utility.utilities.call_traits.examples.example_1 "Example 1:") + The following class is a trivial class that stores some type `T` by value (see the [`call\_traits\_test.cpp`](../../../../../test/call_traits_test.cpp) file). The aim is to illustrate + how each of the available [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") `typedef`s + may be used: + +``` +template +struct contained +{ + // define our typedefs first, arrays are stored by value + // so value\_type is not the same as result\_type: + typedef typename [`boost::call\_traits`](../../boost/call_traits.html "Struct template call_traits")::param\_type param\_type; + typedef typename [`boost::call\_traits`](../../boost/call_traits.html "Struct template call_traits")::reference reference; + typedef typename [`boost::call\_traits`](../../boost/call_traits.html "Struct template call_traits")::const\_reference const\_reference; + typedef T value\_type; + typedef typename [`boost::call\_traits`](../../boost/call_traits.html "Struct template call_traits")::value\_type result\_type; + + // stored value: + value\_type v\_; + + // constructors: + contained() {} + contained(param\_type p) : v\_(p){} + // return byval: + result\_type value() { return v\_; } + // return by\_ref: + reference get() { return v\_; } + const\_reference const\_get()const { return v\_; } + // pass value: + void call(param\_type p){} + +}; + +``` +##### +[Example + 2 (the reference to reference problem):](call_traits.html#utility.utilities.call_traits.examples.example_2_the_reference_to_refer "Example 2 (the reference to reference problem):") + Consider the definition of [`std::binder1st`](https://en.cppreference.com/w/cpp/utility/functional/binder12): + +``` +template +class binder1st : + public [`std::unary\_function`](https://en.cppreference.com/w/cpp/utility/functional/unary_function) +{ +protected: + Operation op; + typename Operation::first\_argument\_type value; +public: + binder1st(const Operation& x, const typename Operation::first\_argument\_type& y); + typename Operation::result\_type operator()(const typename Operation::second\_argument\_type& x) const; +}; + +``` + + + Now consider what happens in the relatively common case that the functor + takes its second argument as a reference, that implies that `Operation::second\_argument\_type` is a reference + type, `operator()` + will now end up taking a reference to a reference as an argument, and + that is not currently legal. The solution here is to modify `operator()` + to use [`call\_traits`](../../boost/call_traits.html "Struct template call_traits"): + +``` +typename Operation::result\_type operator()(typename [`call\_traits`](../../boost/call_traits.html "Struct template call_traits")::param\_type x) const; + +``` + + + Now in the case that `Operation::second\_argument\_type` + is a reference type, the argument is passed as a reference, and the no + "reference to reference" occurs. + + +##### +[Example + 3 (the `make\_pair` problem):](call_traits.html#utility.utilities.call_traits.examples.example_3_the_make_pair_problem "Example 3 (the make_pair problem):") + If we pass the name of an array as one (or both) arguments to `[`std::make\_pair`](https://en.cppreference.com/w/cpp/utility/pair/make_pair)`, then template + argument deduction deduces the passed parameter as "const reference + to array of `T`", + this also applies to string literals (which are really array literals). + Consequently instead of returning a pair of pointers, it tries to return + a pair of arrays, and since an array type is not copy-constructible the + code fails to compile. One solution is to explicitly cast the arguments + to [`std::make\_pair`](https://en.cppreference.com/w/cpp/utility/pair/make_pair) to pointers, but + [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") + provides a better automatic solution that works safely even in generic + code where the cast might do the wrong thing: + +``` +template +[`std::pair`](https://en.cppreference.com/w/cpp/utility/pair)< + typename [`boost::call\_traits`](../../boost/call_traits.html "Struct template call_traits")::value\_type, + typename [`boost::call\_traits`](../../boost/call_traits.html "Struct template call_traits")::value\_type> + make\_pair(const T1& t1, const T2& t2) +{ + return [`std::pair`](https://en.cppreference.com/w/cpp/utility/pair)< + typename [`boost::call\_traits`](../../boost/call_traits.html "Struct template call_traits")::value\_type, + typename [`boost::call\_traits`](../../boost/call_traits.html "Struct template call_traits")::value\_type>(t1, t2); +} + +``` + + + Here, the deduced argument types will be automatically degraded to pointers + if the deduced types are arrays, similar situations occur in the standard + binders and adapters: in principle in any function that "wraps" + a temporary whose type is deduced. Note that the function arguments to + [`std::make\_pair`](https://en.cppreference.com/w/cpp/utility/pair/make_pair) are not expressed + in terms of [`call\_traits`](../../boost/call_traits.html "Struct template call_traits"): + doing so would prevent template argument deduction from functioning. + + +##### +[Example + 4 (optimising fill):](call_traits.html#utility.utilities.call_traits.examples.example_4_optimising_fill "Example 4 (optimising fill):") + The [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") + template will "optimize" the passing of a small built-in type + as a function parameter. This mainly has an effect when the parameter + is used within a loop body. + + In the following example (see [`fill\_example.cpp`](../../../../../../libs/type_traits/examples/fill_example.cpp)), a version of [`std::fill`](https://en.cppreference.com/w/cpp/algorithm/fill) is optimized in two ways: + if the type passed is a single byte built-in type then [`std::memset`](https://en.cppreference.com/w/cpp/string/byte/memset) is used to effect the + fill, otherwise a conventional C++ implementation is used, but with the + passed parameter "optimized" using [`call\_traits`](../../boost/call_traits.html "Struct template call_traits"): + +``` +template +struct filler +{ + template + static void do\_fill(I first, I last, typename [`boost::call\_traits`](../../boost/call_traits.html "Struct template call_traits")::param\_type val) + { + while(first != last) + { + \*first = val; + ++first; + } + } +}; + +template <> +struct filler +{ + template + static void do\_fill(I first, I last, T val) + { + [`std::memset`](https://en.cppreference.com/w/cpp/string/byte/memset)(first, val, last-first); + } +}; + +template +inline void fill(I first, I last, const T& val) +{ + enum { can\_opt = boost::is\_pointer::value + && boost::is\_arithmetic::value + && (sizeof(T) == 1) }; + typedef filler filler\_t; + filler\_t::template do\_fill(first, last, val); +} + +``` + + + The reason that this is "optimal" for small built-in types + is that with the value passed as `T +const` instead of `const T&` the compiler is able to tell both + that the value is constant and that it is free of aliases. With this + information the compiler is able to cache the passed value in a register, + unroll the loop, or use explicitly parallel instructions: if any of these + are supported. Exactly how much mileage you will get from this depends + upon your compiler - we could really use some accurate benchmarking software + as part of boost for cases like this. + + Note that the function arguments to fill are not expressed in terms of + [`call\_traits`](../../boost/call_traits.html "Struct template call_traits"): + doing so would prevent template argument deduction from functioning. + Instead fill acts as a "thin wrapper" that is there to perform + template argument deduction, the compiler will optimise away the call + to fill all together, replacing it with the call to `filler<>::do\_fill`, + which does use [`call\_traits`](../../boost/call_traits.html "Struct template call_traits"). + + + +#### +[Rationale](call_traits.html#utility.utilities.call_traits.rationale "Rationale") + The following notes are intended to briefly describe the rationale behind + choices made in [`call\_traits`](../../boost/call_traits.html "Struct template call_traits"). + + All user-defined types follow "existing practice" and need no + comment. + + Small built-in types, what the standard calls [fundamental + types](https://en.cppreference.com/w/cpp/language/types), differ from existing practice only in the `param\_type` `typedef`. + In this case passing `T const` is compatible with existing practice, + but may improve performance in some cases (see [Example + 4](call_traits.html#sec:example4)). In any case this should never be any worse than existing practice. + + Pointers follow the same rationale as small built-in types. + + For reference types the rationale follows [Example + 2](call_traits.html#sec:refs) - references to references are not allowed, so the [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") members must be defined + such that these problems do not occur. There is a proposal to modify the + language such that "a reference to a reference is a reference" + (issue #106, submitted by Bjarne Stroustrup). [`call\_traits`](../../boost/call_traits.html "Struct template call_traits")`::value\_type` + and [`call\_traits`](../../boost/call_traits.html "Struct template call_traits")`::param\_type` both provide the same effect + as that proposal, without the need for a language change. In other words, + it's a workaround. + + For array types, a function that takes an array as an argument will degrade + the array type to a pointer type: this means that the type of the actual + parameter is different from its declared type, something that can cause + endless problems in template code that relies on the declared type of a + parameter. + + For example: + +``` +template +struct A +{ + void foo(T t); +}; + +``` + + + In this case if we instantiate `A` + then the declared type of the parameter passed to member function `foo` is `int[2]`, + but its actual type is `const int\*`. If + we try to use the type `T` + within the function body, then there is a strong likelihood that our code + will not compile: + +``` +template +void A::foo(T t) +{ + T dup(t); // doesn't compile for case that T is an array. +} + +``` + + + By using [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") + the degradation from array to pointer is explicit, and the type of the + parameter is the same as it's declared type: + +``` +template +struct A +{ + void foo(typename [`call\_traits`](../../boost/call_traits.html "Struct template call_traits")::value\_type t); +}; + +template +void A::foo(typename [`call\_traits`](../../boost/call_traits.html "Struct template call_traits")::value\_type t) +{ + typename [`call\_traits`](../../boost/call_traits.html "Struct template call_traits")::value\_type dup(t); // OK even if T is an array type. +} + +``` + + + For `value\_type` (return + by value), again only a pointer may be returned, not a copy of the whole + array, and again [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") + makes the degradation explicit. The `value\_type` + member is useful whenever an array must be explicitly degraded to a pointer + - [Example 3](call_traits.html#sec:example3) provides the test case. + + Footnote: the array specialisation for [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") is the least well + understood of all the [`call\_traits`](../../boost/call_traits.html "Struct template call_traits") + specialisations. If the given semantics cause specific problems for you, + or does not solve a particular array-related problem, then I would be interested + to hear about it. Most people though will probably never need to use this + specialisation. + + +#### +Reference +##### +Header <[boost/detail/call\_traits.hpp](../../../../../../boost/detail/call_traits.hpp)> +``` +namespace boost { + template struct [call\_traits](../../boost/call_traits.html "Struct template call_traits"); + + template struct [call\_traits](../../boost/call_tra_idm35151228613424.html "Struct template call_traits"); + template struct [call\_traits](../../boost/call_tra_idm35151228608944.html "Struct template call_traits"); + template struct [call\_traits](../../boost/call_tra_idm35151228605104.html "Struct template call_traits"); +} +``` + + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](../../BOOST_BINARY_LITERAL_D.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](../../boost/call_traits.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/compressed_pair.html b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/compressed_pair.html new file mode 100644 index 0000000..0e517ad --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/compressed_pair.html @@ -0,0 +1,137 @@ +--- +title: Compressed Pair +copyright: +revised: +--- + + +Compressed Pair + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../../index.html) | [Libraries](../../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../../more/index.htm) | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](../../boost/call_tra_idm35151228605104.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](../../boost/compressed_pair.html) + + +### +[Compressed Pair](compressed_pair.html "Compressed Pair") +[Introduction](compressed_pair.html#utility.utilities.compressed_pair.introduction) +[Synopsis](compressed_pair.html#utility.utilities.compressed_pair.synopsis) +[Reference](compressed_pair.html#compressed_pair.reference) +[Acknowledgments](compressed_pair.html#utility.utilities.compressed_pair.acknowledgments) + + +#### +[Introduction](compressed_pair.html#utility.utilities.compressed_pair.introduction "Introduction") + All of the contents of [``](../../../../../../boost/compressed_pair.hpp) are defined inside `namespace boost`. + + The class [`compressed\_pair`](../../boost/compressed_pair.html "Class template compressed_pair") + is very similar to [`std::pair`](https://en.cppreference.com/w/cpp/utility/pair). However, if either of the + template arguments are empty classes, then the [*empty + base-class optimisation*](https://en.cppreference.com/w/cpp/language/ebo) is applied to compress the size + of the pair. + + +#### +[Synopsis](compressed_pair.html#utility.utilities.compressed_pair.synopsis "Synopsis") +``` +cpp +template +class [`compressed\_pair`](../../boost/compressed_pair.html "Class template compressed_pair") +{ +public: + typedef T1 first\_type; + typedef T2 second\_type; + typedef typename [`call\_traits`](../../boost/call_traits.html "Struct template call_traits")::param\_type first\_param\_type; + typedef typename [`call\_traits`](../../boost/call_traits.html "Struct template call_traits")::param\_type second\_param\_type; + typedef typename [`call\_traits`](../../boost/call_traits.html "Struct template call_traits")::reference first\_reference; + typedef typename [`call\_traits`](../../boost/call_traits.html "Struct template call_traits")::reference second\_reference; + typedef typename [`call\_traits`](../../boost/call_traits.html "Struct template call_traits")::const\_reference first\_const\_reference; + typedef typename [`call\_traits`](../../boost/call_traits.html "Struct template call_traits")::const\_reference second\_const\_reference; + + compressed\_pair() : base() {} + compressed\_pair(first\_param\_type x, second\_param\_type y); + explicit compressed\_pair(first\_param\_type x); + explicit compressed\_pair(second\_param\_type y); + + compressed\_pair& operator=(const compressed\_pair&); + + first\_reference first(); + first\_const\_reference first() const; + + second\_reference second(); + second\_const\_reference second() const; + + void swap(compressed\_pair& y); +}; + +``` + + + The two members of the pair can be accessed using the member functions + `first()` + and `second()`. + Note that not all member functions can be instantiated for all template + parameter types. In particular [`compressed\_pair`](../../boost/compressed_pair.html "Class template compressed_pair") can be instantiated + for reference and array types, however in these cases the range of constructors + that can be used is limited. If types `T1` + and `T2` are the same type, + then there is only one version of the single-argument constructor, and + this constructor initialises both values in the pair to the passed value. + + Note that if either member is a [POD](https://en.cppreference.com/w/cpp/named_req/PODType) + type, then that member is not zero-initialized by the [`compressed\_pair`](../../boost/compressed_pair.html "Class template compressed_pair") default constructor: + it is up to you to supply an initial value for these types if you want + them to have a default value. + + Note that [`compressed\_pair`](../../boost/compressed_pair.html "Class template compressed_pair") + can not be instantiated if either of the template arguments is a union + type, unless there is compiler support for [`boost::is\_union`](../../../../../../libs/type_traits/index.html), or if [`boost::is\_union`](../../../../../../libs/type_traits/index.html) is specialised for the + union type. + + Finally, a word of caution for Visual C++ 6 users: if either argument is + an empty type, then assigning to that member will produce memory corruption, + unless the empty type has a "do nothing" assignment operator + defined. This is due to a bug in the way VC6 generates implicit assignment + operators. + + +#### +Reference +##### +Header <[boost/detail/compressed\_pair.hpp](../../../../../../boost/detail/compressed_pair.hpp)> +``` +namespace boost { + template class [compressed\_pair](../../boost/compressed_pair.html "Class template compressed_pair"); + + template class [compressed\_pair](../../boost/compress_idm35151228634288.html "Class template compressed_pair"); + template + void swap([compressed\_pair](../../boost/compressed_pair.html "Class template compressed_pair")< T1, T2 > & x, [compressed\_pair](../../boost/compressed_pair.html "Class template compressed_pair")< T1, T2 > & y); +} +``` + +#### +[Acknowledgments](compressed_pair.html#utility.utilities.compressed_pair.acknowledgments "Acknowledgments") + Based on contributions by Steve Cleary, Beman Dawes, Howard Hinnant and + John Maddock. + + Maintained by [John Maddock](mailto:john%40johnmaddock.co.uk). + + + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](../../boost/call_tra_idm35151228605104.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](../../boost/compressed_pair.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/in_place_factory.html b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/in_place_factory.html new file mode 100644 index 0000000..01bfc84 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/in_place_factory.html @@ -0,0 +1,393 @@ +--- +title: In-place Factory +copyright: +revised: +--- + + +In-place Factory + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../../index.html) | [Libraries](../../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../../more/index.htm) | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](../../boost/compress_idm35151228634288.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](../../boost/in_place_factory_base.html) + + +### +[In-place + Factory](in_place_factory.html "In-place Factory") +[Introduction](in_place_factory.html#utility.utilities.in_place_factory.introduction) +[Framework](in_place_factory.html#utility.utilities.in_place_factory.framework) +[Specification](in_place_factory.html#utility.utilities.in_place_factory.specification) +[Container-side + Usage](in_place_factory.html#utility.utilities.in_place_factory.container_side_usage) +[User-side + Usage](in_place_factory.html#utility.utilities.in_place_factory.user_side_usage) +[Reference](in_place_factory.html#in_place_factory.reference) +[Acknowledgments](in_place_factory.html#utility.utilities.in_place_factory.acknowledgments) + + +#### +[Introduction](in_place_factory.html#utility.utilities.in_place_factory.introduction "Introduction") + Suppose we have a class + +``` +struct X +{ + X ( int, [`std::string`](https://en.cppreference.com/w/cpp/string/basic_string) ) ; +}; + +``` + + + And a container for it which supports an empty state. That is, a container + which can contain zero objects: + +``` +struct C +{ + C() : contained\_(0) {} + ~C() { delete contained\_ ; } + X\* contained\_ ; +}; + +``` + + + A container designed to support an empty state typically does not require + the contained type to be [*DefaultConstructible*](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible), + but it typically requires it to be [*CopyConstructible*](https://en.cppreference.com/w/cpp/named_req/CopyConstructible) + as a mechanism to initialize the object to store: + +``` +struct C +{ + C() : contained\_(0) {} + C ( X const& v ) : contained\_ ( new X(v) ) {} + ~C() { delete contained\_ ; } + X\* contained\_ ; +}; + +``` + + + There is a subtle problem with this: since the mechanism used to initialize + the stored object is copy construction, there must exist a previously constructed + source object to copy from. This object is likely to be temporary and serve + no purpose besides being the source: + +``` +void foo() +{ + // Temporary object created. + C c( X(123,"hello") ) ; +} + +``` + + + A solution to this problem is to support direct construction of the contained + object right in the container's storage. + + In this scheme, the user supplies the arguments for the `X` + constructor directly to the container: + +``` +struct C +{ + C() : contained\_(0) {} + C ( X const& v ) : contained\_ ( new X(v) ) {} + C ( int a0, [`std::string`](https://en.cppreference.com/w/cpp/string/basic_string) a1 ) : contained\_ ( new X(a0,a1) ) {} + ~C() { delete contained\_ ; } + X\* contained\_ ; +}; + +``` + + +``` +void foo() +{ + // Wrapped object constructed in-place + // No temporary created. + C c(123,"hello"); +} + +``` + + + Clearly, this solution does not scale well since the container must duplicate + all the constructor overloads from the contained type, or at least all + those which are to be supported directly in the container. + + +#### +[Framework](in_place_factory.html#utility.utilities.in_place_factory.framework "Framework") + This library proposes a framework to allow some containers to directly + construct contained objects in-place without requiring the entire set of + constructor overloads from the contained type. It also allows the container + to remove the [*CopyConstructible*](https://en.cppreference.com/w/cpp/named_req/CopyConstructible) + requirement from the contained type since objects can be directly constructed + in-place without need of a copy. + + The only requirement on the container is that it must provide proper storage. + That is, the container should be correctly aligned and sized. Naturally, + the container will typically support uninitialized storage to avoid the + in-place construction to override a fully-constructed object, as this would + defeat the purpose of in-place construction. + + For this purpose, the framework provides two concepts called: InPlaceFactories + and TypedInPlaceFactories. Helpers to declare these classes are declared + in [``](../../../../../../boost/utility/in_place_factory.hpp) and [``](../../../../../../boost/utility/typed_in_place_factory.hpp). + + Essentially, these classes hold a sequence of actual parameters and a method + to construct an object in place using these parameters. Each member of + the family differs only in the number and type of the parameter list. The + first family takes the type of the object to construct directly in method + provided for that purpose, whereas the second family incorporates that + type in the factory class itself. From the container point of view, using + the framework amounts to calling the factory's method to contruct the object + in place. From the user point of view, it amounts to creating the right + factory object to hold the parameters and pass it to the container. + + The following simplified example shows the basic idea. A complete example + follows the formal specification of the framework: + +``` +struct C +{ + template + C ( InPlaceFactory const& aFactory ) + : + contained\_ ( uninitialized\_storage() ) + { + aFactory.template apply(contained\_); + } + + ~C() + { + contained\_ -> X::~X(); + delete[] contained\_ ; + } + + char\* uninitialized\_storage() { return new char[sizeof(X)] ; } + + char\* contained\_ ; +}; + +void foo() +{ + C c( in\_place(123,"hello") ) ; +} + +``` +#### +[Specification](in_place_factory.html#utility.utilities.in_place_factory.specification "Specification") + The following is the first member of the family of `InPlaceFactory` + classes, along with its corresponding helper template function. The rest + of the family varies only in the number and type of template and constructor + parameters. + +``` +namespace boost { + +struct [`in\_place\_factory\_base`](../../boost/in_place_factory_base.html "Class in_place_factory_base") {}; + +template +class in\_place\_factory : public [`in\_place\_factory\_base`](../../boost/in_place_factory_base.html "Class in_place_factory_base") +{ + public: + in\_place\_factory ( A0 const& a0 ) : m\_a0(a0) {} + + template< class T > + void apply ( void\* address ) const + { + new (address) T(m\_a0); + } + + private: + A0 const& m\_a0 ; +}; + +template +in\_place\_factory in\_place ( A0 const& a0 ) +{ + return in\_place\_factory(a0); +} + +} + +``` + + + Similarly, the following is the first member of the family of `typed\_in\_place\_factory` classes, along + with its corresponding helper template function. The rest of the family + varies only in the number and type of template and constructor parameters. + +``` +namespace boost { + +struct [`typed\_in\_place\_factory\_base`](in_place_factory.html#boost.typed_in_place_factory_base) {}; + +template +class typed\_in\_place\_factory : public [`typed\_in\_place\_factory\_base`](in_place_factory.html#boost.typed_in_place_factory_base) +{ + public: + typed\_in\_place\_factory ( A0 const& a0 ) : m\_a0(a0) {} + + void apply ( void\* address ) const + { + new (address) T(m\_a0); + } + + private: + A0 const& m\_a0 ; +}; + +template +typed\_in\_place\_factory in\_place ( A0 const& a0 ) +{ + return typed\_in\_place\_factory(a0); +} +} + +``` + + + As you can see, the `in\_place\_factory` + and `typed\_in\_place\_factory` + template classes vary only in the way they specify the target type: in + the first family, the type is given as a template argument to the apply + member function while in the second it is given directly as part of the + factory class. + + When the container holds a unique non-polymorphic type, such as the case + of [Boost.Optional](../../../../../../libs/optional/index.html), + it knows the exact dynamic-type of the contained object and can pass it + to the `apply()` + method of a non-typed factory. In this case, end users can use an `in\_place\_factory` instance which can be + constructed without the type of the object to construct. + + However, if the container holds heterogeneous or polymorphic objects, such + as the case of [Boost.Variant](../../../../../../libs/variant/index.html), + the dynamic-type of the object to be constructed must be known by the factory. + In this case, end users must use a `typed\_in\_place\_factory` + instead. + + +#### +[Container-side + Usage](in_place_factory.html#utility.utilities.in_place_factory.container_side_usage "Container-side Usage") + As shown in the introductory simplified example, the container class must + contain methods that accept an instance of these factories and pass the + object's storage to the factory's apply method. + + However, the type of the factory class cannot be completely specified in + the container class because that would defeat the whole purpose of the + factories which is to allow the container to accept a variadic argument + list for the constructor of its contained object. + + The correct function overload must be based on the only distinctive and + common characteristic of all the classes in each family: the base class. + + Depending on the container class, you can use `enable\_if` + to generate the right overload, or use the following dispatch technique, + which is used in the [Boost.Optional](../../../../../../libs/optional/index.html) + class: + +``` +struct C +{ + C() : contained\_(0) {} + C ( X const& v ) : contained\_ ( new X(v) ) {} + + template + C ( Expr const& expr ) + : + contained\_ ( uninitialized\_storage() ) + { + construct(expr,&expr); + } + + ~C() { delete contained\_ ; } + + template + void construct ( InPlaceFactory const& aFactory, boost::[`in\_place\_factory\_base`](../../boost/in_place_factory_base.html "Class in_place_factory_base")\* ) + { + aFactory.template apply(contained\_); + } + + template + void construct ( TypedInPlaceFactory const& aFactory, boost::[`typed\_in\_place\_factory\_base`](in_place_factory.html#boost.typed_in_place_factory_base)\* ) + { + aFactory.apply(contained\_); + } + + X\* uninitialized\_storage() { return static\_cast(new char[sizeof(X)]) ; } + + X\* contained\_ ; +}; + +``` +#### +[User-side + Usage](in_place_factory.html#utility.utilities.in_place_factory.user_side_usage "User-side Usage") + End users pass to the container an instance of a factory object holding + the actual parameters needed to construct the contained object directly + within the container. For this, the helper template function `in\_place` is used. + + The call `in\_place(a0,a1,a2,...,an)` constructs + a (non-typed) `in\_place\_factory` + instance with the given argument list. + + The call `in\_place(a0,a1,a2,...,an)` constructs + a `typed\_in\_place\_factory` + instance with the given argument list for the type `T`. + +``` +void foo() +{ + C a( in\_place(123, "hello") ) ; // in\_place\_factory passed + C b( in\_place(456, "world") ) ; // typed\_in\_place\_factory passed +} + +``` +#### +Reference +##### +Header <[boost/utility/in\_place\_factory.hpp](../../../../../../boost/utility/in_place_factory.hpp)> +``` +namespace boost { + class [in\_place\_factory\_base](../../boost/in_place_factory_base.html "Class in_place_factory_base"); +} +``` +##### +Header <[boost/utility/typed\_in\_place\_factory.hpp](../../../../../../boost/utility/typed_in_place_factory.hpp)> +``` +namespace boost { + class [typed\_in\_place\_factory\_base](../../boost/typed_in_idm35151228676656.html "Class typed_in_place_factory_base"); +} +``` + +#### +[Acknowledgments](in_place_factory.html#utility.utilities.in_place_factory.acknowledgments "Acknowledgments") + Copyright Fernando Luis Cacciola Carballal, 2004 + + + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](../../boost/compress_idm35151228634288.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](../../boost/in_place_factory_base.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/operators.html b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/operators.html new file mode 100644 index 0000000..236226e --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/operators.html @@ -0,0 +1,2254 @@ +--- +title: Operators +copyright: +revised: +--- + + +Operators + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../../index.html) | [Libraries](../../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../../more/index.htm) | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](../../boost/typed_in_idm35151228676656.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](result_of.html) + + +### +[Operators](operators.html "Operators") +[Introduction](operators.html#utility.utilities.operators.introduction) +[Rationale](operators.html#utility.utilities.operators.rationale) +[Example](operators.html#utility.utilities.operators.example) +[Usage](operators.html#utility.utilities.operators.usage) +[Arithmetic + Operators](operators.html#utility.utilities.operators.arithmetic_operators) +[Dereference + Operators and Iterator Helpers](operators.html#utility.utilities.operators.dereference_operators_and_iterat) +[Note + for Users of Older Versions](operators.html#utility.utilities.operators.note_for_users_of_older_versions) +[Acknowledgments](operators.html#utility.utilities.operators.acknowledgments) + + +#### +[Introduction](operators.html#utility.utilities.operators.introduction "Introduction") + The header [``](../../../../../../boost/operators.hpp) + supplies several sets of class templates in `namespace +boost`. These templates define + operators at namespace scope in terms of a minimal number of fundamental + operators provided by the class. + + +#### +[Rationale](operators.html#utility.utilities.operators.rationale "Rationale") + Overloaded operators for class types typically occur in groups. If you + can write `x + +y`, you probably also want to + be able to write `x += +y`. If you can write `x < y,` you + also want `x > +y`, `x +>= y,` and `x +<= y`. + + Moreover, unless your class has really surprising behavior, some of these + related operators can be defined in terms of others (e.g. `x >= y` is equivalent to `!(x < y)`). + + Replicating this boilerplate for multiple classes is both tedious and error-prone. + The [``](../../../../../../boost/operators.hpp) + templates help by generating operators for you at namespace scope based + on other operators you have defined in your class. + + If, for example, you declare a class like this: + +``` +class MyInt + : boost::[`operators`](operators.html#sec:arithmetic) +{ + bool operator<(const MyInt& x) const; + bool operator==(const MyInt& x) const; + MyInt& operator+=(const MyInt& x); + MyInt& operator-=(const MyInt& x); + MyInt& operator\*=(const MyInt& x); + MyInt& operator/=(const MyInt& x); + MyInt& operator%=(const MyInt& x); + MyInt& operator|=(const MyInt& x); + MyInt& operator&=(const MyInt& x); + MyInt& operator^=(const MyInt& x); + MyInt& operator++(); + MyInt& operator--(); +}; + +``` + + + then the [`operators`](operators.html#sec:arithmetic)<> + template adds more than a dozen additional operators, such as `operator>`, + `operator<=`, + `operator>=`, + and the binary `operator+`. + +[Two-argument forms](operators.html#sec:two_arg) of the templates + are also provided to allow interaction with other types. + +This is a *Summary of Template Semantics*: + + + +1. Each operator template completes the concept(s) it describes by defining + overloaded operators for its target class. +2. The name of an operator class template indicates the [concept](operators.html#sec:concepts_note) + that its target class will model. +3. Usually, the target class uses an instantiation of the operator class + template as a base class. Some operator templates support an [alternate method](operators.html#sec:explicit_instantiation). +4. The concept can be compound, i.e. it may represent a common combination + of other, simpler concepts. +5. Most operator templates require their target class to support operations + related to the operators supplied by the template. In accordance with + widely accepted [coding + style recommendations](http://www.gotw.ca/gotw/004.htm), the target class is often required to + supply the assignment counterpart operator of the concept's "main + operator." For example, the `addable` + template requires `operator+=(T const&)` + and in turn supplies `operator+(T const&, +T const&)`. + + +*Note on the use of concepts*: + The discussed concepts are not necessarily the standard library's concepts, + such as [*CopyConstructible*](https://en.cppreference.com/w/cpp/named_req/CopyConstructible), + although some of them could be; they are what we call *concepts + with a small 'c'*. In particular, they are different from the + former ones in that they *do not* describe precise semantics + of the operators they require to be defined, except the requirements that + (a) the semantics of the operators grouped in one concept should be consistent + (e.g. effects of evaluating of `a ++= b` + and `a = +a + +b` expressions should be the same), + and (b) that the return types of the operators should follow semantics + of return types of corresponding operators for built-in types (e.g. `operator<` + should return a type convertible to `bool`, + and `T::operator-=` + should return type convertible to `T`). + Such "loose" requirements make `operators` + library applicable to broader set of target classes from different domains, + i.e. eventually more useful. + + +#### +[Example](operators.html#utility.utilities.operators.example "Example") + This example shows how some of the [arithmetic + operator templates](operators.html#sec:arithmetic) can be used with a geometric point class template. + +``` +template +class point // note: private inheritance is OK here! + : boost::addable< point // point + point + , boost::subtractable< point // point - point + , boost::dividable2< point, T // point / T + , boost::multipliable2< point, T // point \* T, T \* point + > > > > +{ +public: + point(T, T); + T x() const; + T y() const; + + point operator+=(const point&); + // point operator+(point, const point&) automatically + // generated by addable. + + point operator-=(const point&); + // point operator-(point, const point&) automatically + // generated by subtractable. + + point operator\*=(T); + // point operator\*(point, const T&) and + // point operator\*(const T&, point) auto-generated + // by multipliable. + + point operator/=(T); + // point operator/(point, const T&) auto-generated + // by dividable. +private: + T x\_; + T y\_; +}; + +// now use the point<> class: +template +T length(const point p) +{ + return sqrt(p.x()\*p.x() + p.y()\*p.y()); +} + +const point right(0, 1); +const point up(1, 0); +const point pi\_over\_4 = up + right; +const point pi\_over\_4\_normalized = pi\_over\_4 / length(pi\_over\_4); + +``` +#### +[Usage](operators.html#utility.utilities.operators.usage "Usage") + + +###### + +[Two-Argument + Template Forms](operators.html#utility.utilities.operators.usage.two_argument_template_forms) +The arguments to a binary operator commonly + have identical types, but it is not unusual to want to define operators + which combine different types. For [example](operators.html#sec:example), + one might want to multiply a mathematical vector by a scalar. The two-argument + template forms of the arithmetic operator templates are supplied for this + purpose. When applying the two-argument form of a template, the desired + return type of the operators typically determines which of the two types + in question should be derived from the operator template. + + For example, if the result of `T ++ U` + is of type `T`, then `T` (not `U`) + should be derived from [`addable`](operators.html#table:addable2). + The comparison templates [`less\_than\_comparable`](operators.html#table:less_than_comparable2), [`equality\_comparable`](operators.html#table:equality_comparable2), [`equivalent`](operators.html#table:equivalent2), and [`partially\_ordered`](operators.html#table:partially_ordered2) are exceptions to this guideline, + since the return type of the operators they define is `bool`. + + On compilers which do not support partial specialization, the two-argument + forms must be specified by using the names shown below with the trailing + `'2'`. The single-argument forms + with the trailing `'1'` are provided + for symmetry and to enable certain applications of the [base + class chaining](operators.html#sec:chaining) technique. + +*Mixed Arithmetics*: + Another application of the two-argument template forms is for mixed arithmetics + between a type `T` and a + type `U` that is convertible + to `T`. In this case there + are two ways where the two-argument template forms are helpful: one is + to provide the respective signatures for operator overloading, the second + is performance. + + With respect to the operator overloading assume e.g. that `U` is `int`, + that `T` is an user-defined + unlimited integer type, and that `double +operator-(double, const T&)` exists. + + If one wants to compute `int - T` and + does not provide `T operator-(int, +const T&)`, the compiler will consider `double operator-(double, const T&)` + to be a better match than `T operator-(const T&, const T&)`, + which will probably be different from the user's intention. + + To define a complete set of operator signatures, additional 'left' forms + of the two-argument template forms are provided [`subtractable2\_left`](operators.html#table:subtractable2_left), [`dividable2\_left`](operators.html#table:dividable2_left), and [`modable2\_left`](operators.html#table:modable2_left) that define the signatures for + non-commutative operators where `U` + appears on the left hand side (`operator-(const U&, const T&)`, `operator/(const U&, const T&)`, `operator%(const U&, const T&)`). + + With respect to the performance observe that when one uses the single type + binary operator for mixed type arithmetics, the type `U` + argument has to be converted to type `T`. + In practice, however, there are often more efficient implementations of, + say `T::operator-=(const U&)` that avoid unnecessary conversions + from `U` to `T`. + + The two-argument template forms of the arithmetic operator create additional + operator interfaces that use these more efficient implementations. There + is, however, no performance gain in the 'left' forms: they still need a + conversion from `U` to `T` and have an implementation equivalent + to the code that would be automatically created by the compiler if it considered + the single type binary operator to be the best match. + + + +###### + +[Base + Class Chaining and Object Size](operators.html#utility.utilities.operators.usage.base_class_chaining_and_object_s) + Every operator class template, except the [arithmetic + examples](operators.html#sec:ex_oprs) and the [iterator helpers](operators.html#sec:iterator), + has an additional, but optional, template type parameter `B`. This parameter will be a publicly-derived + base class of the instantiated template. This means it must be a class + type. It can be used to avoid the bloating of object sizes that is commonly + associated with multiple-inheritance from several empty base classes. See + the [note for users of older versions](operators.html#sec:old_lib_note) + for more details. + + To provide support for a group of operators, use the `B` + parameter to chain operator templates into a single-base class hierarchy, + demostrated in the [usage example](operators.html#sec:example). The + technique is also used by the composite operator templates to group operator + definitions. If a chain becomes too long for the compiler to support, try + replacing some of the operator templates with a single grouped operator + template that chains the old templates together; the length limit only + applies to the number of templates directly in the chain, not those hidden + in group templates. + +*Caveat*: to chain to a base class which is *not* + a Boost operator template when using the [single-argument + form](operators.html#sec:two_arg) of a Boost operator template, you must specify the operator + template with the trailing `'1'` + in its name. Otherwise the library will assume you mean to define a binary + operation combining the class you intend to use as a base class and the + class you're deriving. + + + +###### + +[Separate + Explicit Instantiation](operators.html#utility.utilities.operators.usage.separate_explicit_instantiation) + On some compilers (e.g. Borland, GCC) even single-inheritance seems to + cause an increase in object size in some cases. If you are not defining + a class template, you may get better object-size performance by avoiding + derivation altogether, and instead explicitly instantiating the operator + template as follows: + +``` +class my\_class // lose the inheritance... +{ + //... +}; + +// explicitly instantiate the operators I need. +template struct less\_than\_comparable; +template struct equality\_comparable; +template struct incrementable; +template struct decrementable; +template struct addable; +template struct subtractable; + +``` + + + Note that some operator templates cannot use this workaround and must be + a base class of their primary operand type. Those templates define operators + which must be member functions, and the workaround needs the operators + to be independent `friend` functions. + The relevant templates are: + + + +* [`dereferenceable<>`](operators.html#table:dereferenceable) +* [`indexable<>`](operators.html#table:indexable) +* Any composite operator template that includes at least one of the above + + + As Daniel Krugler pointed out, this technique violates C++11 §14.6.5/2 [temp.inject] + and is thus non-portable. The reasoning is, that the operators injected + by the instantiation of e.g. `less\_than\_comparable` can not be found by ADL according to + the rules given by C++11 §3.4.2/2 [basic.lookup.argdep], since `my\_class` is not an associated class of + `less\_than\_comparable`. + Thus only use this technique if all else fails. + + + +###### + +[Requirement + Portability](operators.html#utility.utilities.operators.usage.requirement_portability) + Many compilers (e.g. MSVC 6.3, GCC 2.95.2) will not enforce the requirements + in the operator template tables unless the operations which depend on them + are actually used. This is not standard-conforming behavior. In particular, + although it would be convenient to derive all your classes which need binary + operators from the [`operators<>`](operators.html#table:operators1) and [`operators2<>`](operators.html#table:operators2) + templates, regardless of whether they implement all the requirements of + those templates, this shortcut is not portable. Even if this currently + works with your compiler, it may not work later. + + +#### +[Arithmetic + Operators](operators.html#utility.utilities.operators.arithmetic_operators "Arithmetic Operators") + The arithmetic operator templates ease the task of creating a custom numeric + type. Given a core set of operators, the templates add related operators + to the numeric class. These operations are like the ones the standard arithmetic + types have, and may include comparisons, adding, incrementing, logical + and bitwise manipulations, etc. Further, since most numeric types need + more than one of these operators, some templates are provided to combine + several of the basic operator templates in one declaration. + + The requirements for the types used to instantiate the simple operator + templates are specified in terms of expressions which must be valid and + the expression's return type. The composite operator templates only list + what other templates they use. The supplied operations and requirements + of the composite operator templates can be inferred from the operations + and requirements of the listed components. + + + +###### + +[Simple + Arithmetic Operators](operators.html#utility.utilities.operators.arithmetic_operators.simple_arithmetic_operators) + These templates are "simple" since they provide operators based + on a single operation the base type has to provide. They have an additional + optional template parameter `B`, + which is not shown, for the [base class chaining](operators.html#sec:chaining) + technique. + + The primary operand type `T` + needs to be of class type, built-in types are not supported. + +**Table 1.6. Notation** + +| + Key + | + Description + | +| --- | --- | +| +`T` + | + primary operand type + | +| +`t,t1` + | + values of type `T` + | +| +`U` + | + alternate operand type + | +| +`u` + | + value of type `U` + | + + +**Table 1.7. Simple Arithmetic Operator Template Classes** + + + +| + Template + | + Supplied Operations + | + Requirements + | + Propagates constexpr + | +| --- | --- | --- | --- | +| +`less\_than\_comparable` + + +[`less\_than\_comparable1`](operators.html#sec:arithmetic)`` + | +`bool operator>(const +T&, +const T&)` + + +`bool operator<=(const +T&, +const T&)` + + +`bool operator>=(const +T&, +const T&)` + | +`t < +t1`. + + + Return convertible to `bool`. + See the [Ordering Note](operators.html#sec:ordering) + | + Since `C++11`, except [MSVC + < v19.22](https://developercommunity.visualstudio.com/content/problem/414193/rejects-valid-constexpr-marked-friend-function-def.html) + | +| +`less\_than\_comparable` + + +[`less\_than\_comparable2`](operators.html#sec:arithmetic)`` + | +`bool operator<=(const +T&, +const U&)` + + +`bool operator>=(const +T&, +const U&)` + + +`bool operator>(const +U&, +const T&)` + + +`bool operator<(const +U&, +const T&)` + + +`bool operator<=(const +U&, +const T&)` + + +`bool operator>=(const +U&, +const T&)` + | +`t < +u`. `t +> u`. + + + Returns convertible to `bool`. + See the [Ordering Note](operators.html#sec:ordering). + | + Since `C++11`, except [MSVC + < v19.22](https://developercommunity.visualstudio.com/content/problem/414193/rejects-valid-constexpr-marked-friend-function-def.html) + | +| +`equality\_comparable` + + +[`equality\_comparable1`](operators.html#sec:arithmetic)`` + | +`bool operator!=(const +T&, +const T&)` + | +`t == +t1`. + + + Return convertible to `bool`. + | + Since `C++11`, except [MSVC + < v19.22](https://developercommunity.visualstudio.com/content/problem/414193/rejects-valid-constexpr-marked-friend-function-def.html) + | +| +`equality\_comparable` + + +[`equality\_comparable2`](operators.html#sec:arithmetic)`` + | +`bool operator==(const +U&, +const T&)` + + +`bool operator!=(const +U&, +const T&)` + + +`bool operator!=(const +T&, +const U&)` + | +`t == +u`. + + + Return convertible to `bool`. + | + Since `C++11`, except [MSVC + < v19.22](https://developercommunity.visualstudio.com/content/problem/414193/rejects-valid-constexpr-marked-friend-function-def.html) + | +| +`addable` + + +`addable1` + | +`T operator+(const +T&, +const T&)` + | +`T temp(t); temp ++= t1`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`addable` + + +`addable2` + | +`T operator+(const +T&, +const U&)` + + +`T operator+(const +U&, +const T& )` + | +`T temp(t); temp ++= u`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`subtractable` + + +`subtractable1` + | +`T operator-(const +T&, +const T&)` + | +`T temp(t); temp +-= t1`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`subtractable` + + +`subtractable2` + | +`T operator-(const +T&, +const U&)` + | +`T temp(t); temp +-= u`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`subtractable2\_left` + | +`T operator-(const +U&, +const T&)` + | +`T temp(u); temp +-= t`. + + + Return convertible to `T`. + | + No + | +| +`multipliable` + + +`multipliable1` + | +`T operator\*(const +T&, +const T&)` + | +`T temp(t); temp +\*= t1`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`multipliable` + + +`multipliable2` + | +`T operator\*(const +T&, +const U&)` + + +`T operator\*(const +U&, +const T&)` + | +`T temp(t); temp +\*= u`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`dividable` + + +`dividable1` + | +`T operator/(const +T&, +const T&)` + | +`T temp(t); temp +/= t1`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`dividable` + + +`dividable2` + | +`T operator/(const +T&, +const U&)` + | +`T temp(t); temp +/= u`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`dividable2\_left` + | +`T operator/(const +U&, +const T&)` + | +`T temp(u); temp +/= t`. + + + Return convertible to `T`. + | + No + | +| +`modable` + + +`modable1` + | +`T operator%(const +T&, +const T&)` + | +`T temp(t); temp +%= t1`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`modable` + + +`modable2` + | +`T operator%(const +T&, +const U&)` + | +`T temp(t); temp +%= u`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`modable2\_left` + | +`T operator%(const +U&, +const T&)` + | +`T temp(u); temp +%= t`. + + + Return convertible to `T`. + | + No + | +| +`orable` + + +`orable1` + | +`T operator|(const +T&, +const T&)` + | +`T temp(t); temp +|= t1`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`orable` + + +`orable2` + | +`T operator|(const +T&, +const U&)` + + +`T operator|(const +U&, +const T&)` + | +`T temp(t); temp +|= u`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`andable` + + +`andable1` + | +`T operator&(const +T&, +const T&)` + | +`T temp(t); temp +&= t1`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`andable` + + +`andable2` + | +`T operator&(const +T&, +const U&)` + + +`T operator&(const +U&, +const T&)` + | +`T temp(t); temp +&= u`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`xorable` + + +`xorable1` + | +`T operator^(const +T&, +const T&)` + | +`T temp(t); temp +^= t1`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`xorable` + + +`xorable2` + | +`T operator^(const +T&, +const U&)` + + +`T operator^(const +U&, +const T&)` + | +`T temp(t); temp +^= u`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`incrementable` + | +`T operator++(T&, int)` + | +`T temp(t); ++t` + + + Return convertible to `T`. + | + No + | +| +`decrementable` + | +`T operator--(T&, int)` + | +`T temp(t); --t;` + + + Return convertible to `T`. + | + No + | +| +`left\_shiftable` + + +`left\_shiftable1` + | +`T operator<<(const +T&, +const T&)` + | +`T temp(t); temp +<<= t1`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`left\_shiftable` + + +`left\_shiftable2` + | +`T operator<<(const +T&, +const U&)` + | +`T temp(t); temp +<<= u`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`right\_shiftable` + + +`right\_shiftable1` + | +`T operator>>(const +T&, +const T&)` + | +`T temp(t); temp +>>= t1`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`right\_shiftable` + + +`right\_shiftable2` + | +`T operator>>(const +T&, +const U&)` + | +`T temp(t); temp +>>= u`. + + + Return convertible to `T`. + See the [Symmetry Note](operators.html#sec:symmetry). + | + No + | +| +`equivalent` + + +[`equivalent1`](operators.html#sec:arithmetic)`` + | +`bool operator==(const +T&, +const T&)` + | +`t < +t1`. + + + Return convertible to `bool`. + See the [Ordering Note](operators.html#sec:ordering). + | + Since `C++11`, except [MSVC + < v19.22](https://developercommunity.visualstudio.com/content/problem/414193/rejects-valid-constexpr-marked-friend-function-def.html) + | +| +`equivalent` + + +[`equivalent2`](operators.html#sec:arithmetic)`` + | +`bool operator==(const +T&, +const U&)` + | +`t < +u`. `t +> u`. + + + Returns convertible to `bool`. + See the [Ordering Note](operators.html#sec:ordering). + | + Since `C++11`, except [MSVC + < v19.22](https://developercommunity.visualstudio.com/content/problem/414193/rejects-valid-constexpr-marked-friend-function-def.html) + | +| +`partially\_ordered` + + +[`partially\_ordered1`](operators.html#sec:arithmetic)`` + | +`bool operator>(const +T&, +const T&)` + + +`bool operator<=(const +T&, +const T&)` + + +`bool operator>=(const +T&, +const T&)` + | +`t < +t1`. `t +== t1`. + + + Returns convertible to `bool`. + See the [Ordering Note](operators.html#sec:ordering). + | + Since `C++11`, except [MSVC + < v19.22](https://developercommunity.visualstudio.com/content/problem/414193/rejects-valid-constexpr-marked-friend-function-def.html) + | +| +`partially\_ordered` + + +[`partially\_ordered2`](operators.html#sec:arithmetic)`` + | +`bool operator<=(const +T&, +const U&)` + + +`bool operator>=(const +T&, +const U&)` + + +`bool operator>(const +U&, +const T&)` + + +`bool operator<(const +U&, +const T&)` + + +`bool operator<=(const +U&, +const T&)` + + +`bool operator>=(const +U&, +const T&)` + | +`t < +u`. `t +> u`. + `t == +u`. + + + Returns convertible to `bool`. + See the [Ordering Note](operators.html#sec:ordering). + | + Since `C++11`, except [MSVC + < v19.22](https://developercommunity.visualstudio.com/content/problem/414193/rejects-valid-constexpr-marked-friend-function-def.html) + | + + +*Ordering Note*: The [`less\_than\_comparable`](operators.html#table:less_than_comparable1) and [`partially\_ordered`](operators.html#table:partially_ordered1) + templates provide the same set of operations. However, the workings of + [`less\_than\_comparable`](operators.html#table:less_than_comparable1) assume that all values of type + `T` can be placed in a total + order. If that is not true (e.g. Not-a-Number values in IEEE floating point + arithmetic), then [`partially\_ordered`](operators.html#table:partially_ordered1) + should be used. The [`partially\_ordered`](operators.html#table:partially_ordered1) + template can be used for a totally-ordered type, but it is not as efficient + as [`less\_than\_comparable`](operators.html#table:less_than_comparable1). This rule also applies for + [`less\_than\_comparable`](operators.html#table:less_than_comparable2) + and [`partially\_ordered`](operators.html#table:partially_ordered2) + with respect to the ordering of all `T` + and `U` values, and for both + versions of [`equivalent<>`](operators.html#table:equivalent1). The solution for [`equivalent<>`](operators.html#table:equivalent1) is to write a custom `operator==` + for the target class. + +*Symmetry Note*: Before talking + about symmetry, we need to talk about optimizations to understand the reasons + for the different implementation styles of operators. Let's have a look + at `operator+` + for a class `T` as an example: + +``` +T operator+( const T& lhs, const T& rhs ) +{ + return T( lhs ) += rhs; +} + +``` + + + This would be a normal implementation of `operator+`, but it is not an efficient one. An unnamed + local copy of `lhs` is created, + `operator+=` + is called on it and it is copied to the function return value (which is + another unnamed object of type `T`). + The standard doesn't generally allow the intermediate object to be optimized + away: + +> +> *C++11 §3.7.3/3 [basic.stc.auto]: Automatic storage duration:* +> If a variable with automatic storage duration has initialization or a +> destructor with side effects, it shall not be destroyed before the end +> of its block, nor shall it be eliminated as an optimization even if it +> appears to be unused, except that a class object or its copy/move may +> be eliminated as specified in 12.8. +> +> +> + The reference to §12.8 is important for us: + +> +> +> *C++11 §12.8/31 [class.copy]: Copying and moving class objects:* +> When certain criteria are met, an implementation is allowed to omit the +> copy/move construction of a class object, even if the copy/move constructor +> and/or destructor for the object have side effects. (…) This elision of +> copy/move operations, called *copy elision*, is permitted +> in the following circumstances (which may be combined to eliminate multiple +> copies): +> +> +> +> +> — in a `return` statement in +> a function with a class return type, when the expression is the name +> of a non-volatile automatic object (other than a function or catch-clause +> parameter) with the same cv- unqualified type as the function return +> type, the copy/move operation can be omitted by constructing the automatic +> object directly into the function's return value +> +> +> +> +> (…) +> +> +> +> + This optimization is known as the named return value optimization ([NRVO](https://en.cppreference.com/w/cpp/language/copy_elision#Non-mandatory_elision_of_copy.2Fmove_.28since_C.2B.2B11.29_operations)), + which leads us to the following implementation for `operator+`: + +``` +T operator+( const T& lhs, const T& rhs ) +{ + T nrv( lhs ); + nrv += rhs; + return nrv; +} + +``` + + + Given this implementation, the compiler is allowed to remove the intermediate + object. Sadly, not all compilers implement the NRVO, some even implement + it in an incorrect way which makes it useless here. Without the NRVO, the + NRVO-friendly code is no worse than the original code showed above, but + there is another possible implementation, which has some very special properties: + +``` +T operator+( T lhs, const T& rhs ) +{ + return lhs += rhs; +} + +``` + + + The difference to the first implementation is that `lhs` + is not taken as a constant reference used to create a copy; instead, `lhs` is a by-value parameter, thus it + is already the copy needed. This allows another optimization (C++11 §12.2/2 + [class.temporary]) for some cases. + + Consider `a + +b + +c` where the result of `a + b` is not copied when used as `lhs` when adding `c`. + This is more efficient than the original code, but not as efficient as + a compiler using the NRVO. For most people, it is still preferable for + compilers that don't implement the NRVO, but the `operator+` now has a different function signature. + Also, the number of objects created differs for `(a + b ) + c` and + `a + +( b ++ c +)`. + + Most probably, this won't be a problem for you, but if your code relies + on the function signature or a strict symmetric behaviour, you should set + `BOOST\_FORCE\_SYMMETRIC\_OPERATORS` + in your user-config. This will force the NRVO-friendly implementation to + be used even for compilers that do not implement the NRVO. + + + +###### + +[Grouped + Arithmetic Operators](operators.html#utility.utilities.operators.arithmetic_operators.grouped_arithmetic_operators) + The following templates provide common groups of related operations. For + example, since a type which is addable is usually also subtractable, the + [`additive`](operators.html#table:additive1) + template provides the combined operators of both. The grouped operator + templates have an additional optional template parameter `B`, which is not shown, for the [base class chaining](operators.html#sec:chaining) technique. + +**Table 1.8. Notation** + +| + Key + | + Description + | +| --- | --- | +| +`T` + | + primary operand type + | +| +`U` + | + alternate operand type + | + + +**Table 1.9. Grouped Arithmetic Operator Template Classes** + +| + Template + | + Component Operator Templates + | +| --- | --- | +| +`totally\_ordered` + + +[`totally\_ordered1`](operators.html#sec:arithmetic)`` + | +[`less\_than\_comparable`](operators.html#table:less_than_comparable1) + + +[`equality\_comparable`](operators.html#table:equality_comparable1) + | +| +`totally\_ordered` + + +[`totally\_ordered2`](operators.html#sec:arithmetic)`` + | +[`less\_than\_comparable`](operators.html#table:less_than_comparable2) + + +[`equality\_comparable`](operators.html#table:equality_comparable2) + | +| +`additive` + + +[`additive1`](operators.html#sec:arithmetic)`` + | +[`addable`](operators.html#table:addable1) + + +[`subtractable`](operators.html#table:subtractable1) + | +| +`additive` + + +[`additive2`](operators.html#sec:arithmetic)`` + | +[`addable`](operators.html#table:addable2) + + +[`subtractable`](operators.html#table:subtractable2) + | +| +`multiplicative` + + +[`multiplicative1`](operators.html#sec:arithmetic)`` + | +[`multipliable`](operators.html#table:multipliable1) + + +[`dividable`](operators.html#table:dividable1) + | +| +`multiplicative` + + +[`multiplicative2`](operators.html#sec:arithmetic)`` + | +[`multipliable`](operators.html#table:multipliable2) + + +[`dividable`](operators.html#table:dividable2) + | +| +`integer\_multiplicative` + + +[`integer\_multiplicative1`](operators.html#sec:arithmetic)`` + | +[`multiplicative`](operators.html#table:multiplicative1) + + +[`modable`](operators.html#table:modable1) + | +| +`integer\_multiplicative` + + +[`integer\_multiplicative2`](operators.html#sec:arithmetic)`` + | +[`multiplicative`](operators.html#table:multiplicative2) + + +[`modable`](operators.html#table:modable2) + | +| +`arithmetic` + + +[`arithmetic1`](operators.html#sec:arithmetic)`` + | +[`additive`](operators.html#table:additive1) + + +[`multiplicative`](operators.html#table:multiplicative1) + | +| +`arithmetic` + + +[`arithmetic2`](operators.html#sec:arithmetic)`` + | +[`additive`](operators.html#table:additive2) + + +[`multiplicative`](operators.html#table:multiplicative2) + | +| +`integer\_arithmetic` + + +[`integer\_arithmetic1`](operators.html#sec:arithmetic)`` + | +[`additive`](operators.html#table:additive1) + + +[`integer\_multiplicative`](operators.html#table:integer_multiplicative1) + | +| +`integer\_arithmetic` + + +[`integer\_arithmetic2`](operators.html#sec:arithmetic)`` + | +[`additive`](operators.html#table:additive2) + + +[`integer\_multiplicative`](operators.html#table:integer_multiplicative2) + | +| +`bitwise` + + +[`bitwise1`](operators.html#sec:arithmetic)`` + | +[`xorable`](operators.html#table:xorable1) + + +[`andable`](operators.html#table:andable1) + + +[`orable`](operators.html#table:orable1) + | +| +`bitwise` + + +[`bitwise2`](operators.html#sec:arithmetic)`` + | +[`xorable`](operators.html#table:xorable2) + + +[`andable`](operators.html#table:andable2) + + +[`orable`](operators.html#table:orable2) + | +| +`unit\_steppable` + | +[`incrementable`](operators.html#table:incrementable) + + +[`decrementable`](operators.html#table:decrementable) + | +| +`shiftable` + + +[`shiftable1`](operators.html#sec:arithmetic)`` + | +[`left\_shiftable`](operators.html#table:left_shiftable1) + + +[`right\_shiftable`](operators.html#table:right_shiftable1) + | +| +`shiftable` + + +[`shiftable2`](operators.html#sec:arithmetic)`` + | +[`left\_shiftable`](operators.html#table:left_shiftable2) + + +[`right\_shiftable`](operators.html#table:right_shiftable2) + | +| +`ring\_operators` + + +[`ring\_operators1`](operators.html#sec:arithmetic)`` + | +[`additive`](operators.html#table:additive1) + + +[`multipliable`](operators.html#table:multipliable1) + | +| +`ring\_operators` + + +[`ring\_operators2`](operators.html#sec:arithmetic)`` + | +[`additive`](operators.html#table:additive2) + + +[`subtractable2\_left`](operators.html#table:subtractable2_left) + + +[`multipliable`](operators.html#table:multipliable2) + | +| +`ordered\_ring\_operators` + + +[`ordered\_ring\_operators1`](operators.html#sec:arithmetic)`` + | +[`ring\_operators`](operators.html#table:ring_operators1) + + +[`totally\_ordered`](operators.html#table:totally_ordered1) + | +| +`ordered\_ring\_operators` + + +[`ordered\_ring\_operators2`](operators.html#sec:arithmetic)`` + | +[`ring\_operators`](operators.html#table:ring_operators2) + + +[`totally\_ordered`](operators.html#table:totally_ordered2) + | +| +`field\_operators` + + +[`field\_operators1`](operators.html#sec:arithmetic)`` + | +[`ring\_operators`](operators.html#table:ring_operators1) + + +[`dividable`](operators.html#table:dividable1) + | +| +`field\_operators` + + +[`field\_operators2`](operators.html#sec:arithmetic)`` + | +[`ring\_operators`](operators.html#table:ring_operators2) + + +[`dividable`](operators.html#table:dividable2) + + +[`dividable2\_left`](operators.html#table:dividable2_left) + | +| +`ordered\_field\_operators` + + +[`ordered\_field\_operators1`](operators.html#sec:arithmetic)`` + | +[`field\_operators`](operators.html#table:field_operators1) + + +[`totally\_ordered`](operators.html#table:totally_ordered1) + | +| +`ordered\_field\_operators` + + +[`ordered\_field\_operators2`](operators.html#sec:arithmetic)`` + | +[`field\_operators`](operators.html#table:field_operators2) + + +[`totally\_ordered`](operators.html#table:totally_ordered2) + | +| +`euclidean\_ring\_operators` + + +[`euclidean\_ring\_operators1`](operators.html#sec:arithmetic)`` + | +[`ring\_operators`](operators.html#table:ring_operators1) + + +[`dividable`](operators.html#table:dividable1) + + +[`modable`](operators.html#table:modable1) + | +| +`euclidean\_ring\_operators` + + +[`euclidean\_ring\_operators2`](operators.html#sec:arithmetic)`` + | +[`ring\_operators`](operators.html#table:ring_operators2) + + +[`dividable`](operators.html#table:dividable2) + + +[`dividable2\_left`](operators.html#table:dividable2_left) + + +[`modable`](operators.html#table:modable2) + + +[`modable2\_left`](operators.html#table:modable2_left) + | +| +`ordered\_euclidean\_ring\_operators` + + +[`ordered\_euclidean\_ring\_operators1`](operators.html#sec:arithmetic)`` + | +[`euclidean\_ring\_operators`](operators.html#table:euclidean_ring_operators1) + + +[`totally\_ordered`](operators.html#table:totally_ordered1) + | +| +`ordered\_euclidean\_ring\_operators` + + +[`ordered\_euclidean\_ring\_operators2`](operators.html#sec:arithmetic)`` + | +[`euclidean\_ring\_operators`](operators.html#table:euclidean_ring_operators2) + + +[`totally\_ordered`](operators.html#table:totally_ordered2) + | + + +*Spelling: euclidean vs. euclidian*: Older versions + of the Boost.Operators library used "`euclidian`", + but it was pointed out that "`euclidean`" + is the more common spelling. To be compatible with older version, the library + now supports both spellings. + + + +###### + +[Example + Templates](operators.html#utility.utilities.operators.arithmetic_operators.example_templates) + The arithmetic operator class templates [`operators<>`](operators.html#table:operators1) + and [`operators2<>`](operators.html#table:operators2) are examples of non-extensible + operator grouping classes. These legacy class templates, from previous + versions of the header, cannot be used for [base + class chaining](operators.html#sec:chaining). + +**Table 1.10. Notation** + +| + Key + | + Description + | +| --- | --- | +| +`T` + | + primary operand type + | +| +`U` + | + alternate operand type + | + + +**Table 1.11. Final Arithmetic Operator Template Classes** + +| + Template + | + Component Operator Templates + | +| --- | --- | +| +[`operators`](operators.html#sec:arithmetic)`` + | +[`totally\_ordered`](operators.html#table:totally_ordered1) + + +[`integer\_arithmetic`](operators.html#table:integer_arithmetic1) + + +[`bitwise`](operators.html#table:bitwise1) + + +[`unit\_steppable`](operators.html#table:unit_steppable) + | +| +[`operators`](operators.html#sec:arithmetic)`` + + +[`operators2`](operators.html#sec:arithmetic)`` + | +[`totally\_ordered`](operators.html#table:totally_ordered2) + + +[`integer\_arithmetic`](operators.html#table:integer_arithmetic2) + + +[`bitwise`](operators.html#table:bitwise2) + | + + +*Arithmetic Operators Demonstration and + Test Program*: The [`operators\_test.cpp`](../../../../../test/operators_test.cpp) program demonstrates the + use of the arithmetic operator templates, and can also be used to verify + correct operation. Check the compiler status report for the test results + with selected platforms. + + +#### +[Dereference + Operators and Iterator Helpers](operators.html#utility.utilities.operators.dereference_operators_and_iterat "Dereference Operators and Iterator Helpers") + The [iterator helper](operators.html#sec:iterator) templates ease + the task of creating a custom iterator. Similar to arithmetic types, a + complete iterator has many operators that are "redundant" and + can be implemented in terms of the core set of operators. + + The [dereference operators](operators.html#sec:dereference) were motivated + by the [iterator helpers](operators.html#sec:iterator), but are often + useful in non-iterator contexts as well. Many of the redundant iterator + operators are also arithmetic operators, so the iterator helper classes + borrow many of the operators defined above. In fact, only two new operators + need to be defined: the pointer-to-member `operator->` and the subscript `operator[]`. + + The requirements for the types used to instantiate the dereference operators + are specified in terms of expressions which must be valid and their return + type. The composite operator templates list their component templates, + which the instantiating type must support, and possibly other requirements. + + + +###### + +[Dereference + Operators](operators.html#utility.utilities.operators.dereference_operators_and_iterat.dereference_operators) + All the dereference operator templates in this table accept an optional + template parameter (not shown) to be used for [base + class chaining](operators.html#sec:chaining). + +**Table 1.12. Notation** + +| + Key + | + Description + | +| --- | --- | +| +`T` + | + operand type + | +| +`D` + | +`difference\_type` + | +| +`i` + | + object of type `T` + (an iterator) + | +| +`P` + | +`pointer` type + | +| +`R` + | +`reference` type + | +| +`n` + | + object of type `D` + (an index) + | + + +**Table 1.13. Dereference Operator Template Classes** + + +| + Template + | + Supplied Operations + | + Requirements + | +| --- | --- | --- | +| +[`dereferenceable`](operators.html#sec:arithmetic)`` + | +`P operator->() const` + | +`\*i`. + Address of the returned value convertible to `P`. + | +| +[`indexable`](operators.html#sec:arithmetic)`` + | +`R operator[](D +n) +const` + | +`\*(i ++ n)`. Return of type `R`. + | + +###### + +[Grouped + Iterator Operators](operators.html#utility.utilities.operators.dereference_operators_and_iterat.grouped_iterator_operators) + There are five iterator operator class templates, each for a different + category of iterator. The following table shows the operator groups for + any category that a custom iterator could define. These class templates + have an additional optional template parameter `B`, + which is not shown, to support [base class + chaining](operators.html#sec:chaining). + +**Table 1.14. Notation** + +| + Key + | + Description + | +| --- | --- | +| +`T` + | + operand type + | +| +`D` + | +`difference\_type` + | +| +`V` + | +`value\_type` + | +| +`P` + | +`pointer` type + | +| +`R` + | +`reference` type + | + + +**Table 1.15. Iterator Operator Class Templates** + +| + Template + | + Component Operator Templates + | +| --- | --- | +| +[`input\_iteratable`](operators.html#sec:arithmetic)`` + | +[`equality\_comparable`](operators.html#table:equality_comparable1) + + +[`incrementable`](operators.html#table:incrementable) + + +[`dereferenceable`](operators.html#table:dereferenceable) + | +| +[`output\_iteratable`](operators.html#sec:arithmetic)`` + | +[`incrementable`](operators.html#table:incrementable) + | +| +[`forward\_iteratable`](operators.html#sec:arithmetic)`` + | +[`input\_iteratable`](operators.html#table:input_iteratable) + | +| +[`bidirectional\_iteratable`](operators.html#sec:arithmetic)`` + | +[`forward\_iteratable`](operators.html#table:forward_iteratable) + + +[`decrementable`](operators.html#table:decrementable) + | +| +[`random\_access\_iteratable`](operators.html#sec:arithmetic)`` + | +[`bidirectional\_iteratable`](operators.html#table:bidirectional_iteratable) + + +[`totally\_ordered`](operators.html#table:totally_ordered1) + + +[`additive`](operators.html#table:additive2) + + +[`indexable`](operators.html#table:indexable) + | + +###### + +[Iterator + Helpers](operators.html#utility.utilities.operators.dereference_operators_and_iterat.iterator_helpers) + There are also five iterator helper class templates, each corresponding + to a different iterator category. These classes cannot be used for [base class chaining](operators.html#sec:chaining). The following summaries + show that these class templates supply both the iterator operators from + the [iterator operator class templates](operators.html#sec:grpd_iter_oprs) + and the iterator `typedef`s + required by the C++ standard, such as `iterator\_category` + and `value\_type`. + +**Table 1.16. Notation** + +| + Key + | + Description + | +| --- | --- | +| +`T` + | + operand type + | +| +`D` + | +`difference\_type` + | +| +`V` + | +`value\_type` + | +| +`P` + | +`pointer` type + | +| +`R` + | +`reference` type + | +| +`x1`, `x2` + | + objects of type `T` + | + + +**Table 1.17. Helper Class Templates** + +| + Template + | + Operations and Requirements + | +| --- | --- | +| +[`input\_iterator\_helper`](operators.html#sec:arithmetic)`` + | + Supports the operations and has the requirements of [`input\_iteratable`](operators.html#table:input_iteratable) + | +| +[`output\_iterator\_helper`](operators.html#sec:arithmetic)`` + | + Supports the operations and has the requirements of [`output\_iteratable`](operators.html#table:output_iteratable) + + + See also [[1](operators.html#note:1)], [[2](operators.html#note:2)]. + | +| +[`forward\_iterator\_helper`](operators.html#sec:arithmetic)`` + | + Supports the operations and has the requirements of [`forward\_iteratable`](operators.html#table:forward_iteratable) + | +| +[`bidirectional\_iterator\_helper`](operators.html#sec:arithmetic)`` + | + Supports the operations and has the requirements of [`bidirectional\_iteratable`](operators.html#table:bidirectional_iteratable) + | +| +[`random\_access\_iterator\_helper`](operators.html#sec:arithmetic)`` + | + Supports the operations and has the requirements of [`random\_access\_iteratable`](operators.html#table:random_access_iteratable) + + + To satisfy [*RandomAccessIterator*](https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator), + `x1 - +x2` with return convertible + to `D` is also + required. + | + + +*Iterator Helper Notes*: + + + +1. Unlike other iterator helpers templates, [`output\_iterator\_helper`](operators.html#sec:arithmetic) + takes only one template parameter - the type of its target class. Although + to some it might seem like an unnecessary restriction, the standard + requires `difference\_type` + and `value\_type` of any + output iterator to be `void` + (C++11 §24.4.1 [lib.iterator.traits]), and [`output\_iterator\_helper`](operators.html#sec:arithmetic) template + respects this requirement. Also, output iterators in the standard have + void `pointer` and `reference` types, so the [`output\_iterator\_helper`](operators.html#sec:arithmetic) does + the same. +2. As self-proxying is the easiest and most common + way to implement output iterators (see, for example, insert (C++11 + §24.5.2 [insert.iterators]) and stream iterators (C++11 §24.6 [stream.iterators]) + in the standard library), [`output\_iterator\_helper`](operators.html#sec:arithmetic) supports + the idiom by defining `operator\*` and `operator++` member functions which just return + a non-const reference to the iterator itself. Support for self-proxying + allows us, in many cases, to reduce the task of writing an output iterator + to writing just two member functions - an appropriate constructor and + a copy-assignment operator. For example, here is a possible implementation + of [`boost::function\_output\_iterator`](../../../../../../libs/iterator/doc/function_output_iterator.html) + adaptor: + + +``` +template +struct function\_output\_iterator + : boost::[`output\_iterator\_helper`](operators.html#sec:arithmetic)< function\_output\_iterator > +{ + explicit function\_output\_iterator(UnaryFunction const& f = UnaryFunction()) + : func(f) {} + + template + function\_output\_iterator& operator=(T const& value) + { + this->func(value); + return \*this; + } + +private: + UnaryFunction func; +}; + +``` + + + Note that support for self-proxying does not prevent you from using [`output\_iterator\_helper`](operators.html#sec:arithmetic) + to ease any other, different kind of output iterator's implementation. + If [`output\_iterator\_helper`](operators.html#sec:arithmetic)'s + target type provides its own definition of `operator\*` or/and `operator++`, then these operators will get used and + the ones supplied by [`output\_iterator\_helper`](operators.html#sec:arithmetic) + will never be instantiated. + + + +###### + +[Iterator + Demonstration and Test Program](operators.html#utility.utilities.operators.dereference_operators_and_iterat.iterator_demonstration_and_test_) + The [`iterators\_test.cpp`](../../../../../test/iterators_test.cpp) + program demonstrates the use of the iterator templates, and can also be + used to verify correct operation. The following is the custom iterator + defined in the test program. It demonstrates a correct (though trivial) + implementation of the core operations that must be defined in order for + the iterator helpers to "fill in" the rest of the iterator operations. + +``` +template +struct test\_iter + : public boost::[`random\_access\_iterator\_helper`](operators.html#sec:arithmetic)< + test\_iter, T, [`std::ptrdiff\_t`](https://en.cppreference.com/w/cpp/types/ptrdiff_t), P, R + > +{ + typedef test\_iter self; + typedef R Reference; + typedef [`std::ptrdiff\_t`](https://en.cppreference.com/w/cpp/types/ptrdiff_t) Distance; + +public: + explicit test\_iter(T\* i =0); + test\_iter(const self& x); + self& operator=(const self& x); + Reference operator\*() const; + self& operator++(); + self& operator--(); + self& operator+=(Distance n); + self& operator-=(Distance n); + bool operator==(const self& x) const; + bool operator<(const self& x) const; + friend Distance operator-(const self& x, const self& y); +}; + +``` + + + Check the [compiler + status report](http://www.boost.org/development/testing.html) for the test results with selected platforms. + + +#### +[Note + for Users of Older Versions](operators.html#utility.utilities.operators.note_for_users_of_older_versions "Note for Users of Older Versions") + The [changes in the library interface and recommended + usage](operators.html#sec:chaining) were motivated by some practical issues described below. The + new version of the library is still backward-compatible with the former + one, so you are not *forced* to change any existing + code, but the old usage is deprecated. + + Though it was arguably simpler and more intuitive than using [base + class chaining](operators.html#sec:chaining), it has been discovered that the old practice of + deriving from multiple operator templates can cause the resulting classes + to be much larger than they should be. Most modern C++ compilers significantly + bloat the size of classes derived from multiple empty base classes, even + though the base classes themselves have no state. For instance, the size + of `point` + from the [example](operators.html#sec:example) above was 12-24 bytes + on various compilers for the Win32 platform, instead of the expected 8 + bytes. + + Strictly speaking, it was not the library's fault – the language rules allow + the compiler to apply the [empty + base class optimization](https://en.cppreference.com/w/cpp/language/ebo) in that situation. In principle an arbitrary + number of empty base classes can be allocated at the same offset, provided + that none of them have a common ancestor (see §10 [class.derived] paragraph + 8 of the C++11 standard). + + But the language definition also does not *require* + implementations to do the optimization, and few if any of today's compilers + implement it when multiple inheritance is involved. What's worse, it is + very unlikely that implementors will adopt it as a future enhancement to + existing compilers, because it would break binary compatibility between + code generated by two different versions of the same compiler. As Matt + Austern said, "One of the few times when you have the freedom to do + this sort of thing is when you are targeting a new architecture…". + On the other hand, many common compilers will use the empty base optimization + for single inheritance hierarchies. + + Given the importance of the issue for the users of the library (which aims + to be useful for writing light-weight classes like `MyInt` + or `point<>`), + and the forces described above, we decided to change the library interface + so that the object size bloat could be eliminated even on compilers that + support only the simplest form of the empty base class optimization. The + current library interface is the result of those changes. Though the new + usage is a bit more complicated than the old one, we think it's worth it + to make the library more useful in real world. Alexy Gurtovoy contributed + the code which supports the new usage idiom while allowing the library + to remain backward-compatible. + + +#### +[Acknowledgments](operators.html#utility.utilities.operators.acknowledgments "Acknowledgments") + + +* [Dave Abrahams](http://www.boost.org/people/dave_abrahams.htm): + Started the library and contributed the arithmetic operators in [`boost/operators.hpp`](../../../../../../boost/operators.hpp). +* [Jeremy Siek](http://www.boost.org/people/jeremy_siek.htm): + Contributed the [dereference operators and + iterator helpers](operators.html#sec:deref) in [boost/operators.hpp](../../../../../../boost/operators.hpp). + Also contributed [iterators\_test.cpp](../../../../../test/iterators_test.cpp). +* [Aleksey + Gurtovoy](http://www.boost.org/people/aleksey_gurtovoy.htm): Contributed the code to support [base + class chaining](operators.html#sec:chaining) while remaining backward-compatible with old + versions of the library. +* [Beman Dawes](http://www.boost.org/people/beman_dawes.html): + Contributed [`operators\_test.cpp`](../../../../../test/operators_test.cpp). +* [Daryle + Walker](http://www.boost.org/people/daryle_walker.html): Contributed classes for the shift operators, equivalence, + partial ordering, and arithmetic conversions. Added the grouped operator + classes. Added helper classes for input and output iterators. +* Helmut Zeisel: Contributed the 'left' operators and added some grouped + operator classes. +* Daniel Frey: Contributed the NRVO-friendly and symmetric implementation + of arithmetic operators. + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](../../boost/typed_in_idm35151228676656.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](result_of.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/result_of.html b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/result_of.html new file mode 100644 index 0000000..687d4e4 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/result_of.html @@ -0,0 +1,475 @@ +--- +title: Result of +copyright: +revised: +--- + + +Result of + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../../index.html) | [Libraries](../../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../../more/index.htm) | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](operators.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](../../boost/result_of.html) + + +### +[Result of](result_of.html "Result of") +[Introduction](result_of.html#utility.utilities.result_of.introduction) +[Usage guidelines for `boost::result\_of`](result_of.html#utility.utilities.result_of.usage_guidelines_for_boost_resul) +[Usage + guidelines for the TR1 result\_of protocol](result_of.html#utility.utilities.result_of.usage_guidelines_for_the_tr1_res) +[Known differences between `boost::result\_of` + and `boost::tr1\_result\_of`](result_of.html#utility.utilities.result_of.known_differences_between_boost_) +[Known differences between + `boost::result\_of` + and C++11 result\_of](result_of.html#utility.utilities.result_of.known_differences_between_boost0) +[Reference](result_of.html#result_of.reference) +[Acknowledgments](result_of.html#utility.utilities.result_of.acknowledgments) + + +#### +[Introduction](result_of.html#utility.utilities.result_of.introduction "Introduction") + The class template [`result\_of`](../../boost/result_of.html "Struct template result_of") + helps determine the type of a call expression. For example, given an lvalue + `f` of type `F` and lvalues `t1`,`t2`, ..., `tN` + of types `T1`, `T2`, ..., `TN`, + respectively, the type [`result\_of`](../../boost/result_of.html "Struct template result_of")`::type` + defines the result type of the expression `f(t1, +t2, +...,tN)`. + + This implementation permits the type `F` + to be a function pointer, function reference, member function pointer, + or class type. By default, N may be any value between 0 and 16. To change + the upper limit, define the macro `BOOST\_RESULT\_OF\_NUM\_ARGS` + to the maximum value for N. Class template [`result\_of`](../../boost/result_of.html "Struct template result_of") resides in the header + [``](../../../../../../boost/utility/result_of.hpp). + + If your compiler's support for [`decltype`](https://en.cppreference.com/w/cpp/language/decltype) is adequate, [`result\_of`](../../boost/result_of.html "Struct template result_of") automatically uses it + to deduce the type of the call expression, in which case [`result\_of`](../../boost/result_of.html "Struct template result_of")`::type` names the type [`decltype`](https://en.cppreference.com/w/cpp/language/decltype)`(boost::declval()(boost::declval(), boost::declval(), ..., boost::declval()))`, as in the following example. + +``` +struct functor { + template + T operator()(T x) + { + return x; + } +}; + +typedef [`boost::result\_of`](../../boost/result_of.html "Struct template result_of")::type type; // type is int + +``` + + + You can test whether [`result\_of`](../../boost/result_of.html "Struct template result_of") + is using [`decltype`](https://en.cppreference.com/w/cpp/language/decltype) by checking if the macro + `BOOST\_RESULT\_OF\_USE\_DECLTYPE` + is defined after including `result\_of.hpp`. + You can also force [`result\_of`](../../boost/result_of.html "Struct template result_of") + to use [`decltype`](https://en.cppreference.com/w/cpp/language/decltype) by defining `BOOST\_RESULT\_OF\_USE\_DECLTYPE` prior to + including `result\_of.hpp`. + + If [`decltype`](https://en.cppreference.com/w/cpp/language/decltype) is not used, then automatic + result type deduction of function objects is not possible. Instead, [`result\_of`](../../boost/result_of.html "Struct template result_of") + uses the following protocol to allow the programmer to specify a type. + When `F` is a class type + with a member type `result\_type`, + `result\_of::type` is `F::result\_type`. + When `F` does not contain + `result\_type`, `result\_of::type` is `F::result::type` + when `N > +0` or `void` + when `N = +0`. + + Note that it is the responsibility of the programmer to ensure that function + objects accurately advertise their result type via this protocol, as in + the following example. + +``` +struct functor { + template struct result; + + template + struct result { + typedef T type; + }; + + template + T operator()(T x) + { + return x; + } +}; + +typedef [`boost::result\_of`](../../boost/result_of.html "Struct template result_of")::type type; // type is int + +``` + + + Since [`decltype`](https://en.cppreference.com/w/cpp/language/decltype) is a language feature standardized + in C++11, if you are writing a function object to be used with [`result\_of`](../../boost/result_of.html "Struct template result_of"), for maximum portability, + you might consider following the above protocol even if your compiler has + proper [`decltype`](https://en.cppreference.com/w/cpp/language/decltype) support. + + If you wish to continue to use the protocol on compilers that support + [`decltype`](https://en.cppreference.com/w/cpp/language/decltype), there are two options: + + + +* You can use [`boost::tr1\_result\_of`](../../boost/tr1_result_of.html "Struct template tr1_result_of"), + which is also defined in [``](../../../../../boost/utility/result_of.hpp). +* Alternatively, you can define the macro `BOOST\_RESULT\_OF\_USE\_TR1`, + which causes [`result\_of`](../../boost/result_of.html "Struct template result_of") + to use the protocol described above instead of [`decltype`](https://en.cppreference.com/w/cpp/language/decltype). If you choose to follow + the protocol, take care to ensure that the `result\_type` + and `result<>` + members accurately represent the return type of `operator()` given a call expression. + + + Additionally, [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") + provides a third mode of operation, which some users may find convenient. + When `BOOST\_RESULT\_OF\_USE\_TR1\_WITH\_DECLTYPE\_FALLBACK` + is defined, [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") + behaves as follows. If the function object has a member type `result\_type` or member template `result<>`, + then [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") + will use the TR1 protocol. + + Otherwise, [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") + will use [`decltype`](https://en.cppreference.com/w/cpp/language/decltype). Using TR1 with a [`decltype`](https://en.cppreference.com/w/cpp/language/decltype) fallback may workaround + certain problems at the cost of portability. For example: + + + +* Deficient compiler: If your code requires [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") to work with incomplete + return types but your compiler's [`decltype`](https://en.cppreference.com/w/cpp/language/decltype) implementation does + not support incomplete return types, then you can use the TR1 protocol + as a workaround. Support for incomplete return types was added late + in the C++11 standardization process (see [N3276](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3276.pdf)) + and is not implemented by some compilers. +* Deficient legacy code: If your existing TR1 function object advertises + a different type than the actual result type deduced by [`decltype`](https://en.cppreference.com/w/cpp/language/decltype), then using TR1 with + a [`decltype`](https://en.cppreference.com/w/cpp/language/decltype) fallback will allow + you to work with both your existing TR1 function objects and new C++11 + function object. This situation could occur if your legacy function + objects misused the TR1 protocol. See the documentation on known [differences](result_of.html#sec:result_of_tr1_diff) between [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") and TR1. +* This implementation of [`result\_of`](../../boost/result_of.html "Struct template result_of") requires class template + partial specialization, the ability to parse function types properly, + and support for SFINAE. If [`result\_of`](../../boost/result_of.html "Struct template result_of") is not supported + by your compiler, including the header [``](../../../../../boost/utility/result_of.hpp) will define the macro + `BOOST\_NO\_RESULT\_OF`. + + + For additional information about [`result\_of`](../../boost/result_of.html "Struct template result_of"), see the C++ Library + Technical Report, [N1836](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf), + or, for motivation and design rationale, the [`result\_of`](../../boost/result_of.html "Struct template result_of") [proposal](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1454.html). + + +#### +Usage guidelines for [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") + The following are general suggestions about when and how to use [`boost::result\_of`](../../boost/result_of.html "Struct template result_of"). + + + +1. If you are targeting C++11 and are not concerned about portability + to non-compliant compilers or previous versions of the standard, then + use `[`std::result\_of`](https://en.cppreference.com/w/cpp/types/result_of)`. If `[`std::result\_of`](https://en.cppreference.com/w/cpp/types/result_of)` meets your + needs, then there's no reason to stop using it. +2. If you are targeting C++11 but may port your code to legacy compilers + at some time in the future, then use [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") with [`decltype`](https://en.cppreference.com/w/cpp/language/decltype). When [`decltype`](https://en.cppreference.com/w/cpp/language/decltype) is used [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") and `[`std::result\_of`](https://en.cppreference.com/w/cpp/types/result_of)` are usually + interchangeable. See the documentation on known [differences](result_of.html#sec:result_of_cxx11_diff) + between [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") + and C++11 [`std::result\_of`](https://en.cppreference.com/w/cpp/types/result_of). +3. If compiler portability is required, use [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") with the TR1 protocol + + + Regardless of how you configure [`boost::result\_of`](../../boost/result_of.html "Struct template result_of"), it is important to + bear in mind that the return type of a function may change depending on + its arguments, and additionally, the return type of a member function may + change depending on the cv-qualification of the object. [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") must be passed the appropriately + cv-qualified types in order to deduce the corresponding return type. + + For example: + +``` +struct functor { + int& operator()(int); + int const& operator()(int) const; + + float& operator()(float&); + float const& operator()(float const&); +}; + +typedef [`boost::result\_of`](../../boost/result_of.html "Struct template result_of")< + functor(int) +>::type type1; // type1 is int & + +typedef [`boost::result\_of`](../../boost/result_of.html "Struct template result_of")< + const functor(int) +>::type type2; // type2 is int const & + +typedef [`boost::result\_of`](../../boost/result_of.html "Struct template result_of")< + functor(float&) +>::type type3; // type3 is float & + +typedef [`boost::result\_of`](../../boost/result_of.html "Struct template result_of")< + functor(float const&) +>::type type4; // type4 is float const & + +``` +#### +[Usage + guidelines for the TR1 result\_of protocol](result_of.html#utility.utilities.result_of.usage_guidelines_for_the_tr1_res "Usage guidelines for the TR1 result_of protocol") + On compliant C++11 compilers, [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") can use [`decltype`](https://en.cppreference.com/w/cpp/language/decltype) to deduce the type of any + call expression, including calls to function objects. However, on pre-C++11 + compilers or on compilers without adequate decltype support, additional + scaffolding is needed from function objects as described above. The following + are suggestions about how to use the TR1 protocol. + + + +* When the return type does not depend on the argument types or the cv-qualification + of the function object, simply define `result\_type`. + There is no need to use the `result` + template unless the return type varies. +* Use the protocol specified type when defining function prototypes. + This can help ensure the actual return type does not get out of sync + with the protocol specification. For example: + + +``` +struct functor { + typedef int result\_type; + result\_type operator()(int); +}; + +``` + +* Always specify the `result` + specialization near the corresponding `operator()` overload. This can make it easier + to keep the specializations in sync with the overloads. For example: + + +``` +struct functor { + template struct result; + + template + struct result { + typedef int& type; + }; + result::type operator()(int); + + template + struct result { + typedef int const& type; + }; + result::type operator()(int) const; +}; + +``` + +* Use type transformations to simplify the `result` + template specialization. For example, the following uses [Boost.TypeTraits](../../../type_traits/doc/html/index.html) + to specialize the `result` + template for a single `operator()` that can be called on both a const + and non-const function object with either an lvalue or rvalue argument. + + +``` +struct functor { + template struct result; + + template + struct result + : boost::remove\_cv< + typename boost::remove\_reference::type + > + {}; + + template + T operator()(T const& x) const; +}; + +``` +#### +Known differences between [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") + and [`boost::tr1\_result\_of`](../../boost/tr1_result_of.html "Struct template tr1_result_of") + When using [`decltype`](https://en.cppreference.com/w/cpp/language/decltype), [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") ignores the TR1 protocol + and instead deduces the return type of function objects directly via [`decltype`](https://en.cppreference.com/w/cpp/language/decltype). In most situations, users + will not notice a difference, so long as they use the protocol correctly. + The following are situations in which the type deduced by [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") is known to differ depending + on whether [`decltype`](https://en.cppreference.com/w/cpp/language/decltype) or the TR1 protocol is + used. + + TR1 protocol misusage: When using the TR1 protocol, [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") cannot detect whether + the actual type of a call to a function object is the same as the type + specified by the protocol, which allows for the possibility of inadvertent + mismatches between the specified type and the actual type. When using + [`decltype`](https://en.cppreference.com/w/cpp/language/decltype), these subtle bugs may + result in compilation errors. For example: + +``` +struct functor { + typedef short result\_type; + int operator()(short); +}; + +#ifdef BOOST\_RESULT\_OF\_USE\_DECLTYPE + +BOOST\_STATIC\_ASSERT(( + boost::is\_same<[`boost::result\_of`](../../boost/result_of.html "Struct template result_of")::type, int>::value +)); + +#else + +BOOST\_STATIC\_ASSERT(( + boost::is\_same<[`boost::result\_of`](../../boost/result_of.html "Struct template result_of")::type, short>::value +)); + +#endif + +``` + + + Note that the user can force [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") to use the TR1 protocol + even on platforms that support [`decltype`](https://en.cppreference.com/w/cpp/language/decltype) by defining `BOOST\_RESULT\_OF\_USE\_TR1`. + + Nullary function objects: When using the TR1 protocol, [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") cannot always deduce + the type of calls to nullary function objects, in which case the type defaults + to void. When using [`decltype`](https://en.cppreference.com/w/cpp/language/decltype), [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") always gives the actual + type of the call expression. For example: + +``` +struct functor { + template struct result { + typedef int type; + }; + int operator()(); +}; + +#ifdef BOOST\_RESULT\_OF\_USE\_DECLTYPE + +BOOST\_STATIC\_ASSERT(( + boost::is\_same<[`boost::result\_of`](../../boost/result_of.html "Struct template result_of")::type, int>::value +)); + +#else + +BOOST\_STATIC\_ASSERT(( + boost::is\_same<[`boost::result\_of`](../../boost/result_of.html "Struct template result_of")::type, void>::value +)); + +#endif + +``` + + + Note that there are some workarounds for the nullary function problem. + So long as the return type does not vary, `result\_type` + can always be used to specify the return type regardless of arity. If the + return type does vary, then the user can specialize [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") itself for nullary calls. + + Non-class prvalues and cv-qualification: When using the TR1 protocol, + [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") + will report the cv-qualified type specified by `result\_type` + or the `result` template + regardless of the actual cv-qualification of the call expression. When + using [`decltype`](https://en.cppreference.com/w/cpp/language/decltype), [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") will report the actual + type of the call expression, which is not cv-qualified when the expression + is a non-class prvalue. For example: + +``` +struct functor { + template struct result; + template struct result { + typedef const T type; + }; + + const short operator()(const short); + int const & operator()(int const &); +}; + +// Non-prvalue call expressions work the same with or without decltype. + +BOOST\_STATIC\_ASSERT(( + boost::is\_same< + [`boost::result\_of`](../../boost/result_of.html "Struct template result_of")::type, + int const & +::value +)); + +// Non-class prvalue call expressions are not actually cv-qualified, +// but only the decltype-based result\_of reports this accurately. + +#ifdef BOOST\_RESULT\_OF\_USE\_DECLTYPE + +BOOST\_STATIC\_ASSERT(( + boost::is\_same< + [`boost::result\_of`](../../boost/result_of.html "Struct template result_of")::type, + short +::value +)); + +#else + +BOOST\_STATIC\_ASSERT(( + boost::is\_same< + [`boost::result\_of`](../../boost/result_of.html "Struct template result_of")::type, + const short +::value +)); + +#endif + +``` +#### +Known differences between + [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") + and C++11 result\_of + When using [`decltype`](https://en.cppreference.com/w/cpp/language/decltype), [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") implements most of the + C++11 [`std::result\_of`](https://en.cppreference.com/w/cpp/types/result_of) specification. One + known exception is that [`boost::result\_of`](../../boost/result_of.html "Struct template result_of") + does not implement the requirements regarding pointers to member data. + + +#### +Reference +##### +Header <[boost/utility/result\_of.hpp](../../../../../../boost/utility/result_of.hpp)> +``` +namespace boost { + template struct [result\_of](../../boost/result_of.html "Struct template result_of"); + template struct [tr1\_result\_of](../../boost/tr1_result_of.html "Struct template tr1_result_of"); +} +``` + +#### +[Acknowledgments](result_of.html#utility.utilities.result_of.acknowledgments "Acknowledgments") + Created by Doug Gregor. Contributions from Daniel Walker, Eric Niebler, + Michel Morin and others. + + + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](operators.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](../../boost/result_of.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/string_view.html b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/string_view.html new file mode 100644 index 0000000..663f430 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/string_view.html @@ -0,0 +1,455 @@ +--- +title: String View +copyright: +revised: +--- + + +String View + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../../index.html) | [Libraries](../../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../../more/index.htm) | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](../../boost/tr1_result_of.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](../../boost/basic_string_view.html) + + +### +[String View](string_view.html "String View") +[Introduction](string_view.html#utility.utilities.string_view.introduction) +[Examples](string_view.html#utility.utilities.string_view.examples) +[Synopsis](string_view.html#utility.utilities.string_view.reference) +[History](string_view.html#utility.utilities.string_view.history) +[Reference](string_view.html#string_view.reference) +[Acknowledgments](string_view.html#utility.utilities.string_view.acknowledgments) + + +#### +[Introduction](string_view.html#utility.utilities.string_view.introduction "Introduction") + The class [`boost::string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") + and other classes derived from [`basic\_string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") represent references + to strings or substrings. When you are parsing/processing strings from + some external source, frequently you want to pass a piece of text to a + procedure for specialized processing. Before [`std::string\_view`](https://en.cppreference.com/w/cpp/string/basic_string_view), the canonical way + to do this used to be a [`std::string`](https://en.cppreference.com/w/cpp/string/basic_string), but that has certain + drawbacks: + + 1) If you are processing a buffer of text (say a HTTP response or the contents + of a file), then you have to create the string from the text you want to + pass, which involves memory allocation and copying of data. + + 2) If a routine receives a constant [`std::string`](https://en.cppreference.com/w/cpp/string/basic_string) and wants to pass a portion + of that string to another routine, then it must create a new string of + that substring. + + 3) If a routine receives a constant [`std::string`](https://en.cppreference.com/w/cpp/string/basic_string) and wants to return a + portion of the string, then it must create a new string to return. + +[`boost::string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") + is designed to solve these efficiency problems. A [`boost::string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") is a read-only reference + to a contiguous sequence of characters, and provides much of the functionality + of [`std::string`](https://en.cppreference.com/w/cpp/string/basic_string). A [`boost::string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") is cheap to create, + copy and pass by value, because it does not actually own the storage that + it points to. + + A [`boost::string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") + is implemented as a small struct that contains a pointer to the start of + the character `data` and + a `count`. A [`boost::string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") is cheap to create + and cheap to copy. + +[`boost::string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") + acts as a container; it includes all the methods that you would expect + in a container, including iteration support, `operator[]`, `at` + and `size`. It can be used + with any of the iterator-based algorithms in the STL - as long as you do + not need to change the underlying data. For example, [`std::sort`](https://en.cppreference.com/w/cpp/algorithm/sort) and [`std::remove`](https://en.cppreference.com/w/cpp/algorithm/remove) will not work. + + Besides generic container functionality, [`boost::string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") provides a subset + of the interface of [`std::string`](https://en.cppreference.com/w/cpp/string/basic_string). This makes it easy to + replace parameters of type `const +[`std::string`](https://en.cppreference.com/w/cpp/string/basic_string) &` + with [`boost::string\_view`](../../boost/basic_string_view.html "Class template basic_string_view"). + Like [`std::string`](https://en.cppreference.com/w/cpp/string/basic_string), [`boost::string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") has a static member + variable named `npos` to + denote the result of failed searches, and to mean "the end". + + +| | | +| --- | --- | +| [Caution] | Caution | +| + Because a [`boost::string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") + does not own the data that it refers to, it introduces lifetime issues + into code that uses it. The programmer must ensure that the data that + a [`string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") + refers to exists as long as the [`string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") does. + | + +| | | +| --- | --- | +| [Note] | Note | +| + Boost.Utility also includes the class [`string\_ref`](../../boost/basic_string_view.html "Class template basic_string_view"): + + + - [`string\_ref`](../../boost/basic_string_view.html "Class template basic_string_view") + is the initial implementation of Jeffrey Yaskin's [N3442: + string\_ref: a non-owning reference to a string](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html). + + + - [`string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") + is an updated implementation to reflect the Library Fundamentals TS + [N4480: + [string.view]](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4480.html). + + + Please prefer [`string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") + / [`basic\_string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") + over [`string\_ref`](../../boost/basic_string_view.html "Class template basic_string_view") + / [`basic\_string\_ref`](../../boost/basic_string_view.html "Class template basic_string_view"): + + + - The [`basic\_string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") + class better matches [`std::basic\_string\_view`](https://en.cppreference.com/w/cpp/string/basic_string_view). + + + - [`basic\_string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") + has WAY more constexpr support. + + + - Code that uses [`basic\_string\_ref`](../../boost/basic_string_view.html "Class template basic_string_view") should continue + to work. + + + - Not much code depends on [`basic\_string\_ref`](../../boost/basic_string_view.html "Class template basic_string_view") anymore. + | + +#### +[Examples](string_view.html#utility.utilities.string_view.examples "Examples") + Integrating [`string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") + into your code is fairly simple. Wherever you pass a `const +[`std::string`](https://en.cppreference.com/w/cpp/string/basic_string) &` + or [`std::string`](https://en.cppreference.com/w/cpp/string/basic_string) as a parameter, that's + a candidate for passing a [`boost::string\_view`](../../boost/basic_string_view.html "Class template basic_string_view"). + +``` +[`std::string`](https://en.cppreference.com/w/cpp/string/basic_string) extract\_part ( const [`std::string`](https://en.cppreference.com/w/cpp/string/basic_string) &bar ) { + return bar.substr ( 2, 3 ); +} + +if ( extract\_part ( "ABCDEFG" ).front() == 'C' ) { /\* do something \*/ } + +``` + + + Let's figure out what happens in this contrived example. + + + +* First, a temporary string is created from the string literal `"ABCDEFG"`, and it is passed + (by reference) to the routine `extract\_part`. +* Then a second string is created in the call `[`std::string`](https://en.cppreference.com/w/cpp/string/basic_string)::substr` and returned to `extract\_part` (this copy may be elided + by RVO). +* Then `extract\_part` returns + that string back to the caller (again this copy may be elided). +* The first temporary string is deallocated, and `front` + is called on the second string, and then it is deallocated as well. + + + Two [`std::string`](https://en.cppreference.com/w/cpp/string/basic_string) s are created, and two + copy operations. That is potentially four memory allocations and deallocations, + and the associated copying of data. + + Now let's look at the same code with [`string\_view`](../../boost/basic_string_view.html "Class template basic_string_view"): + +``` +[`boost::string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") extract\_part ( [`boost::string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") bar ) { + return bar.substr ( 2, 3 ); +} + +if ( extract\_part ( "ABCDEFG" ).front() == "C" ) { /\* do something \*/ } + +``` + + + No memory allocations. No copying of character data. No changes to the + code other than the types. There are two [`string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") s created, and two + [`string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") + s copied, but those are cheap operations. + + +#### +[Synopsis](string_view.html#utility.utilities.string_view.reference "Synopsis") + The header file [``](../../../../../../boost/utility/string_view.hpp) defines a template [`boost::basic\_string\_view`](../../boost/basic_string_view.html "Class template basic_string_view"), and four specializations + [`string\_view`](../../boost/basic_string_view.html "Class template basic_string_view"), + [`wstring\_view`](../../boost/basic_string_view.html "Class template basic_string_view"), + [`u16string\_view`](../../boost/basic_string_view.html "Class template basic_string_view"), + [`u32string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") + - for `char` / `wchar\_t` / `char16\_t` + / `char32\_t`. + +`#include ` + + Construction and copying: + +``` +constexpr basic\_string\_view (); // Constructs an empty string\_view +constexpr basic\_string\_view(const charT\* str); // Constructs from a NULL-terminated string +constexpr basic\_string\_view(const charT\* str, size\_type len); // Constructs from a pointer, length pair +template +basic\_string\_view(const [`std::basic\_string`](https://en.cppreference.com/w/cpp/string/basic_string)& str); // Constructs from a std::string +basic\_string\_view (const basic\_string\_view &rhs); +basic\_string\_view& operator=(const basic\_string\_view &rhs); + +``` + + +[`string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") + does not define a move constructor nor a move-assignment operator because + copying a [`string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") + is just a cheap as moving one. + + Basic container-like functions: + +``` +constexpr size\_type size() const ; +constexpr size\_type length() const ; +constexpr size\_type max\_size() const ; +constexpr bool empty() const ; + +// All iterators are const\_iterators +constexpr const\_iterator begin() const ; +constexpr const\_iterator cbegin() const ; +constexpr const\_iterator end() const ; +constexpr const\_iterator cend() const ; +const\_reverse\_iterator rbegin() const ; +const\_reverse\_iterator crbegin() const ; +const\_reverse\_iterator rend() const ; +const\_reverse\_iterator crend() const ; + +``` + + + Access to the individual elements (all of which are const): + +``` +constexpr const charT& operator[](size\_type pos) const ; +const charT& at(size\_t pos) const ; +constexpr const charT& front() const ; +constexpr const charT& back() const ; +constexpr const charT\* data() const ; + +``` + + + Modifying the [`string\_view`](../../boost/basic_string_view.html "Class template basic_string_view") + (but not the underlying data): + +``` +void clear(); +void remove\_prefix(size\_type n); +void remove\_suffix(size\_type n); + +``` + + + Searching: + +``` +size\_type find(basic\_string\_view s) const ; +size\_type find(charT c) const ; +size\_type rfind(basic\_string\_view s) const ; +size\_type rfind(charT c) const ; +size\_type find\_first\_of(charT c) const ; +size\_type find\_last\_of (charT c) const ; + +size\_type find\_first\_of(basic\_string\_view s) const ; +size\_type find\_last\_of(basic\_string\_view s) const ; +size\_type find\_first\_not\_of(basic\_string\_view s) const ; +size\_type find\_first\_not\_of(charT c) const ; +size\_type find\_last\_not\_of(basic\_string\_view s) const ; +size\_type find\_last\_not\_of(charT c) const ; + +``` + + + String-like operations: + +``` +constexpr basic\_string\_view substr(size\_type pos, size\_type n=npos) const ; // Creates a new string\_view +bool starts\_with(charT c) const ; +bool starts\_with(basic\_string\_view x) const ; +bool ends\_with(charT c) const ; +bool ends\_with(basic\_string\_view x) const ; + +``` +#### +[History](string_view.html#utility.utilities.string_view.history "History") + + +###### + +[boost + 1.71](string_view.html#utility.utilities.string_view.history.boost_1_71) + + +* Glen Fernandes updated the implementation of the stream insertion operator + to write directly to the `basic\_streambuf` + and refactored that functionality into a common utility. + +###### + +[boost + 1.53](string_view.html#utility.utilities.string_view.history.boost_1_53) + + +* Introduced +#### +Reference +##### +Header <[boost/utility/string\_view.hpp](../../../../../../boost/utility/string_view.hpp)> +``` +namespace boost { + template class [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view"); + template + constexpr bool + operator==([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, + [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + constexpr bool + operator!=([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, + [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + constexpr bool + operator<([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, + [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + constexpr bool + operator>([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, + [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + constexpr bool + operator<=([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, + [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + constexpr bool + operator>=([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, + [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + constexpr bool + operator==([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, + const std::basic\_string< charT, traits, Allocator > & y); + template + constexpr bool + operator==(const std::basic\_string< charT, traits, Allocator > & x, + [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + constexpr bool + operator==([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, const charT \* y); + template + constexpr bool + operator==(const charT \* x, [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + constexpr bool + operator!=([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, + const std::basic\_string< charT, traits, Allocator > & y); + template + constexpr bool + operator!=(const std::basic\_string< charT, traits, Allocator > & x, + [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + constexpr bool + operator!=([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, const charT \* y); + template + constexpr bool + operator!=(const charT \* x, [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + constexpr bool + operator<([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, + const std::basic\_string< charT, traits, Allocator > & y); + template + constexpr bool + operator<(const std::basic\_string< charT, traits, Allocator > & x, + [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + constexpr bool + operator<([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, const charT \* y); + template + constexpr bool + operator<(const charT \* x, [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + constexpr bool + operator>([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, + const std::basic\_string< charT, traits, Allocator > & y); + template + constexpr bool + operator>(const std::basic\_string< charT, traits, Allocator > & x, + [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + constexpr bool + operator>([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, const charT \* y); + template + constexpr bool + operator>(const charT \* x, [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + constexpr bool + operator<=([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, + const std::basic\_string< charT, traits, Allocator > & y); + template + constexpr bool + operator<=(const std::basic\_string< charT, traits, Allocator > & x, + [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + constexpr bool + operator<=([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, const charT \* y); + template + constexpr bool + operator<=(const charT \* x, [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + constexpr bool + operator>=([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, + const std::basic\_string< charT, traits, Allocator > & y); + template + constexpr bool + operator>=(const std::basic\_string< charT, traits, Allocator > & x, + [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + constexpr bool + operator>=([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > x, const charT \* y); + template + constexpr bool + operator>=(const charT \* x, [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > y); + template + std::basic\_ostream< charT, traits > & + operator<<(std::basic\_ostream< charT, traits > & os, + const [basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > & str); + template std::size\_t hash\_range(It, It); + template + std::size\_t hash\_value([basic\_string\_view](../../boost/basic_string_view.html "Class template basic_string_view")< charT, traits > s); +} +``` + +#### +[Acknowledgments](string_view.html#utility.utilities.string_view.acknowledgments "Acknowledgments") + Author: Clow, Marshall + + Copyright 2012 Marshall Clow + + + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](../../boost/tr1_result_of.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](../../boost/basic_string_view.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/value_init.html b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/value_init.html new file mode 100644 index 0000000..0a3b5e8 --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities/value_init.html @@ -0,0 +1,724 @@ +--- +title: Value Init +copyright: +revised: +--- + + +Value Init + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../../index.html) | [Libraries](../../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../../more/index.htm) | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](../../boost/basic_string_view.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](../../boost/initialized.html) + + +### +[Value + Init](value_init.html "Value Init") +[Introduction](value_init.html#utility.utilities.value_init.introduction) +[Details](value_init.html#utility.utilities.value_init.details) +[Types + and objects](value_init.html#utility.utilities.value_init.types_and_objects) +[References](value_init.html#utility.utilities.value_init.references) +[Reference](value_init.html#value_init.reference) +[Acknowledgements](value_init.html#utility.utilities.value_init.acknowledgements) + + +#### +[Introduction](value_init.html#utility.utilities.value_init.introduction "Introduction") + Constructing and initializing objects in a generic way is difficult in + C++. The problem is that there are several different rules that apply for + initialization. Depending on the type, the value of a newly constructed + object can be zero-initialized (logically 0), default-constructed (using + the default constructor), or indeterminate. When writing generic code, + this problem must be addressed. The template [`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized") provides a solution + with consistent syntax for value initialization of scalar, union and class + types. Moreover, [`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized") offers a workaround + to various compiler issues regarding value-initialization. + + Furthermore, a `const` object + [`initialized\_value`](../../boost/initialized_value.html "Global initialized_value") + is provided, to avoid repeating the type name when retrieving the value + from a `[`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized")` object. + + There are various ways to initialize a variable, in C++. The following + declarations all *may* have a local variable initialized + to its default value: + +``` +T1 var1; +T2 var2 = 0; +T3 var3 = {}; +T4 var4 = T4(); + +``` + + + Unfortunately, whether or not any of those declarations correctly initialize + the variable very much depends on its type. The first declaration is valid + for any [*DefaultConstructible*](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible) + type by definition. + + However, it does not always do an initialization. It correctly initializes + the variable when it's an instance of a class, and the author of the class + has provided a proper default constructor. On the other hand, the value + of `var1` is *indeterminate* + when its type is an arithmetic type, like `int`, + `float`, or `char`. + + An arithmetic variable is of course initialized properly by the second + declaration, `T2 var2 += 0`. + But this initialization form will not usually work for a class type, unless + the class was especially written to support being initialized that way. + + The third form, `T3 var3 += {}`, + initializes an aggregate, typically a "C-style" `struct` or a "C-style" array. However, + at the time this library was developed, the syntax did not allow for a + class that has an explicitly declared constructor. + + The fourth form is the most generic form of them, as it can be used to + initialize arithmetic types, class types, aggregates, pointers, and other + types. The declaration, `T4 var4 = T4()`, + should be read as follows: First a temporary object is created, by `T4()`. + This object is [value-initialized](value_init.html#sec:valueinit). + Next the temporary object is copied to the named variable, `var4`. Afterwards, the temporary is destroyed. + While the copying and the destruction are likely to be optimized away, + C++ still requires the type `T4` + to be [*CopyConstructible*](https://en.cppreference.com/w/cpp/named_req/CopyConstructible). + So `T4` needs to be *both* +[*DefaultConstructible*](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible) +*and* [*CopyConstructible*](https://en.cppreference.com/w/cpp/named_req/CopyConstructible). + + A class may not be CopyConstructible, for example because it may have a + private and undefined copy constructor, or because it may be derived from + `boost::noncopyable`. Scott Meyers [[2](value_init.html#sec:references)] + explains why a class would be defined like that. + + There is another, less obvious disadvantage to the fourth form, `T4 var4 += T4()`: It suffers from various [compiler + issues](value_init.html#sec:compiler_issues), causing a variable to be left uninitialized in some compiler + specific cases. + + The template [`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized") + offers a generic way to initialize an object, like `T4 +var4 = +T4()`, + but without requiring its type to be [*CopyConstructible*](https://en.cppreference.com/w/cpp/named_req/CopyConstructible). + And it offers a workaround to those compiler issues regarding value-initialization + as well. It allows getting an initialized variable of any type; it *only* + requires the type to be [*DefaultConstructible*](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible). + A properly *value-initialized* object of type `T` is constructed by the following declaration: + +``` +value\_initialized var; + +``` + + + The template [`initialized`](../../boost/initialized.html "Class template initialized") + offers both value-initialization and direct-initialization. It is especially + useful as a data member type, allowing the very same object to be either + direct-initialized or value-initialized. + + The `const` object [`initialized\_value`](../../boost/initialized_value.html "Global initialized_value") allows value-initializing + a variable as follows: + +``` +T var = initialized\_value; + +``` + + + This form of initialization is semantically equivalent to `T4 var4 += T4()`, but robust against the aforementioned + compiler issues. + + +#### +[Details](value_init.html#utility.utilities.value_init.details "Details") + The C++ standard [[3](value_init.html#sec:references)] contains the + definitions of `zero-initialization` and `default-initialization`. + Informally, zero-initialization means that the object is given the initial + value `0` converted to the type + and default-initialization means that [POD](https://en.cppreference.com/w/cpp/named_req/PODType) + [[4](value_init.html#sec:references)] types are zero-initialized, while + non-POD class types are initialized with their corresponding default constructors. + + A *declaration* can contain an *initializer*, + which specifies the object's initial value. The initializer can be just + '()', which states that the object shall be value-initialized (but see + below). However, if a *declaration* has no *initializer* + and it is of a non-`const`, + non-`static` POD type, the initial + value is indeterminate: (see §8.5, [dcl.init], for the accurate definitions). + +``` +int x; // no initializer. x value is indeterminate. +[`std::string`](https://en.cppreference.com/w/cpp/string/basic_string) s; // no initializer, s is default-constructed. + +int y = int(); +// y is initialized using copy-initialization +// but the temporary uses an empty set of parentheses as the initializer, +// so it is default-constructed. +// A default constructed POD type is zero-initialized, +// therefore, y == 0. + +void foo ( [`std::string`](https://en.cppreference.com/w/cpp/string/basic_string) ) ; +foo ( [`std::string`](https://en.cppreference.com/w/cpp/string/basic_string)() ) ; +// the temporary string is default constructed +// as indicated by the initializer () + +``` + +###### + +[value-initialization](value_init.html#utility.utilities.value_init.details.value_initialization) + The first [Technical + Corrigendum for the C++ Standard](http://www.open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html) (TC1), whose draft was released + to the public in November 2001, introduced [Core + Issue 178](http://www.open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#178), among many other issues. + + That issue introduced the new concept of `value-initialization`, + and also fixed the wording for zero-initialization. Informally, value-initialization + is similar to default-initialization with the exception that in some cases + non-static data members and base class sub-objects are also value-initialized. + + The difference is that an object that is value-initialized will not have, + or at least is less likely to have, indeterminate values for data members + and base class sub-objects; unlike the case of an object default constructed + (see Core Issue 178 for a normative description). + + In order to specify value-initialization of an object we need to use the + empty-set initializer: `()`. + + As before, a declaration with no initializer specifies default-initialization, + and a declaration with a non-empty initializer specifies copy (`=xxx`) + or direct (`xxx`) initialization. + +``` +template void eat(T); + +int x ; // indeterminate initial value. + +[`std::string`](https://en.cppreference.com/w/cpp/string/basic_string) s; // default-initialized. + +eat ( int() ) ; // value-initialized + +eat ( [`std::string`](https://en.cppreference.com/w/cpp/string/basic_string)() ) ; // value-initialized + +``` + +###### + +[value-initialization + syntax](value_init.html#utility.utilities.value_init.details.value_initialization_syntax) + Value initialization is specified using `()`. + However, the empty set of parentheses is not permitted by the syntax of + initializers because it is parsed as the declaration of a function taking + no arguments: + +``` +int x() ; // declares function int(\*)() + +``` + + + Thus, the empty `()` must be + put in some other initialization context. + + One alternative is to use copy-initialization syntax: + +``` +int x = int(); + +``` + + + This works perfectly fine for POD types. But for non-POD class types, copy-initialization + searches for a suitable constructor, which could be, for instance, the + copy-constructor. It also searches for a suitable conversion sequence but + this does not apply in this context. + + For an arbitrary unknown type, using this syntax may not have the value-initialization + effect intended because we don't know if a copy from a default constructed + object is exactly the same as a default constructed object, and the compiler + is allowed, in some cases, but never required to, optimize the copy away. + + One possible generic solution is to use value-initialization of a non static + data member: + +``` +template +struct W +{ + // value-initialization of 'data' here. + W() : data() {} + + T data; +}; + +W w; +// w.data is value-initialized for any type. + +``` + + + This is the solution as it was supplied by earlier versions of the `[`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized")` template class. Unfortunately this + approach suffered from various compiler issues. + + + +###### + +[Compiler + issues](value_init.html#utility.utilities.value_init.details.compiler_issues) + Various compilers have not yet fully implemented value-initialization. + So when an object should be *value-initialized* according + to the C++ Standard, it *may* in practice still be left + uninitialized, because of those compiler issues. It is hard to make a general + statement on what those issues are like, because they depend on the compiler + you are using, its version number, and the type of object you would like + to have value-initialized. + + All compilers we have tested so far support value-initialization for arithmetic + types properly. However, various compilers may leave some types of *aggregates* + uninitialized, when they should be value-initialized. Value-initialization + of objects of a pointer-to-member type may also go wrong on various compilers. + + At the moment of writing, May 2010, the following reported issues regarding + value-initialization are still there in current compiler releases: + + + +* [Microsoft + Visual Studio Feedback ID 100744, Value-initialization in new-expression](https://connect.microsoft.com/VisualStudio/feedback/details/100744): + Reported by Pavel Kuznetsov (MetaCommunications Engineering), 2005. +* [Microsoft + Visual Studio Feedback ID 484295, VC++ does not value-initialize members + of derived classes without user-declared constructor](http://connect.microsoft.com/VisualStudio/feedback/details/484295) Reported + by Sylvester Hesp, 2009. +* [Microsoft + Visual Studio Feedback ID 499606, Presence of copy constructor breaks + member class initialization](https://connect.microsoft.com/VisualStudio/feedback/details/499606) Reported by Alex Vakulenko, 2009 +* [Embarcadero/C++Builder + Report 83751, Value-initialization: arrays should have each element + value-initialized](http://qc.embarcadero.com/wc/qcmain.aspx?d=83751) Reported by Niels Dekker (LKEB), 2010. +* [Embarcadero/C++Builder + Report 83851, Value-initialized temporary triggers internal backend + error C1798](http://qc.embarcadero.com/wc/qcmain.aspx?d=83851) Reported by Niels Dekker, 2010. +* [Embarcadero/C++Builder + Report 84279, Internal compiler error (F1004), value-initializing member + function pointer by "new T()"](http://qc.embarcadero.com/wc/qcmain.aspx?d=84279) Reported by Niels Dekker, + 2010 +* Sun CR 6947016, Sun 5.10 may fail to value-initialize an object of + a non-POD aggregate. Reported to Steve Clamage by Niels Dekker, 2010. +* IBM's XL V10.1 and V11.1 may fail to value-initialize a temporary of + a non-POD aggregate. Reported to Michael Wong by Niels Dekker, 2010. +* Intel support issue 589832, Attempt to value-initialize pointer-to-member + triggers internal error on Intel 11.1. Reported by John Maddock, 2010. + + + Note that all known GCC issues regarding value-initialization are fixed + with GCC version 4.4, including [GCC + Bug 30111](http://gcc.gnu.org/bugzilla/show_bug.cgi?id=30111). Clang also has completely implemented value-initialization, + as far as we know, now that [Clang + Bug 7139](http://llvm.org/bugs/show_bug.cgi?id=7139) is fixed. + + New versions of [`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized") + (Boost release version 1.35 or higher) offer a workaround to these issues: + [`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized") + may now clear its internal data, prior to constructing the object that + it contains. It will do so for those compilers that need to have such a + workaround, based on the [compiler + defect macro](../../../../../../libs/config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_defects) `BOOST\_NO\_COMPLETE\_VALUE\_INITIALIZATION`. + + +#### +[Types + and objects](value_init.html#utility.utilities.value_init.types_and_objects "Types and objects") +##### +[`template class +value\_initialized`](value_init.html#utility.utilities.value_init.types_and_objects.template_class_value_initialized "template class value_initialized") +``` +namespace boost { + +template +class [`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized") +{ + + public : + + [`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized")() : x() {} + + operator T const &() const { return x ; } + + operator T&() { return x ; } + + T const &data() const { return x ; } + + T& data() { return x ; } + + void swap( [`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized")& ); + + private : + + [unspecified] x ; + +} ; + +template + +T const& get ( [`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized") const& x ) +{ + return x.data(); +} + +template +T& get ( [`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized")& x ) +{ + return x.data(); +} + +template +void swap ( [`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized")& lhs, [`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized")& rhs ) +{ + lhs.swap(rhs); +} + +} // namespace boost + +``` + + + An object of this template class is a `T`-wrapper + convertible to `'T&'` whose + wrapped object (data member of type `T`) + is [value-initialized](value_init.html#sec:valueinit) upon default-initialization + of this wrapper class: + +``` +int zero = 0; +[`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized") x; +assert( x == zero ) ; + +[`std::string`](https://en.cppreference.com/w/cpp/string/basic_string) def; +[`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized")< [`std::string`](https://en.cppreference.com/w/cpp/string/basic_string) > y; +assert( y == def ) ; + +``` + + + The purpose of this wrapper is to provide a consistent syntax for value + initialization of scalar, union and class types (POD and non-POD) since + the correct syntax for value initialization varies (see [value-initialization + syntax](value_init.html#sec:valueinitsyn)). + + The wrapped object can be accessed either through the conversion operator + `T&`, + the member function `data()`, or the non-member function `get()`: + +``` +void watch(int); + +[`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized") x; + +watch(x) ; // operator T& used. +watch(x.data()); +watch( get(x) ) // function get() used + +``` + + + Both `const` and non-`const` objects can be wrapped. Mutable + objects can be modified directly from within the wrapper but constant + objects cannot: + + When `T` is a [*Swappable*](https://en.cppreference.com/w/cpp/named_req/Swappable) + type, `[`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized")` is swappable as well, by calling + its `swap` member function + as well as by calling `boost::swap`. + +``` +[`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized") x; +static\_cast(x) = 1 ; // OK +get(x) = 1 ; // OK + +[`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized") y ; +static\_cast(y) = 1 ; // ERROR: cannot cast to int& +static\_cast(y) = 1 ; // ERROR: cannot modify a const value +get(y) = 1 ; // ERROR: cannot modify a const value + +``` +| | | +| --- | --- | +| [Warning] | Warning | +| + The [`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized") + implementation of Boost version 1.40.0 and older allowed *non-const* + access to the wrapped object, from a constant wrapper, both by its + conversion operator and its `data()` member function. + + + For example: + + +``` +[`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized") const x\_c; +int& xr = x\_c ; // OK, conversion to int& available even though x\_c is itself const. +xr = 2 ; + +``` + + + The reason for this obscure behavior was that some compilers did not + accept the following valid code: + + +``` +struct X +{ + operator int&() ; + operator int const&() const ; + }; + X x ; + (x == 1) ; // ERROR HERE! + +``` + + + The current version of [`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized") no longer + has this obscure behavior. As compilers nowadays widely support overloading + the conversion operator by having a `const` + and a `non-const` version, we have decided to fix + the issue accordingly. So the current version supports the idea of + logical constness. + | + + +###### + +[Recommended + practice: The non-member get() idiom](value_init.html#utility.utilities.value_init.types_and_objects.template_class_value_initialized.recommended_practice_the_non_mem) + The obscure behavior of being able to modify a non-`const` + wrapped object from within a constant wrapper (as was supported by previous + versions of [`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized")) + can be avoided if access to the wrapped object is always performed with + the `get()` + idiom: + +``` +value\_initialized x; +get(x) = 1; // OK +value\_initialized cx; +get(x) = 1; // ERROR: Cannot modify a const object + +value\_initialized const x\_c; +get(x\_c) = 1; // ERROR: Cannot modify a const object + +value\_initialized const cx\_c; +get(cx\_c) = 1; // ERROR: Cannot modify a const object + +``` +##### +[`template class +initialized`](value_init.html#utility.utilities.value_init.types_and_objects.template_class_initialized_t "template class initialized") +``` +namespace boost { + +template +class [`initialized`](../../boost/initialized.html "Class template initialized") +{ + + public : + + [`initialized`](../../boost/initialized.html "Class template initialized")() : x() {} + + explicit [`initialized`](../../boost/initialized.html "Class template initialized")(T const & arg) : x(arg) {} + + operator T const &() const; + + operator T&(); + + T const &data() const; + + T& data(); + + void swap( [`initialized`](../../boost/initialized.html "Class template initialized")& ); + + private : + + [unspecified] x ; + +}; + +template +T const& get ( [`initialized`](../../boost/initialized.html "Class template initialized") const& x ); + +template +T& get ( [`initialized`](../../boost/initialized.html "Class template initialized")& x ); + +template +void swap ( [`initialized`](../../boost/initialized.html "Class template initialized")& lhs, [`initialized`](../../boost/initialized.html "Class template initialized")& rhs ); + +} // namespace boost + +``` + + + The template class `boost::[`initialized`](../../boost/initialized.html "Class template initialized")` + supports both value-initialization and direct-initialization, so its + interface is a superset of the interface of `[`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized")`: + Its default-constructor value-initializes the wrapped object just like + the default-constructor of `[`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized")`, + but `boost::[`initialized`](../../boost/initialized.html "Class template initialized")` also offers an extra `explicit` constructor, which direct-initializes + the wrapped object by the specified value. + +`[`initialized`](../../boost/initialized.html "Class template initialized")` is especially useful when the wrapped + object must be either value-initialized or direct-initialized, depending + on runtime conditions. For example, `[`initialized`](../../boost/initialized.html "Class template initialized")` + could hold the value of a data member that may be value-initialized by + some constructors, and direct-initialized by others. + + On the other hand, if it is known beforehand that the object must *always* + be value-initialized, `[`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized")` + may be preferable. And if the object must always be direct-initialized, + none of the two wrappers really needs to be used. + + +##### +[`initialized\_value`](value_init.html#utility.utilities.value_init.types_and_objects.initialized_value "initialized_value") +``` +namespace boost { +class [`initialized\_value\_t`](../../boost/initialized_value_t.html "Class initialized_value_t") +{ + public : + template operator T() const ; +}; + +[`initialized\_value\_t`](../../boost/initialized_value_t.html "Class initialized_value_t") const initialized\_value = {} ; + +} // namespace boost + +``` + + +[`initialized\_value`](../../boost/initialized_value.html "Global initialized_value") + provides a convenient way to get an initialized value: its conversion + operator provides an appropriate *value-initialized* + object for any [*CopyConstructible*](https://en.cppreference.com/w/cpp/named_req/CopyConstructible) + type. + + Suppose you need to have an initialized variable of type `T`. You could do it as follows: + +``` +T var = T(); + +``` + + + But as mentioned before, this form suffers from various compiler issues. + The template [`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized") + offers a workaround: + +``` +T var = get( [`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized")() ); + +``` + + + Unfortunately both forms repeat the type name, which is rather short + now (`T`), but could of + course be more like `Namespace::Template::Type`. + + Instead, one could use [`initialized\_value`](../../boost/initialized_value.html "Global initialized_value") as follows: + +``` +T var = [`initialized\_value`](../../boost/initialized_value.html "Global initialized_value"); + +``` + +#### +[References](value_init.html#utility.utilities.value_init.references "References") + + +1. Bjarne Stroustrup, Gabriel Dos Reis, and J. Stephen Adamczyk wrote + various papers, proposing to extend the support for brace-enclosed + *initializer lists* in C++. This [feature](https://en.cppreference.com/w/cpp/language/list_initialization) + has now been available since C++11. This would allow a variable `var` of any [*DefaultConstructible*](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible) + type `T` to be *value-initialized* + by doing `T var += {}`. + The papers are listed at Bjarne's web page, [My + C++ Standards committee papers](http://www.research.att.com/~bs/WG21.html). +2. Scott Meyers, Effective C++, Third Edition, item 6, *Explicitly + disallow the use of compiler-generated functions you do not want*, + [Scott Meyers: Books + and CDs](http://www.aristeia.com/books.html) +3. The C++ Standard, Second edition (2003), ISO/IEC 14882:2003 +4. POD stands for ["Plain + Old Data"](https://en.cppreference.com/w/cpp/named_req/PODType) +#### +Reference +##### +Header <[boost/utility/value\_init.hpp](../../../../../../boost/utility/value_init.hpp)> +``` +namespace boost { + template class [initialized](../../boost/initialized.html "Class template initialized"); + class [initialized\_value\_t](../../boost/initialized_value_t.html "Class initialized_value_t"); + template class [value\_initialized](../../boost/value_initialized.html "Class template value_initialized"); + + [initialized\_value\_t](../../boost/initialized_value_t.html "Class initialized_value_t") const [initialized\_value](../../boost/initialized_value.html "Global initialized_value"); + template T const & get([initialized](../../boost/initialized.html "Class template initialized")< T > const & x); + template T & get([initialized](../../boost/initialized.html "Class template initialized")< T > & x); + template + void swap([initialized](../../boost/initialized.html "Class template initialized")< T > & lhs, [initialized](../../boost/initialized.html "Class template initialized")< T > & rhs); + template T const & get([value\_initialized](../../boost/value_initialized.html "Class template value_initialized")< T > const & x); + template T & get([value\_initialized](../../boost/value_initialized.html "Class template value_initialized")< T > & x); + template + void swap([value\_initialized](../../boost/value_initialized.html "Class template value_initialized")< T > & lhs, [value\_initialized](../../boost/value_initialized.html "Class template value_initialized")< T > & rhs); +} +``` + +#### +[Acknowledgements](value_init.html#utility.utilities.value_init.acknowledgements "Acknowledgements") +[`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized") + was developed by Fernando Cacciola, with help and suggestions from David + Abrahams and Darin Adler. + + Special thanks to Bjorn Karlsson who carefully edited and completed this + documentation. + +[`value\_initialized`](../../boost/value_initialized.html "Class template value_initialized") + was reimplemented by Fernando Cacciola and Niels Dekker for Boost release + version 1.35 (2008), offering a workaround to various compiler issues. + +`boost::[`initialized`](../../boost/initialized.html "Class template initialized")` + was very much inspired by feedback from Edward Diener and Jeffrey Hellrung. + +[`initialized\_value`](../../boost/initialized_value.html "Global initialized_value") + was written by Niels Dekker, and added to Boost release version 1.36 (2008). + + Developed by [Fernando + Cacciola](mailto:fernando_cacciola%40hotmail.com). The latest version of this file can be found at [www.boost.org](http://www.boost.org). + + + + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../../doc/src/images/prev.png)](../../boost/basic_string_view.html)[![Up](../../../../../../doc/src/images/up.png)](../utilities.html)[![Home](../../../../../../doc/src/images/home.png)](../../index.html)[![Next](../../../../../../doc/src/images/next.png)](../../boost/initialized.html) diff --git a/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities0.html b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities0.html new file mode 100644 index 0000000..793713a --- /dev/null +++ b/doc/libs/1_78_0/libs/utility/doc/html/utility/utilities0.html @@ -0,0 +1,56 @@ +--- +title: More Utilities +copyright: +revised: +--- + + +More Utilities + + + + +| | | | | | | +| --- | --- | --- | --- | --- | --- | +| Boost C++ Libraries | [Home](../../../../../index.html) | [Libraries](../../../../../libs/libraries.htm) | [People](http://www.boost.org/users/people.html) | [FAQ](http://www.boost.org/users/faq.html) | [More](../../../../../more/index.htm) | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../boost/initialized_value.html)[![Up](../../../../../doc/src/images/up.png)](../index.html)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](ref.html) +[More Utilities](utilities0.html "More Utilities") +--------------------------------------------------- + Some utilities have been moved from Boost.Utilities to more appropriate Boost + libraries: + + + +1. Moved to [Boost.Core](../../../../../libs/core/index.html) + + 1. [addressof](../../../../../libs/core/doc/html/core/addressof.html) + 2. [checked\_delete](../../../../../libs/core/doc/html/core/checked_delete.html) + 3. [enable\_if](../../../../../libs/core/doc/html/core/enable_if.html) + 4. [noncopyable](../../../../../libs/core/doc/html/core/noncopyable.html) +2. Moved to [Boost.TypeTraits](../../../../../libs/type_traits/index.html) + + 1. [declval](../../../../../libs/type_traits/doc/html/boost_typetraits/reference/declval.html) +3. Moved to [Boost.Iterator](../../../../../libs/iterator/index.html) + + 1. [generator + iterator adaptors](../../../../../libs/iterator/doc/generator_iterator.htm) + 2. [next/prior](../../../../../libs/iterator/doc/html/iterator/algorithms/next_prior.html) +4. Moved to [Boost.IO](../../../../../libs/io/index.html) + + 1. [ostream\_string](../../../../../libs/io/doc/html/io.html) +5. Moved to [Boost.ThrowException](../../../../../libs/throw_exception/index.html) + + 1. [throw\_exception](../../../../../libs/throw_exception/doc/html/throw_exception.html#using_boost_throw_exception) + +| | | +| --- | --- | +| | Copyright © 2001 Beman Dawes + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE\_1\_0.txt or copy at ) + + | + +--- +[![Prev](../../../../../doc/src/images/prev.png)](../boost/initialized_value.html)[![Up](../../../../../doc/src/images/up.png)](../index.html)[![Home](../../../../../doc/src/images/home.png)](../index.html)[![Next](../../../../../doc/src/images/next.png)](ref.html) diff --git a/doc/libs/1_79_0/libs/atomic/index.html b/doc/libs/1_79_0/libs/atomic/index.html new file mode 100644 index 0000000..e862f15 --- /dev/null +++ b/doc/libs/1_79_0/libs/atomic/index.html @@ -0,0 +1,19 @@ +--- +title: +copyright: +revised: +--- + +Automatic redirection failed, please go to +   + +--- + + +© Copyright Beman Dawes, 2001 + + +Distributed under the Boost Software License, Version 1.0. (See accompanying +file [LICENSE\_1\_0.txt](../../LICENSE_1_0.txt) or copy +at [www.boost.org/LICENSE\_1\_0.txt](http://www.boost.org/LICENSE_1_0.txt)) + diff --git a/doc/libs/common/boost.png b/doc/libs/common/boost.png new file mode 100644 index 0000000..b4d51fc Binary files /dev/null and b/doc/libs/common/boost.png differ diff --git a/doc/libs/common/doc/src/images/alert.png b/doc/libs/common/doc/src/images/alert.png new file mode 100644 index 0000000..b4645bc Binary files /dev/null and b/doc/libs/common/doc/src/images/alert.png differ diff --git a/doc/libs/common/doc/src/images/blank.png b/doc/libs/common/doc/src/images/blank.png new file mode 100644 index 0000000..764bf4f Binary files /dev/null and b/doc/libs/common/doc/src/images/blank.png differ diff --git a/doc/libs/common/doc/src/images/caution.png b/doc/libs/common/doc/src/images/caution.png new file mode 100644 index 0000000..5b7809c Binary files /dev/null and b/doc/libs/common/doc/src/images/caution.png differ diff --git a/doc/libs/common/doc/src/images/draft.png b/doc/libs/common/doc/src/images/draft.png new file mode 100644 index 0000000..0084708 Binary files /dev/null and b/doc/libs/common/doc/src/images/draft.png differ diff --git a/doc/libs/common/doc/src/images/home.png b/doc/libs/common/doc/src/images/home.png new file mode 100644 index 0000000..5584aac Binary files /dev/null and b/doc/libs/common/doc/src/images/home.png differ diff --git a/doc/libs/common/doc/src/images/important.png b/doc/libs/common/doc/src/images/important.png new file mode 100644 index 0000000..12c90f6 Binary files /dev/null and b/doc/libs/common/doc/src/images/important.png differ diff --git a/doc/libs/common/doc/src/images/next.png b/doc/libs/common/doc/src/images/next.png new file mode 100644 index 0000000..59800b4 Binary files /dev/null and b/doc/libs/common/doc/src/images/next.png differ diff --git a/doc/libs/common/doc/src/images/next_disabled.png b/doc/libs/common/doc/src/images/next_disabled.png new file mode 100644 index 0000000..10a8c59 Binary files /dev/null and b/doc/libs/common/doc/src/images/next_disabled.png differ diff --git a/doc/libs/common/doc/src/images/note.png b/doc/libs/common/doc/src/images/note.png new file mode 100644 index 0000000..d0c3c64 Binary files /dev/null and b/doc/libs/common/doc/src/images/note.png differ diff --git a/doc/libs/common/doc/src/images/prev.png b/doc/libs/common/doc/src/images/prev.png new file mode 100644 index 0000000..d88a40f Binary files /dev/null and b/doc/libs/common/doc/src/images/prev.png differ diff --git a/doc/libs/common/doc/src/images/prev_disabled.png b/doc/libs/common/doc/src/images/prev_disabled.png new file mode 100644 index 0000000..ab3c17e Binary files /dev/null and b/doc/libs/common/doc/src/images/prev_disabled.png differ diff --git a/doc/libs/common/doc/src/images/smiley.png b/doc/libs/common/doc/src/images/smiley.png new file mode 100644 index 0000000..30a77f7 Binary files /dev/null and b/doc/libs/common/doc/src/images/smiley.png differ diff --git a/doc/libs/common/doc/src/images/stable_vector.png b/doc/libs/common/doc/src/images/stable_vector.png new file mode 100644 index 0000000..26af7af Binary files /dev/null and b/doc/libs/common/doc/src/images/stable_vector.png differ diff --git a/doc/libs/common/doc/src/images/tip.png b/doc/libs/common/doc/src/images/tip.png new file mode 100644 index 0000000..5c4aab3 Binary files /dev/null and b/doc/libs/common/doc/src/images/tip.png differ diff --git a/doc/libs/common/doc/src/images/toc-blank.png b/doc/libs/common/doc/src/images/toc-blank.png new file mode 100644 index 0000000..6ffad17 Binary files /dev/null and b/doc/libs/common/doc/src/images/toc-blank.png differ diff --git a/doc/libs/common/doc/src/images/toc-minus.png b/doc/libs/common/doc/src/images/toc-minus.png new file mode 100644 index 0000000..abbb020 Binary files /dev/null and b/doc/libs/common/doc/src/images/toc-minus.png differ diff --git a/doc/libs/common/doc/src/images/toc-plus.png b/doc/libs/common/doc/src/images/toc-plus.png new file mode 100644 index 0000000..941312c Binary files /dev/null and b/doc/libs/common/doc/src/images/toc-plus.png differ diff --git a/doc/libs/common/doc/src/images/up.png b/doc/libs/common/doc/src/images/up.png new file mode 100644 index 0000000..17d9c3e Binary files /dev/null and b/doc/libs/common/doc/src/images/up.png differ diff --git a/doc/libs/common/doc/src/images/up_disabled.png b/doc/libs/common/doc/src/images/up_disabled.png new file mode 100644 index 0000000..e22bc87 Binary files /dev/null and b/doc/libs/common/doc/src/images/up_disabled.png differ diff --git a/doc/libs/common/doc/src/images/warning.png b/doc/libs/common/doc/src/images/warning.png new file mode 100644 index 0000000..1c33db8 Binary files /dev/null and b/doc/libs/common/doc/src/images/warning.png differ diff --git a/doc/tools.html b/doc/tools.html new file mode 100644 index 0000000..8b5878e --- /dev/null +++ b/doc/tools.html @@ -0,0 +1,57 @@ +--- +title: Boost Tools +copyright: Rene Rivera 2007. +revised: +--- + + +Boost Tools + + + +Boost Tools +=========== + +Boost developers, testers, and maintainers have developed + various programs to help with the administration of the Boost + Libraries. Like everything else about Boost, these tools are + available in source form, and are part of the regular Boost + distribution. + + +Users may find these tools useful when porting Boost + libraries to a new platform, or for use with their own + applications. +[Boost.Build](/build/) +The Boost build system, including the full Boost version + of the jam sources. +[Regression](tools/regression/index.html) +The Boost regression testing system reporting + sources. +[Inspect](tools/inspect/index.html) +The inspection tool used to detect errors in the Boost + directory hierarchy. +[BoostBook](../doc/html/boostbook.html) +A Boost documentation system, based on [DocBook](http://www.docbook.org/) and the [Extensible Stylesheet Language + (XSL)](http://www.w3.org/Style/XSL/), used by some Boost libraries. +[bcp](tools/bcp/) +A utility to extract subsets of Boost; to determine which + parts of Boost your code is using; and to print reports on + Boost usage (including Licence information). +[QuickBook](tools/quickbook/index.html) +QuickBook is a WikiWiki style documentation tool geared + towards C++ documentation using simple rules and markup for + simple formatting tasks. QuickBook generates [BoostBook](../doc/html/boostbook.html) XML. +[Wave](../libs/wave/doc/wave_driver.html) +A Standards conformant C/C++ preprocessor usable on top + of any other compiler. Usable for instance for the debugging + of the expansion of macros in your code or as a replacement + for your built-in preprocessor. + + + + + + + + diff --git a/donate/index.html b/donate/index.html new file mode 100644 index 0000000..590ec07 --- /dev/null +++ b/donate/index.html @@ -0,0 +1,121 @@ +--- +title: Donate to the Boost C++ Libraries +copyright: Beman Dawes, David Abrahams, 1998-2005. Rene Rivera 2004-2007. +revised: 2014-08-25 01:40:46 +0100 +--- + + +Donate to the Boost C++ Libraries + +/\* + /\*]]>\*/ + + + + + +Donate to the Boost C++ Libraries +================================= + +According to [OpenHub's + Boost page](https://www.openhub.net/p/boost/estimated_cost), as of August 2014 there are 14.2 million lines + of code in Boost. Given the high quality of coding needed to + pass Boost's community review process, and the extensive unit + and functional testing required, a cost of US$20/line is not + unreasonable. By that metric, the Boost C++ Libraries would + cost US$284 million to rewrite from scratch in a commercial + organization. + + +If you want more of the same, please donate generously. We + will use donations to fund Boost infrastructure, help finance + [the annual C++ Now conference](http://cppnow.org/), + and help fund students to work on Boost code without having to + worry as much about finding the time or money to do so. You + should be aware we may also use donations for any other purpose + the Boost steering committee feels appropriate. +Why ask for donations for the first time in fifteen + years? +----------------------------------------------------------- + + +Boost was not generated, for the most part, by any + commercial organization. It is available in the public interest + as one of the purest forms of open source: its license, + [the Boost + Software License](/LICENSE_1_0.txt), is highly permissive and allows + unrestricted commercial use. Most of the code was written, + documented, and tested in the spare and family time of some of + the very best C++ engineers in the world, many of whom are also + involved in the ISO C++ standardization process. Many of the + additions to the C++ 11 standard library started life in the + Boost libraries, and so will many of the additions and changes + to the next C++ standard library. + + +Yet, for its first fifteen years, Boost has never asked for + donations of money from its users. So why begin now? + + +As Boost grows, more time and resources are being spent on + dealing with the size and complexity of Boost, especially as + libraries are transitioned to make full use of the new language + features in C++ 11/14. If you wish to support those efforts to + bring more Boost libraries into first tier support for the + latest generation of C++, please donate generously. +Why you should donate with a recurring monthly + donation +-------------------------------------------------------- + + +Boost has participated in [Google's + Summer of Code](https://en.wikipedia.org/wiki/Google_Summer_of_Code) since 2007. This is an annual student open-source programming stipend program lasting three months during + which experienced Boost developers mentor students who work on + improving Boost libraries, usually in all the boring, thankless + stuff none of us like to do. The problem with the three month + duration is that the student is only just getting familiar + enough with the Boost libraries to ramp up their + productivity and rate of output when the program ends. This + leads to these outcomes: + + +* We don't reap the full rewards of what we should given + the substantial investment in mentoring our developers invest + into students each year. +* The student is just getting into the Boost libraries when + they need to return to concentrating on their studies, and + often back to the part time work needed to finance the high + expense of university study nowadays. +* Students, when they graduate, get pulled into the + development of proprietary rather than open-source software, + or they end up gravitating to one of the many open source + projects much better at running a student-to-developer + pipeline than Boost historically has been. + + +Whatever the case, Boost is not benefiting as it should from + enthusiastic students with great ideas about where C++ should + go next, and we hope that *you* can help us change + that. + + +So, if you or your company or organization has benefited + from the Boost C++ Libraries, or you would like to assist + promising young C++ engineers develop their talents to the + full, please strongly consider making a regular monthly + donation to Boost! Please donate generously. Thank you in + advance! + + + + + + + + + diff --git a/generated/download-items.html b/generated/download-items.html new file mode 100644 index 0000000..771747f --- /dev/null +++ b/generated/download-items.html @@ -0,0 +1,32 @@ +--- +title: +copyright: +revised: +---* [Current Release](#live) +* [Old Boost Releases](#history) +* [Git Repositories](#repository) + + +Current Release +--------------- + + +### Version 1.80.0 + + +August 10th, 2022 21:25 GMT + + Updated Libraries: Asio, Atomic, Filesystem, GIL, Histogram, Iterator, JSON, + LEAF, Locale, Log, Math, Multiprecision, Multi-index Containers, Nowide, Optional, + STLInterfaces, System, Unordered, Utility, Wave. +* [Release Notes](/users/history/version_1_80_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.80.0/source/) +* [Documentation](/doc/libs/1_80_0/) + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_80\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.80.0/source/boost_1_80_0.tar.bz2) | 1e19565d82e43bc59209a168f5ac899d3ba471d55c7610c677d4ccf2c9c500c0 | +| [boost\_1\_80\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.80.0/source/boost_1_80_0.tar.gz) | 4b2136f98bdd1f5857f1c3dea9ac2018effe65286cf251534b6ae20cc45e1847 | +| windows | [boost\_1\_80\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.80.0/source/boost_1_80_0.7z) | d12a2af721e22dbfb984ef061ee4c4ab2387f1904f6d65bc5acebaa34d6366ec | +| [boost\_1\_80\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.80.0/source/boost_1_80_0.zip) | e34756f63abe8ac34b35352743f17d061fcc825969a2dd8458264edb38781782 | + + diff --git a/generated/history-items.html b/generated/history-items.html new file mode 100644 index 0000000..a6c9473 --- /dev/null +++ b/generated/history-items.html @@ -0,0 +1,1236 @@ +--- +title: +copyright: +revised: +--- + +[Version 1.80.0](/users/history/version_1_80_0.html) +----------------------------------------------------- + + +August 10th, 2022 21:25 GMT + + Updated Libraries: Asio, Atomic, Filesystem, GIL, Histogram, Iterator, JSON, + LEAF, Locale, Log, Math, Multiprecision, Multi-index Containers, Nowide, Optional, + STLInterfaces, System, Unordered, Utility, Wave. + + +* [Release Notes](/users/history/version_1_80_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.80.0/source/) +* [Documentation](/doc/libs/1_80_0/) +[Version 1.79.0](/users/history/version_1_79_0.html) +----------------------------------------------------- + + +April 13th, 2022 14:22 GMT + + Updated Libraries: Asio, Assert, Atomic, Beast, Core, Describe, Filesystem, + Geometry, Integer, IO, Iterator, JSON, Log, Multi-index Containers, Nowide, + Optional, Predef, Smart Pointers, System, ThrowException, Unordered, Variant2, + Wave, LEAF, QVM. + + +* [Release Notes](/users/history/version_1_79_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.79.0/source/) +* [Documentation](/doc/libs/1_79_0/) +[Version 1.78.0](/users/history/version_1_78_0.html) +----------------------------------------------------- + + +December 8th, 2021 03:45 GMT + + Updated Libraries: Asio, Assert, Atomic, Beast, Core, Describe, DLL, Filesystem, + Geometry, JSON, Lambda2, Log, Math, MultiIndex, Multiprecision, Nowide, PFR, + Predef, Regex, System, Utility, Variant2. + + +* [Release Notes](/users/history/version_1_78_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.78.0/source/) +* [Documentation](/doc/libs/1_78_0/) +[Version 1.77.0](/users/history/version_1_77_0.html) +----------------------------------------------------- + + +August 11th, 2021 14:25 GMT + + New Libraries: Describe, Lambda2. Updated Libraries: Any, Asio, Atomic, Beast, + Conversion, Core, DLL, Filesystem, JSON, LexicalCast, Log, Mp11, MultiIndex, + Nowide, PFR, PropertyTree, System, UUID. + + +* [Release Notes](/users/history/version_1_77_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.77.0/source/) +* [Documentation](/doc/libs/1_77_0/) +[Version 1.76.0](/users/history/version_1_76_0.html) +----------------------------------------------------- + + +April 16th, 2021 21:05 GMT + + Updated Libraries: Asio, Atomic, Beast, Bind, Container, Core, DLL, Filesystem, + GIL, Intrusive, Interprocess, JSON, LexicalCast, Log, Math, Move, Multiprecision, + Nowide, Optional, Outcome, Parameter, PFR, PolyCollection, Predef, PropertyTree, + Regex, StackTrace, TypeTraits, Variant2. + + +* [Release Notes](/users/history/version_1_76_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.76.0/source/) +* [Documentation](/doc/libs/1_76_0/) +[Version 1.75.0](/users/history/version_1_75_0.html) +----------------------------------------------------- + + +December 11th, 2020 19:50 GMT + + New Libraries: JSON, LEAF, PFR. Updated Libraries: Asio, Atomic, Beast, Container, + Endian, Filesystem, GIL, Histogram, Interprocess, Intrusive, Log, Move, Mp11, + Optional, Outcome, Polygon, Preprocessor, Rational, Signal2, System, uBLAS, + VMD, Wave. + + +* [Release Notes](/users/history/version_1_75_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.75.0/source/) +* [Documentation](/doc/libs/1_75_0/) +[Version 1.74.0](/users/history/version_1_74_0.html) +----------------------------------------------------- + + +August 14th, 2020 05:02 GMT + + New Libraries: STLInterfaces. Updated Libraries: Asio, Atomic, Beast, Bimap, + Config, Core, DLL, Endian, Filesystem, Flyweight, Format, Geometry, GIL, Heap, + Integer, Iterator, LexicalCast, Log, Mp11, MultiIndex, Nowide, Outcome, PolyCollection, + Polygon, SmartPtr, Stacktrace, System, TypeTraits, Variant, Variant2, Wave, + YAP. + + +* [Release Notes](/users/history/version_1_74_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.74.0/source/) +* [Documentation](/doc/libs/1_74_0/) +[Version 1.73.0](/users/history/version_1_73_0.html) +----------------------------------------------------- + + +April 28th, 2020 03:57 GMT + + New Libraries: Nowide, StaticString. Updated Libraries: Align, Any, Asio, Assert, + Atomic, Beast, Context, Conversion, DateTime, DLL, DynamicBitset, Flyweight, + Geometry, GIL, Histogram, ICL, IO, LexicalCast, Log, Math, Mp11, MultiIndex, + Multiprecision, Outcome, PolyCollection, Stacktrace, Test, ThrowException, + TTI, TypeIndex, Utility, Variant, Variant2, WinAPI. + + +* [Release Notes](/users/history/version_1_73_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.73.0/source/) +* [Documentation](/doc/libs/1_73_0/) +[Version 1.72.0](/users/history/version_1_72_0.html) +----------------------------------------------------- + + +December 11th, 2019 18:06 GMT + + Updated Libraries: Asio, Atomic, Beast, Circular Buffer, Context, Endian, Filesystem, + Functional/Factory, GIL, Histogram, Log, MPI, Math, Multiprecision, Outcome, + PolyCollection, Preprocessor, Smart Pointers, Test, VMD. + + +* [Release Notes](/users/history/version_1_72_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.72.0/source/) +* [Documentation](/doc/libs/1_72_0/) +[Version 1.71.0](/users/history/version_1_71_0.html) +----------------------------------------------------- + + +August 19th, 2019 15:31 GMT + + New Libraries: Variant2. Updated Libraries: Align, Any, Asio, Beast, CircularBuffer, + Container, Context, Conversion, Core, DynamicBitset, Endian, Fiber, Filesystem, + Flyweight, Histogram, Iostreams, Interprocess, Intrusive, LexicalCast, Log, + Math, Metaparse, Move, MultiArray, MultiIndex, Outcome, Parameter, PtrContainer, + PolyCollection, SmartPtr, Stacktrace, Test, Utility, Uuid, Variant, Yap. + + +* [Release Notes](/users/history/version_1_71_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.71.0/source/) +* [Documentation](/doc/libs/1_71_0/) +[Version 1.70.0](/users/history/version_1_70_0.html) +----------------------------------------------------- + + +April 12th, 2019 06:04 GMT + + New Libraries: Outcome, Histogram. Updated Libraries: Asio, Beast, Context, + Coroutine2, Dll, DynamicBitset, Fiber, Filesystem, Integer, Log, Math, Mp11, + MultiIndex, Multiprecision, Polycollection, Spirit, Stacktrace, Test, TypeIndex, + TypeTraits, Variant, Ublas. + + +* [Release Notes](/users/history/version_1_70_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.70.0/source/) +* [Documentation](/doc/libs/1_70_0/) +[Version 1.69.0](/users/history/version_1_69_0.html) +----------------------------------------------------- + + +December 12th, 2018 02:58 GMT + + New Libraries: Safe Numerics. Updated Libraries: Any, Asio, Assign, Beast, + CircularBuffer, Concept Check, Core, DLL, Dynamic Bitset, Fiber, Filesystem, + Flyweight, Geometry, Integer, Iostreams, Iterator, LexicalCast, Log, Logic, + Math, Mp11, MultiArray, Multi-index Containers, Multiprecision, PolyCollection, + Pool, Preprocessor, Rational, Spirit, Stacktrace, System, Test, TypeIndex, + Utility, Variant, YAP. Discontinued Libraries: Signals. + + +* [Release Notes](/users/history/version_1_69_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.69.0/source/) +* [Documentation](/doc/libs/1_69_0/) +[Version 1.68.0](/users/history/version_1_68_0.html) +----------------------------------------------------- + + +August 9th, 2018 03:46 GMT + + New Libraries: YAP. Updated Libraries: Beast, Context, Coroutine2, Fiber, Fusion, + Geometry, GIL, Graph, Lexical Cast, Log, Math, Multiprecision, Optional, Predef, + Program Options, Python, Rational, System, Signals, Spirit, Stacktrace, Test, + TypeIndex, Uuid. + + +* [Release Notes](/users/history/version_1_68_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.68.0/source/) +* [Documentation](/doc/libs/1_68_0/) +[Version 1.67.0](/users/history/version_1_67_0.html) +----------------------------------------------------- + + +April 14th, 2018 20:37 GMT + + New Libraries: Contract, HOF. Updated Libraries: Asio, Atomic, Beast, Container + Hash, Context, Core, Coroutine2, DateTime, DLL, Fiber, Filesystem, Fusion, + Locale, Log, Math, Multi-index Containers, Multiprecision, Optional, Phoenix, + PolyCollection, Python, Spirit, Stacktrace, Test, TypeIndex, TypeTraits, Unordered, + Units, Uuid, Utility, Variant. + + +* [Release Notes](/users/history/version_1_67_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.67.0/source/) +* [Documentation](/doc/libs/1_67_0/) +[Version 1.66.0](/users/history/version_1_66_0.html) +----------------------------------------------------- + + +December 18th, 2017 13:58 GMT + + New Libraries: Beast, CallableTraits, Mp11. Updated Libraries: Asio, Atomic, + DateTime, Fiber, Format, Fusion, Geometry, Iterator, Log, Multi-index Containers, + Optional, PolyCollection, Predef, Stacktrace, Thread, Utility, Uuid, Variant. + + +* [Release Notes](/users/history/version_1_66_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.66.0/source/) +* [Documentation](/doc/libs/1_66_0/) +[Version 1.65.1](/users/history/version_1_65_1.html) +----------------------------------------------------- + + +September 7th, 2017 17:31 GMT + + Bug fixes: Config, Context, Fiber, Smart Pointers, Stacktrace, Thread + + +* [Release Notes](/users/history/version_1_65_1.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.65.1/source/) +* [Documentation](/doc/libs/1_65_1/) +[Version 1.65.0](/users/history/version_1_65_0.html) +----------------------------------------------------- + + +August 21st, 2017 20:50 GMT + + New Libraries: PolyCollection, Stacktrace. Removed Libraries: TR1. Updated + Libraries: Asio, Context, Config, Core, Coroutine2, DLL, Fiber, Fusion, Geometry, + Hash, Log, Phoenix, Predef, Program Options, Python, Smart Pointers, Test, + Thread, TypeIndex, Typeof, Unordered, Utility, Variant. + + +* [Release Notes](/users/history/version_1_65_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.65.0/source/) +* [Documentation](/doc/libs/1_65_0/) +[Version 1.64.0](/users/history/version_1_64_0.html) +----------------------------------------------------- + + +April 19th, 2017 17:42 GMT + + New Library: Process. Updated Libraries: Any, Atomic, Config, Container, Context, + Conversion, Core, Coroutine2, DLL, Fiber, Geometry, Hash, Interprocess, Intrusive, + LexicalCast, Math, Multi-index Containers, Multiprecision, Predef, Regex, Smart + Pointers, Test, TypeIndex, TypeTraits, Unordered, Variant. + + +* [Release Notes](/users/history/version_1_64_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.64.0/source/) +* [Documentation](/doc/libs/1_64_0/) +[Version 1.63.0](/users/history/version_1_63_0.html) +----------------------------------------------------- + + +December 26th, 2016 23:43 GMT + + Updated Libraries: Atomic, Container, Context, Fiber, Fusion, Geometry, Hash, + Interprocess, Intrusive, LexicalCast, Log, Metaparse, Move, Optional, Phoenix, + Python, Test, TypeIndex, Units, Unordered. + + +* [Release Notes](/users/history/version_1_63_0.html) +* [Download](https://sourceforge.net/projects/boost/files/boost/1.63.0/) +* [Documentation](/doc/libs/1_63_0/) +[Version 1.62.0](/users/history/version_1_62_0.html) +----------------------------------------------------- + + +September 28th, 2016 15:17 GMT + + New Libraries: Fiber, QVM Updated Libraries: Chrono, Circular Buffer, Container, + Context, Coroutine2, DLL, Functional/Forward, Geometry, Interprocess, Intrusive, + Lexical Cast, Log, Math, Phoenix, Regex, Test, Thread, TypeIndex, Unordered, + Variant. + + +* [Release Notes](/users/history/version_1_62_0.html) +* [Download](https://sourceforge.net/projects/boost/files/boost/1.62.0/) +* [Documentation](/doc/libs/1_62_0/) +[Version 1.61.0](/users/history/version_1_61_0.html) +----------------------------------------------------- + + +May 13th, 2016 02:58 GMT + + New Libraries: Compute, DLL, Hana, Metaparse. Updated Libraries: Any, Container, + Context, Coroutine, Coroutine2, Fusion, Geometry, Interprocess, Intrusive, + Lexical Cast, Log, Move, Optional, Test, Variant. + + +* [Release Notes](/users/history/version_1_61_0.html) +* [Download](https://sourceforge.net/projects/boost/files/boost/1.61.0/) +* [Documentation](/doc/libs/1_61_0/) +[Version 1.60.0](/users/history/version_1_60_0.html) +----------------------------------------------------- + + +December 17th, 2015 15:52 GMT + + New Libraries: VMD Updated Libraries: Atomic, Chrono, Container, Context, Core, + Filesystem, Flyweight, Fusion, Interprocess, Intrusive, Lexical Cast, Locale, + Log, Move, Multi-index Containers, odeint, Optional, Predef, Test, Thread, + UUID. + + +* [Release Notes](/users/history/version_1_60_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.60.0/) +* [Documentation](/doc/libs/1_60_0/) +[Version 1.59.0](/users/history/version_1_59_0.html) +----------------------------------------------------- + + +August 13th, 2015 15:23 GMT + + New Libraries: Convert, Coroutine2. Updated Libraries: Container, Context, + Coroutine, Fusion, Geometry, Interprocess, Intrusive, Lexical Cast, Log, Move, + Multi-index Containers, Predef, Program Options, Property Tree, Test, TypeIndex, + Variant. + + +* [Release Notes](/users/history/version_1_59_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.59.0/) +* [Documentation](/doc/libs/1_59_0/) +[Version 1.58.0](/users/history/version_1_58_0.html) +----------------------------------------------------- + + +April 17th, 2015 07:53 GMT + + New Libraries: Endian, Sort. Updated Libraries: Asio, Chrono, Container, Context, + Conversion, DateTime, Flyweight, Function, Functional/Factory, Fusion, Geometry, + Hash, Interprocess, Intrusive, Lexical Cast, Log, Math, Move, Multi-index Containers, + Multiprecision, Optional, Phoenix, Predef, Random, Thread, TypeErasure, TypeIndex, + Units, Unordered, Variant. + + +* [Release Notes](/users/history/version_1_58_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.58.0/) +* [Documentation](/doc/libs/1_58_0/) +[Version 1.57.0](/users/history/version_1_57_0.html) +----------------------------------------------------- + + +November 3rd, 2014 21:55 GMT + + Updated Libraries: Any, Asio, Circular Buffer, Config, Container, Coroutine, + Flyweight, Geometry, Interprocess, Intrusive, Iterator, Lexical Cast, Math, + Move, MultiArray, Multiprecision, Multi-Index Containers, Preprocessor, Thread, + TypeIndex, TypeTraits, Units, Unordered, Utility, uBLAS. + + +* [Release Notes](/users/history/version_1_57_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.57.0/) +* [Documentation](/doc/libs/1_57_0/) +[Version 1.56.0](/users/history/version_1_56_0.html) +----------------------------------------------------- + + +August 7th, 2014 16:08 GMT + + New libraries: Align, TypeIndex. New modules from existing code: Assert, Core, + Lexical\_Cast, Throw\_Exception. Updated libraries: Accumulators, Any, Asio, + Assign, Atomic, Circular Buffer, Concept Check, Container, Context, Coroutine, + Dynamic Bitset, Chrono, Flyweight, Fusion, Geometry, Hash, Interprocess, Intrusive, + Log, Math, Move, MPL, MultiArray, Multi-index Containers, Multiprecision, Odeint, + Optional, Predef, Preprocessor, Program Options, Regex, Smart Pointers, Thread, + TTI, Unordered, Utility, UUID, Variant. Deprecated Libraries: TR1 + + +* [Release Notes](/users/history/version_1_56_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.56.0/) +* [Documentation](/doc/libs/1_56_0/) +[Version 1.55.0](/users/history/version_1_55_0.html) +----------------------------------------------------- + + +November 11th, 2013 19:50 GMT + + New Libraries: Predef. Updated Libraries: Accumulators, Any, Asio, Atomic, + Config, Chrono, Circular Buffer, Container, Context, Coroutine, Filesystem, + Fusion, Geometry, Graph, Hash, Interprocess, Intrusive, Lexical Cast, Log, + Math, Meta State Machine, Move, Multiprecision, Multi-index Containers, MPI, + Phoenix, Polygon, PropertyMap, Rational, Thread, Timer, Type Traits, Unordered, + Utility, Variant, Wave, xpressive. + + +* [Release Notes](/users/history/version_1_55_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.55.0/) +* [Documentation](/doc/libs/1_55_0/) +[Version 1.54.0](/users/history/version_1_54_0.html) +----------------------------------------------------- + + +July 1st, 2013 17:10 GMT + + Changes to supported CPUs. New Libraries: Log, TTI, Type Erasure. Updated Libraries: + Accumulators, Algorithm, Any, Asio, Chrono, Circular Buffer, Container, Context, + Coroutine, Geometry, Graph, Interprocess, Intrusive, Iostreams, Lexical Cast, + Math, Meta State Machine, Move, Multiprecision, Polygon, Property Map, Range, + Thread, Type Traits, uBLAS, Unordered, Utility, Variant, Wave, xpressive Deprecated + Library: Signals. + + +* [Release Notes](/users/history/version_1_54_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.54.0/) +* [Documentation](/doc/libs/1_54_0/) +[Version 1.53.0](/users/history/version_1_53_0.html) +----------------------------------------------------- + + +February 4th, 2013 18:29 GMT + + New Libraries: Atomic, Coroutine, Lockfree, Multiprecision, Odeint. Updated + Libraries: Algorithm, Array, Asio, Bimap, Chrono, Container, Context, Geometry, + GIL, Graph, Hash, Interprocess, Intrusive, Lexical Cast, Locale, Math, MinMax, + Move, Polygon, Random, Range, Ratio, Regex, Smart Pointers, StringAlgo, Thread, + Utility, Unordered, Variant, Wave and xpressive. + + +* [Release Notes](/users/history/version_1_53_0.html) +* [Download](https://sourceforge.net/projects/boost/files/boost/1.53.0/) +* [Documentation](/doc/libs/1_53_0/) +[Version 1.52.0](/users/history/version_1_52_0.html) +----------------------------------------------------- + + +November 5th, 2012 16:05 GMT + + Updated Libraries: Accumulators, Config, Chrono, Container, DateTime, Foreach, + Function, Graph, Hash, Interprocess, Iterator, Lexical Cast, Math, Phoenix, + Polygon, Proto, Ratio, Result\_of, Thread, uBLAS, Unordered, Uuid, Wave, xpressive. + + +* [Release Notes](/users/history/version_1_52_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.52.0/) +* [Documentation](/doc/libs/1_52_0/) +[Version 1.51.0](/users/history/version_1_51_0.html) +----------------------------------------------------- + + +August 20th, 2012 23:00 GMT + + New Libraries: Context. Updated Libraries: Algorithm, Asio, Config, Chrono, + Geometry, Graph, Hash, Lexical Cast, Math, MSM, Proto, Ratio, Regex, Thread, + Unordered, Wave, xpressive + + +* [Release Notes](/users/history/version_1_51_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.51.0/) +* [Documentation](/doc/libs/1_51_0/) +[Version 1.50.0](/users/history/version_1_50_0.html) +----------------------------------------------------- + + +June 28th, 2012 12:48 GMT + + New Libraries: Algorithm, Functional/OverloadedFunction, LocalFunction, Utility/IdentityType. + Updated Libraries: Accumulators, Array, Asio, Bimap, Chrono, Concept Check, + Filesystem, Foreach, Graph, Geometry, Hash, Iostreams, Iterator, MultiArray, + Lexical cast, Locale, MSM, Program Options, PropertyMap, Proto, Ratio, ScopeExit, + Thread, Unordered, Wave, xpressive + + +* [Release Notes](/users/history/version_1_50_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.50.0/) +* [Documentation](/doc/libs/1_50_0/) +[Version 1.49.0](/users/history/version_1_49_0.html) +----------------------------------------------------- + + +February 24th, 2012 21:20 GMT + + New Library: Heap. Updated Libraries: Asio, Chrono, Container, Filesystem, + Foreach, Geometry, Graph, Icl, Interprocess, Intrusive, Lexical Cast, Locale, + Move, Property Tree, Proto, Spirit, Thread, Unordered, Uuid, xpressive. + + +* [Release Notes](/users/history/version_1_49_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.49.0/) +* [Documentation](/doc/libs/1_49_0/) +[Version 1.48.0](/users/history/version_1_48_0.html) +----------------------------------------------------- + + +November 15th, 2011 15:47 GMT + + New Libraries: Container, Locale, Move. Updated Libraries: Asio, Chrono, Config, + Fusion, Geometry, Graph, Interprocess, Intrusive, Lexical cast, Math, MSM, + Numeric Conversion, Proto, Regex, Spirit, TypeTraits, Unordered, Wave + + +* [Release Notes](/users/history/version_1_48_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.48.0/) +* [Documentation](/doc/libs/1_48_0/) +[Version 1.47.0](/users/history/version_1_47_0.html) +----------------------------------------------------- + + +July 11th, 2011 22:19 GMT + + New Libraries: Chrono, Geometry, Phoenix and Ratio. Updated Libraries: Accumulators, + Asio, Config, DateTime, Dynamic Bitset, Foreach, Function, Function Types, + Graph, Iostreams, Iterator, Lexical Cast, Logic, Math, Meta State Machine, + MultiIndex, Proto, Random, Range, Spirit, Tokenizer, Utility, Uuid, Wave + + +* [Release Notes](/users/history/version_1_47_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.47.0/) +* [Documentation](/doc/libs/1_47_0/) +[Version 1.46.1](/users/history/version_1_46_1.html) +----------------------------------------------------- + + +March 12th, 2011 15:45 GMT + + Bug fixes: Asio, Fusion, Graph, Icl, Math, Polygon, Proto, Property Tree, Signals2, + TR1, Unordered. + + +* [Release Notes](/users/history/version_1_46_1.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.46.1/) +* [Documentation](/doc/libs/1_46_1/) +[Version 1.46.0](/users/history/version_1_46_0.html) +----------------------------------------------------- + + +February 21st, 2011 20:36 GMT + + New Libraries: Icl. Updated Libraries: Array, Asio, Bind, Concept Check, Filesystem, + Fusion, Hash, Iostreams, Iterator, Math, Meta State Machine, Optional, Pool, + Program Options, Proto, Signals, Spirit, Tokenizer, Unordered, Wave. Updated + Tools: Boostbook, Inspect, Quickbook. + + +* [Release Notes](/users/history/version_1_46_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.46.0/) +* [Documentation](/doc/libs/1_46_0/) +[Version 1.45.0](/users/history/version_1_45_0.html) +----------------------------------------------------- + + +November 19th, 2010 16:00 GMT + + Updated Libraries: Asio, Config, Flyweight, Foreach, Fusion, Graph, Interprocess, + Math, Meta State Machine, MultiArray, Proto, Spirit, TypeTraits, uBLAS, Unordered, + Wave, Xpressive. Updated tools: Boostbook, Quickbook + + +* [Release Notes](/users/history/version_1_45_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.45.0/) +* [Documentation](/doc/libs/1_45_0/) +[Version 1.44.0](/users/history/version_1_44_0.html) +----------------------------------------------------- + + +August 13th, 2010 17:00 GMT + + New Libraries: Meta State Machine, Polygon. Updated Libraries: Accumulators, + Asio, Config, Filesystem, Foreach, Fusion, Hash, Iostreams, Math, MPL, Multi-index + Containers, Proto, Regex, Spirit, Thread, TR1, Type Traits, uBLAS, Utility, + Uuid, Wave, Xpressive. Updates for Quickbook and Boostbook. + + +* [Release Notes](/users/history/version_1_44_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.44.0/) +* [Documentation](/doc/libs/1_44_0/) +[Version 1.43.0](/users/history/version_1_43_0.html) +----------------------------------------------------- + + +May 6th, 2010 12:00 GMT + + New Libraries: Functional/Factory, Functional/Forward. Major Update: Range. + Updated Libraries: Accumulators, Array, Asio, Fusion, Iostreams, Multi-index + Containers, Proto, Random, Spirit, Thread, Unordered, Uuid, Wave, Xpressive. + Also, updates to the build system and quickbook. + + +* [Release Notes](/users/history/version_1_43_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.43.0/) +* [Documentation](/doc/libs/1_43_0/) +[Version 1.42.0](/users/history/version_1_42_0.html) +----------------------------------------------------- + + +February 2nd, 2010 14:00 GMT + + New Libraries: Uuid. Updated Libraries: Asio, Circular Buffer, Fusion, Graph, + Integer, Iostreams, Program.Options, PropertyMap, Proto, Regex, Spirit, Unordered, + Xpressive. + + +* [Release Notes](/users/history/version_1_42_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.42.0/) +* [Documentation](/doc/libs/1_42_0/) +[Version 1.41.0](/users/history/version_1_41_0.html) +----------------------------------------------------- + + +November 17th, 2009 17:00 GMT + + New Library: Property Tree. Updated libraries: DateTime, Filesystem, Iostreams, + Math, Multi-index Containers, Proto, Python, Regex, Spirit, System, Thread, + Unordered, Utility, Wave, Xpressive. Updates to boost build and quickbook. + The CMake build system for Boost, still under development [here](http://sodium.resophonic.com/boost-cmake/current-docs/), + has been removed from the main release to avoid confusion. + + +* [Release Notes](/users/history/version_1_41_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.41.0/) +* [Documentation](/doc/libs/1_41_0/) +[Version 1.40.0](/users/history/version_1_40_0.html) +----------------------------------------------------- + + +August 27th, 2009 17:00 GMT + + Build System improvements. Updated Libraries: Accumulators, Asio, Circular + Buffer, Foreach, Function, Fusion, Graph, Hash, Interprocess, Intrusive, MPL, + Program.Options, Property Map, Proto, Random, Serialization, Unordered, Xpressive. + + +* [Release Notes](/users/history/version_1_40_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.40.0/) +* [Documentation](/doc/libs/1_40_0/) +[Version 1.39.0](/users/history/version_1_39_0.html) +----------------------------------------------------- + + +May 2nd, 2009 12:00 GMT + + New Libraries: Signals2. Updated Libraries: Asio, Flyweight, Foreach, Hash, + Interprocess, Intrusive, Program.Options, Proto, PtrContainer, Range, Unordered, + Xpressive. Updated Tools: Boostbook, Quickbook. + + +* [Release Notes](/users/history/version_1_39_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.39.0/) +* [Documentation](/doc/libs/1_39_0/) +[Version 1.38.0](/users/history/version_1_38_0.html) +----------------------------------------------------- + + +February 8th, 2009 12:00 GMT + + New Libraries: Flyweight, ScopeExit, Swap. Updated Libraries: Accumulators, + Any, Asio, Config, Date\_Time, Exception, Filesystem, Graph, Hash, Interprocess, + Intrusive, Lexical Cast, Math, Multi-index Containers, Proto, Regex, Thread, + TR1, Type Traits, Unordered, Xpressive. Other Changes: Experimental CMake build + system. + + +* [Release Notes](/users/history/version_1_38_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.38.0/) +* [Documentation](/doc/libs/1_38_0/) +[Version 1.37.0](/users/history/version_1_37_0.html) +----------------------------------------------------- + + +November 3rd, 2008 12:00 GMT + + New Library: Proto. Updated Libraries: Asio, Circular Buffer, Dynamic Bitset, + Exception, Hash, Interprocess, Intrusive, Math, Type Traits, Unordered + + +* [Release Notes](/users/history/version_1_37_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.37.0/) +* [Documentation](/doc/libs/1_37_0/) +[Version 1.36.0](/users/history/version_1_36_0.html) +----------------------------------------------------- + + +August 14th, 2008 12:00 GMT + + New Libraries: Accumulators, Exception, Units, Unordered. Updated Libraries: + Asio, Assign, Circular Buffer, Foreach, Function, Hash, Interprocess, Intrusive, + Math, Multi-index Containers, MPI, PtrContainer, Spirit, Thread, Wave, Xpressive. + + +* [Release Notes](/users/history/version_1_36_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.36.0/) +* [Documentation](/doc/libs/1_36_0/) +[Version 1.35.0](/users/history/version_1_35_0.html) +----------------------------------------------------- + + +March 29th, 2008 12:00 GMT + + New Libraries: Asio, Bimap, Circular Buffer, Function Types, Fusion, GIL, Interprocess, + Intrusive, Math/Special Functions, Math/Statistical Distributions, MPI, System. + Updated Libraries: Graph, Hash, Iostreams, Multi Array, Multi-index Containers, + Serialization, Thread, Wave, Xpressive. + + +* [Release Notes](/users/history/version_1_35_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.35.0/) +* [Documentation](/doc/libs/1_35_0/) +[Version 1.34.1](/users/history/version_1_34_1.html) +----------------------------------------------------- + + +July 24th, 2007 12:00 GMT + + Bugfix Release. + + +* [Release Notes](/users/history/version_1_34_1.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.34.1/) +* [Documentation](/doc/libs/1_34_1/) +[Version 1.34.0](/users/history/version_1_34_0.html) +----------------------------------------------------- + + +May 12th, 2007 12:00 GMT + + New Libraries: Foreach, Statechart, TR1, Typeof, Xpressive. Updated Libraries: + Assign, Date\_time, Filesystem, Function, Hash, Graph, MultiArray, Multi-Index, + Optional, Parameter, Pointer Container, Python, Signals, Smart Pointer, String + Algorithm, Wave + + +* [Release Notes](/users/history/version_1_34_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.34.0/) +* [Documentation](/doc/libs/1_34_0/) +[Version 1.33.1](/users/history/version_1_33_1.html) +----------------------------------------------------- + + +December 5th, 2006 12:00 GMT + + Updated Libraries: Any, Config, Python, Smart Pointer, Regex, Iostreams, Functional/Hash, + Multi-index Containers, Graph, Signals, Thread, and Wave. + + +* [Release Notes](/users/history/version_1_33_1.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.33.1/) +* [Documentation](/doc/libs/1_33_1/) +[Version 1.33.0](/users/history/version_1_33_0.html) +----------------------------------------------------- + + +August 11th, 2005 12:00 GMT + + New Libraries: Iostream, Hash, Parameter, Pointer Container, Wave. Updated + Libraries: Any, Assignment, Bind, Date-Time, Graph, Multi-Index, Program Options, + Property Map, Python, Random Number, Range, Regex, Serialization, Signals. + + +* [Release Notes](/users/history/version_1_33_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.33.0/) +[Version 1.32.0](/users/history/version_1_32_0.html) +----------------------------------------------------- + + +November 19th, 2004 12:00 GMT + + New Libraries: Assignment, Minmax, Multi-Index, Numeric Conversion, Program + Options, Range, Serialization, String, Tribool. Updated Libraries: Graph, MPL, + Python, Signals, Utility, Test. Removed Libraries: Compose. + + +* [Release Notes](/users/history/version_1_32_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.32.0/) +* [Documentation](/doc/libs/1_32_0/) +[Version 1.31.0](/users/history/version_1_31_0.html) +----------------------------------------------------- + + +January 26th, 2004 12:00 GMT + + New Libraries: enable\_if, Variant. Updated Libraries: Date Time, Filesystem, + Iterator, MultiArray, Python, Random Number, Regex, Spirit, Test. Deprecated + Libraries: Compose. + + +* [Release Notes](/users/history/version_1_31_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.31.0/) +* [Documentation](/doc/libs/1_31_0/) +[Version 1.30.2](/users/history/version_1_30_2.html) +----------------------------------------------------- + + +August 19th, 2003 12:00 GMT + + Bugfix release + + +* [Release Notes](/users/history/version_1_30_2.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.30.2/) +[Version 1.30.1](/users/history/version_1_30_1.html) +----------------------------------------------------- + + +August 4th, 2003 12:00 GMT + + Withdrawn bug fix release, fixes for Lambda, Spirit, MPL, Function, Config, + Format, Regex, Smart Pointers, Python + + +* [Release Notes](/users/history/version_1_30_1.html) +[Version 1.30.0](/users/history/version_1_30_0.html) +----------------------------------------------------- + + +March 19th, 2003 12:00 GMT + + New Libraries: Filesystem, Optional, Interval, MPL, Spirit Updated Libraries: + Smart Pointers, Utility, Date-Time, Function, Operators, Test + + +* [Release Notes](/users/history/version_1_30_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.30.0/) +[Version 1.29.0](/users/history/version_1_29_0.html) +----------------------------------------------------- + + +October 10th, 2002 12:00 GMT + + New Libraries: Date-Time, Dynamic Bitset, Format. Updated Libraries: Function, + Multi-Array, Preprocessor, Python, Signals, uBLASH. + + +* [Release Notes](/users/history/version_1_29_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.29.0/) +[Version 1.28.0](/users/history/version_1_28_0.html) +----------------------------------------------------- + + +May 15th, 2002 12:00 GMT + + New Libraries: Lambda, I/O State Saver. Updated Libraries: Configuration, Random + Number, Smart Pointers, Function Utility. + + +* [Release Notes](/users/history/version_1_28_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.28.0/) +[Version 1.27.0](/users/history/version_1_27_0.html) +----------------------------------------------------- + + +February 5th, 2002 12:00 GMT + + Updated Libraries: Python, Integer, Function, Quaternions, Octonions, Smart + Pointers, Preprocessor, Threads. + + +* [Release Notes](/users/history/version_1_27_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.27.0/) +[Version 1.26.0](/users/history/version_1_26_0.html) +----------------------------------------------------- + + +November 30th, 2001 12:00 GMT + + New Libraries: Common Factor, Preprocessor. Updated Libraries: Iterator Adaptor, + Random Number, Operators. + + +* [Release Notes](/users/history/version_1_26_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.26.0/) +[Version 1.25.1](/users/history/version_1_25_1.html) +----------------------------------------------------- + + +November 5th, 2001 12:00 GMT + + Updated Libraries: Graph, Thread, Function. + + +* [Release Notes](/users/history/version_1_25_1.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.25.1/) +[Version 1.25.0](/users/history/version_1_25_0.html) +----------------------------------------------------- + + +October 1st, 2001 12:00 GMT + + New Libraries: Thread, Bind. Updated Libraries: Utility, Array, Config, Random + Number, Math, Tokenizer. + + +* [Release Notes](/users/history/version_1_25_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.25.0/) +[Version 1.24.0](/users/history/version_1_24_0.html) +----------------------------------------------------- + + +August 19th, 2001 12:00 GMT + + New Library: Tuple. + + +* [Release Notes](/users/history/version_1_24_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.24.0/) +[Version 1.23.0](/users/history/version_1_23_0.html) +----------------------------------------------------- + + +July 6th, 2001 12:00 GMT + + New Libraries: Any, Function, Tokenizer, Special functions, Octonions, Quaternions. + Updated Library: Smart Pointer. + + +* [Release Notes](/users/history/version_1_23_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.23.0/) +[Version 1.22.0](/users/history/version_1_22_0.html) +----------------------------------------------------- + + +May 25th, 2001 12:00 GMT + + New Libary: CRC. Updated Libraries: Graph, Integer, Regex, Smart Pointer, Utility. + + +* [Release Notes](/users/history/version_1_22_0.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.22.0/) +[Version 1.21.2](/users/history/version_1_21_2.html) +----------------------------------------------------- + + +April 24th, 2001 12:00 GMT + + New Libraries: Compatibility. Updated Libraries: Random Number, Integer, Graph. + + +* [Release Notes](/users/history/version_1_21_2.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.21.2/) +[Version 1.21.1](/users/history/version_1_21_1.html) +----------------------------------------------------- + + +March 14th, 2001 12:00 GMT + + Updated Libraries: Graph, Python, Regex. + + +* [Release Notes](/users/history/version_1_21_1.html) +* [Download](http://sourceforge.net/projects/boost/files/boost/1.21.1/) +[Version 1.21.0](/users/history/version_1_21_0.html) +----------------------------------------------------- + + +March 9th, 2001 12:00 GMT + + New Libraries: Iterator Adaptor, Pool, Test. Updated Libraries: Graph, Python, + Regular Expression, Type Traits. + + +* [Release Notes](/users/history/version_1_21_0.html) +[Version 1.20.2](/users/history/version_1_20_2.html) +----------------------------------------------------- + + +February 10th, 2001 12:00 GMT + + Updated Libraries: Array traits, Graph, Integer, Random Number, Rational Number, + Regular Expression, Smart Pointer, Timer. + + +* [Release Notes](/users/history/version_1_20_2.html) +* [Download](http://sourceforge.net/project/showfiles.php?group_id=7586&package_id=8041&release_id=138112) +[Version 1.20.1](/users/history/version_1_20_1.html) +----------------------------------------------------- + + +January 10th, 2001 12:00 GMT + + Updated Libraries: Compressed Pair, Graph Library, Regular Expression. + + +* [Release Notes](/users/history/version_1_20_1.html) +[Version 1.20.0](/users/history/version_1_20_0.html) +----------------------------------------------------- + + +January 6th, 2001 12:00 GMT + + New Library: Conversion. Updated Libraries: Array, Graph, Regular Expression. + + +* [Release Notes](/users/history/version_1_20_0.html) +[Version 1.19.0](/users/history/version_1_19_0.html) +----------------------------------------------------- + + +December 10th, 2000 12:00 GMT + + New Libraries: Concept Check, Python, Static Assert, Property Map Concepts. + Updated Libraries: Graph, Regular Expression. + + +* [Release Notes](/users/history/version_1_19_0.html) +[Version 1.18.3](/users/history/version_1_18_3.html) +----------------------------------------------------- + + +November 18th, 2000 12:00 GMT + + Updated Libraries: Graph, Regular Expression, Cast. + + +* [Release Notes](/users/history/version_1_18_3.html) +[Version 1.18.2](/users/history/version_1_18_2.html) +----------------------------------------------------- + + +November 3rd, 2000 12:00 GMT + + Updated Libraries: Case, Graph, Regular Expression, Configuration. Utility + library split into separate libraries. + + +* [Release Notes](/users/history/version_1_18_2.html) +[Version 1.18.1](/users/history/version_1_18_1.html) +----------------------------------------------------- + + +October 15th, 2000 12:00 GMT + + Updated Libraries: Graph, Random, Regular Expression, Configuration. + + +* [Release Notes](/users/history/version_1_18_1.html) +[Version 1.18.0](/users/history/version_1_18_0.html) +----------------------------------------------------- + + +September 28th, 2000 12:00 GMT + + New Libraries: Graph, Regular Expression. Updated Libraries: Array, Functional, + Utility, Integer. + + +* [Release Notes](/users/history/version_1_18_0.html) +[Version 1.17.0](/users/history/version_1_17_0.html) +----------------------------------------------------- + + +August 3rd, 2000 12:00 GMT + + Added Library: Array. Updated Libraries: Array Traits, Random Number, Smart + Pointer. + + +* [Release Notes](/users/history/version_1_17_0.html) +[Version 1.16.1](/users/history/version_1_16_1.html) +----------------------------------------------------- + + +July 5th, 2000 12:00 GMT + + Updated Libraries: Integer, Random Number, Cast, Call Traits, Operators. + + +* [Release Notes](/users/history/version_1_16_1.html) +[Version 1.16.0](/users/history/version_1_16_0.html) +----------------------------------------------------- + + +June 28th, 2000 12:00 GMT + + New Libraries: Functional, iterator header, Updated Libraries: Random Number, + Rational, Cast, Smart Pointer, Config. + + +* [Release Notes](/users/history/version_1_16_0.html) +[Version 1.15.1](/users/history/version_1_15_1.html) +----------------------------------------------------- + + +June 21st, 2000 12:00 GMT + + Updated Libraries: Cast, Operators, Config. + + +* [Release Notes](/users/history/version_1_15_1.html) +[Version 1.15.0](/users/history/version_1_15_0.html) +----------------------------------------------------- + + +June 17th, 2000 12:00 GMT + + Added Library: Random Number. Updated Libraries: Utility, Config, Cast. + + +* [Release Notes](/users/history/version_1_15_0.html) +[Version 1.14.3](/users/history/version_1_14_3.html) +----------------------------------------------------- + + +May 29th, 2000 12:00 GMT + + Updated Libraries: Config, Type Traits. + + +* [Release Notes](/users/history/version_1_14_3.html) +[Version 1.14.2](/users/history/version_1_14_2.html) +----------------------------------------------------- + + +May 9th, 2000 12:00 GMT + + Documentation updates. + + +* [Release Notes](/users/history/version_1_14_2.html) +[Version 1.14.1](/users/history/version_1_14_1.html) +----------------------------------------------------- + + +March 17th, 2000 12:00 GMT + + Updated Libraries: Rational, Smart Pointer, Call Traits, Compressed Pair, Type + Traits. + + +* [Release Notes](/users/history/version_1_14_1.html) +[Version 1.14.0](/users/history/version_1_14_0.html) +----------------------------------------------------- + + +March 5th, 2000 12:00 GMT + + Updated Libraries: Integer. Experimental libraries moved to vault. + + +* [Release Notes](/users/history/version_1_14_0.html) +[Version 1.13.0](/users/history/version_1_13_0.html) +----------------------------------------------------- + + +February 29th, 2000 12:00 GMT + + Added Libraries: Utility, Type Traits, Call Traits, Compressed Pair. + + +* [Release Notes](/users/history/version_1_13_0.html) +[Version 1.12.0](/users/history/version_1_12_0.html) +----------------------------------------------------- + + +February 23rd, 2000 12:00 GMT + + Updated Library: Integer. + + +* [Release Notes](/users/history/version_1_12_0.html) +[Version 1.11.2](/users/history/version_1_11_2.html) +----------------------------------------------------- + + +February 21st, 2000 12:00 GMT + + Updated Libraries: Smart Pointer. + + +* [Release Notes](/users/history/version_1_11_2.html) +[Version 1.11.1](/users/history/version_1_11_1.html) +----------------------------------------------------- + + +February 2nd, 2000 12:00 GMT + + Minor fix for cast.hpp. + + +* [Release Notes](/users/history/version_1_11_1.html) +[Version 1.11.0](/users/history/version_1_11_0.html) +----------------------------------------------------- + + +February 1st, 2000 12:00 GMT + + New Library: Rational Number. Updated Libraries: Case, Config, Smart Pointer, + Utility. + + +* [Release Notes](/users/history/version_1_11_0.html) +[Version 1.10.4](/users/history/version_1_10_4.html) +----------------------------------------------------- + + +December 31st, 1999 12:00 GMT + + Updated Libraries: Smart Pointer, Cast. + + +* [Release Notes](/users/history/version_1_10_4.html) +[Version 1.10.3](/users/history/version_1_10_3.html) +----------------------------------------------------- + + +December 30th, 1999 12:00 GMT + + Updated Libraries: Compse, Operators, Cast, Config, Smart Pointer First release + with a version number. + + +* [Release Notes](/users/history/version_1_10_3.html) +[Old Versions](/users/history/old_versions.html) +------------------------------------------------- + + +December 14th, 1999 12:00 GMT + + Early releases of boost without version numbers. + + +* [Release Notes](/users/history/old_versions.html) + + diff --git a/generated/home-items.html b/generated/home-items.html new file mode 100644 index 0000000..951fb2f --- /dev/null +++ b/generated/home-items.html @@ -0,0 +1,42 @@ +--- +title: +copyright: +revised: +--- +Downloads +--------- +### Current Release + + +* [Version 1.80.0](/users/history/version_1_80_0.html)[Release Notes](/users/history/version_1_80_0.html) | [Download](https://boostorg.jfrog.io/artifactory/main/release/1.80.0/source/) | [Documentation](/doc/libs/1_80_0/)August 10th, 2022 21:25 GMT +[More Downloads...](/users/download/) ([RSS](feed/downloads.rss)) + +News +---- + + +* [Version 1.80.0](/users/history/version_1_80_0.html) + + Updated Libraries: Asio, Atomic, Filesystem, GIL, Histogram, Iterator, JSON, + LEAF, Locale, Log, Math, Multiprecision, Multi-index Containers, Nowide, Optional, + STLInterfaces, System, Unordered, Utility, Wave. + +August 10th, 2022 21:25 GMT +* [Version 1.79.0](/users/history/version_1_79_0.html) + + Updated Libraries: Asio, Assert, Atomic, Beast, Core, Describe, Filesystem, + Geometry, Integer, IO, Iterator, JSON, Log, Multi-index Containers, Nowide, + Optional, Predef, Smart Pointers, System, ThrowException, Unordered, Variant2, + Wave, LEAF, QVM. + +April 13th, 2022 14:22 GMT +* [Version 1.78.0](/users/history/version_1_78_0.html) + + Updated Libraries: Asio, Assert, Atomic, Beast, Core, Describe, DLL, Filesystem, + Geometry, JSON, Lambda2, Log, Math, MultiIndex, Multiprecision, Nowide, PFR, + Predef, Regex, System, Utility, Variant2. + +December 8th, 2021 03:45 GMT + + +[More News...](/users/news/) ([RSS](feed/news.rss)) diff --git a/generated/menu-doc.html b/generated/menu-doc.html new file mode 100644 index 0000000..8e34299 --- /dev/null +++ b/generated/menu-doc.html @@ -0,0 +1,75 @@ +--- +title: +copyright: +revised: +--- #### [Documentation >](/doc/) + + +* [Getting Started + >](/doc/libs/release/more/getting_started/) +* [Libraries >](/doc/libs) + + [1.80.0 - Current + Release >](/doc/libs/1_80_0/) + + [1.79.0 >](/doc/libs/1_79_0/) + + [1.78.0 >](/doc/libs/1_78_0/) + + [1.77.0 >](/doc/libs/1_77_0/) + + [1.76.0 >](/doc/libs/1_76_0/) + + [1.75.0 >](/doc/libs/1_75_0/) + + [1.74.0 >](/doc/libs/1_74_0/) + + [1.73.0 >](/doc/libs/1_73_0/) + + [1.72.0 >](/doc/libs/1_72_0/) + + [1.71.0 >](/doc/libs/1_71_0/) + + [1.70.0 >](/doc/libs/1_70_0/) + + [1.69.0 >](/doc/libs/1_69_0/) + + [1.68.0 >](/doc/libs/1_68_0/) + + [1.67.0 >](/doc/libs/1_67_0/) + + [1.66.0 >](/doc/libs/1_66_0/) + + [1.65.1 >](/doc/libs/1_65_1/) + + [1.65.0 >](/doc/libs/1_65_0/) + + [1.64.0 >](/doc/libs/1_64_0/) + + [1.63.0 >](/doc/libs/1_63_0/) + + [1.62.0 >](/doc/libs/1_62_0/) + + [1.61.0 >](/doc/libs/1_61_0/) + + [1.60.0 >](/doc/libs/1_60_0/) + + [1.59.0 >](/doc/libs/1_59_0/) + + [1.58.0 >](/doc/libs/1_58_0/) + + [1.57.0 >](/doc/libs/1_57_0/) + + [1.56.0 >](/doc/libs/1_56_0/) + + [1.55.0 >](/doc/libs/1_55_0/) + + [1.54.0 >](/doc/libs/1_54_0/) + + [1.53.0 >](/doc/libs/1_53_0/) + + [1.52.0 >](/doc/libs/1_52_0/) + + [1.51.0 >](/doc/libs/1_51_0/) + + [1.50.0 >](/doc/libs/1_50_0/) + + [1.49.0 >](/doc/libs/1_49_0/) + + [1.48.0 >](/doc/libs/1_48_0/) + + [1.47.0 >](/doc/libs/1_47_0/) + + [1.46.1 >](/doc/libs/1_46_1/) + + [1.46.0 >](/doc/libs/1_46_0/) + + [1.45.0 >](/doc/libs/1_45_0/) + + [1.44.0 >](/doc/libs/1_44_0/) + + [1.43.0 >](/doc/libs/1_43_0/) + + [1.42.0 >](/doc/libs/1_42_0/) + + [1.41.0 >](/doc/libs/1_41_0/) + + [1.40.0 >](/doc/libs/1_40_0/) + + [1.39.0 >](/doc/libs/1_39_0/) + + [1.38.0 >](/doc/libs/1_38_0/) + + [1.37.0 >](/doc/libs/1_37_0/) + + [1.36.0 >](/doc/libs/1_36_0/) + + [1.35.0 >](/doc/libs/1_35_0/) + + [1.34.1 >](/doc/libs/1_34_1/) + + [1.34.0 >](/doc/libs/1_34_0/) + + [1.33.1 >](/doc/libs/1_33_1/) + + [1.32.0 >](/doc/libs/1_32_0/) + + [1.31.0 >](/doc/libs/1_31_0/) +* [Tools >](/doc/tools.html) + + [Boost Build >](/tools/build/) + + [Regression >](/tools/regression/) + + [Inspect >](/tools/inspect/) + + [BoostBook >](/doc/html/boostbook.html) + + [QuickBook >](/tools/quickbook/) + + [bcp >](/tools/bcp/) + + [Wave >](/libs/wave/doc/wave_driver.html) + + [AutoIndex >](/tools/auto_index/) + + diff --git a/generated/news-items.html b/generated/news-items.html new file mode 100644 index 0000000..dad5300 --- /dev/null +++ b/generated/news-items.html @@ -0,0 +1,76 @@ +--- +title: +copyright: +revised: +---* [Version 1.80.0](#iversion_1_80_0) +* [Version 1.79.0](#iversion_1_79_0) +* [Version 1.78.0](#iversion_1_78_0) +* [Version 1.77.0](#iversion_1_77_0) +* [Boost has moved downloads to JFrog Artifactory](#iboost_has_moved_downloads_to_jfr) +[Version 1.80.0](/users/history/version_1_80_0.html) +----------------------------------------------------- + + +August 10th, 2022 21:25 GMT + + Updated Libraries: Asio, Atomic, Filesystem, GIL, Histogram, Iterator, JSON, + LEAF, Locale, Log, Math, Multiprecision, Multi-index Containers, Nowide, Optional, + STLInterfaces, System, Unordered, Utility, Wave. + + +* [Release Notes](/users/history/version_1_80_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.80.0/source/) +* [Documentation](/doc/libs/1_80_0/) +[Version 1.79.0](/users/history/version_1_79_0.html) +----------------------------------------------------- + + +April 13th, 2022 14:22 GMT + + Updated Libraries: Asio, Assert, Atomic, Beast, Core, Describe, Filesystem, + Geometry, Integer, IO, Iterator, JSON, Log, Multi-index Containers, Nowide, + Optional, Predef, Smart Pointers, System, ThrowException, Unordered, Variant2, + Wave, LEAF, QVM. + + +* [Release Notes](/users/history/version_1_79_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.79.0/source/) +* [Documentation](/doc/libs/1_79_0/) +[Version 1.78.0](/users/history/version_1_78_0.html) +----------------------------------------------------- + + +December 8th, 2021 03:45 GMT + + Updated Libraries: Asio, Assert, Atomic, Beast, Core, Describe, DLL, Filesystem, + Geometry, JSON, Lambda2, Log, Math, MultiIndex, Multiprecision, Nowide, PFR, + Predef, Regex, System, Utility, Variant2. + + +* [Release Notes](/users/history/version_1_78_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.78.0/source/) +* [Documentation](/doc/libs/1_78_0/) +[Version 1.77.0](/users/history/version_1_77_0.html) +----------------------------------------------------- + + +August 11th, 2021 14:25 GMT + + New Libraries: Describe, Lambda2. Updated Libraries: Any, Asio, Atomic, Beast, + Conversion, Core, DLL, Filesystem, JSON, LexicalCast, Log, Mp11, MultiIndex, + Nowide, PFR, PropertyTree, System, UUID. + + +* [Release Notes](/users/history/version_1_77_0.html) +* [Download](https://boostorg.jfrog.io/artifactory/main/release/1.77.0/source/) +* [Documentation](/doc/libs/1_77_0/) +[Boost has moved downloads to JFrog Artifactory](/users/news/boost_has_moved_downloads_to_jfr.html) +---------------------------------------------------------------------------------------------------- + + +April 29th, 2021 18:00 GMT + + New Location for downloads + + +* [Release Notes](/users/news/boost_has_moved_downloads_to_jfr.html) diff --git a/gfx/boost-dark-trans.png b/gfx/boost-dark-trans.png new file mode 100644 index 0000000..093e301 Binary files /dev/null and b/gfx/boost-dark-trans.png differ diff --git a/gfx/boost_1_33_0.jpg b/gfx/boost_1_33_0.jpg new file mode 100644 index 0000000..6f26ef3 Binary files /dev/null and b/gfx/boost_1_33_0.jpg differ diff --git a/gfx/borland_logo.gif b/gfx/borland_logo.gif new file mode 100644 index 0000000..0165fb4 Binary files /dev/null and b/gfx/borland_logo.gif differ diff --git a/gfx/google_logo_25wht.gif b/gfx/google_logo_25wht.gif new file mode 100644 index 0000000..151f527 Binary files /dev/null and b/gfx/google_logo_25wht.gif differ diff --git a/gfx/imc.jpg b/gfx/imc.jpg new file mode 100644 index 0000000..9437843 Binary files /dev/null and b/gfx/imc.jpg differ diff --git a/gfx/imc.png b/gfx/imc.png new file mode 100644 index 0000000..b5dfdcc Binary files /dev/null and b/gfx/imc.png differ diff --git a/gfx/intel_logo.gif b/gfx/intel_logo.gif new file mode 100644 index 0000000..47f9ded Binary files /dev/null and b/gfx/intel_logo.gif differ diff --git a/gfx/kai_logo.gif b/gfx/kai_logo.gif new file mode 100644 index 0000000..42defce Binary files /dev/null and b/gfx/kai_logo.gif differ diff --git a/gfx/ms_logo.gif b/gfx/ms_logo.gif new file mode 100644 index 0000000..09dca73 Binary files /dev/null and b/gfx/ms_logo.gif differ diff --git a/gfx/space.png b/gfx/space.png new file mode 100644 index 0000000..a17badc Binary files /dev/null and b/gfx/space.png differ diff --git a/index.html b/index.html new file mode 100644 index 0000000..4a80b07 --- /dev/null +++ b/index.html @@ -0,0 +1,107 @@ +--- +title: Boost C++ Libraries +copyright: Beman Dawes, David Abrahams, 1998-2005. Rene Rivera 2004-2007. +revised: +--- +Boost C++ Libraries + + + + + +Welcome to Boost.org! +--------------------- + + +Boost provides free peer-reviewed portable C++ source + libraries. + + +We emphasize libraries that work well with the C++ + Standard Library. Boost libraries are intended to be widely + useful, and usable across a broad spectrum of applications. + The [Boost license](/users/license.html) + encourages the use of Boost libraries for all users with + minimal restrictions. + + +We aim to establish "existing practice" and provide + reference implementations so that Boost libraries are + suitable for eventual standardization. Beginning with the + ten Boost Libraries included in the Library Technical + Report ([TR1](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1745.pdf)) and continuing with every release + of the ISO standard for C++ since 2011, the [C++ Standards Committee](http://www.open-std.org/jtc1/sc22/wg21/) has continued to + rely on Boost as a valuable source for additions to the + Standard C++ Library. + + +Boost as an organization +------------------------ + + +The Boost organization and wider Boost community + supports research and education into the best possible uses + of C++ and libraries developed for it, particularly, but + not exclusively those contained in the Boost Library. + + +The organization and community support mailing lists and + chat rooms to educate about best practices and cutting edge + techniques for the user of Boost Libraries and C++ in + general. + + +Since 2006 an intimate week long annual conference + related to Boost called [C++ Now](http://cppnow.org/) has been held in Aspen, Colorado + each May. The conference is an educational opportunity + focused on cutting-edge C++. Boost has been a participant + in the annual Google Summer of Code since 2007, in which + students develop their skills by working on Boost Library + development. + + +### Getting Started + + +Boost works on + almost any modern operating system, including UNIX and + Windows variants. Follow the [Getting + Started Guide](/doc/libs/release/more/getting_started/index.html) to download and install Boost. Popular + Linux and Unix distributions such as [Fedora](http://fedoraproject.org/), + [Debian](http://www.debian.org/), and [NetBSD](http://www.netbsd.org/) include pre-built Boost + packages. Boost may also already be available on your + organization's internal web server. + + +If you want to + develop Boost, there's a [getting + started guide](https://github.com/boostorg/wiki/wiki/Getting-Started) on the wiki. + + +### Background + + +Read on with the + [introductory material](/users/) to help you + understand what Boost is about and to help in educating + your organization about Boost. + + +### Community + + +Boost welcomes and + thrives on participation from a variety of individuals and + organizations. Many avenues for participation are available + in the [Boost + Community](/community/). + + + + + + + + + + diff --git a/map.html b/map.html new file mode 100644 index 0000000..8022a7a --- /dev/null +++ b/map.html @@ -0,0 +1,30 @@ +--- +title: Boost C++ Libraries, Index +copyright: Beman Dawes, David Abrahams, 1998-2005. Rene Rivera 2004-2005. +revised: +--- + + +Boost C++ Libraries, Index + + + +Index +===== + + +* +* +* +* + + + + + + + + + + + diff --git a/patches/index.html b/patches/index.html new file mode 100644 index 0000000..ff05c90 --- /dev/null +++ b/patches/index.html @@ -0,0 +1,115 @@ +--- +title: Patches - Boost C++ Libraries +copyright: Daniel James 2013. +revised: 2010-05-06 12:05:24 +0100 +--- + + +Patches - Boost C++ Libraries + + + +Boost C++ Library Patches +========================= + +These are patches from library authors which were found too + late to be fixed in the release. Be careful as they have + not been through the normal testing process. + + +1.79.0 +------ + + +* [0001-json-array-erase-relocate.patch](1_79_0/0001-json-array-erase-relocate.patch) + + +1.78.0 +------ + + +* [0001-b2-fix-install.patch](1_78_0/0001-b2-fix-install.patch) + + +1.73.0 +------ + + +* [0001-outcome-assert.patch](1_73_0/0001-outcome-assert.patch) +* [0002-beast-coroutines.patch](1_73_0/0002-beast-coroutines.patch) + + +1.72.0 +------ + + +* [0001-revert-cease-dependence-on-range.patch](1_72_0/0001-revert-cease-dependence-on-range.patch) + + +1.70.0 +------ + + +* [0001-beast-fix-moved-from-executor.patch](1_70_0/0001-beast-fix-moved-from-executor.patch) + + +1.67.0 +------ + + +* [0001-Fiber-Use-pthread\_setaffinity\_np-on-FreeBSD-as-well.patch](1_67_0/0001-Fiber-Use-pthread_setaffinity_np-on-FreeBSD-as-well.patch) +* [0002-Wave-Avoid-using-wrong-T\_DIVIDE-on-BSDs.patch](1_67_0/0002-Wave-Avoid-using-wrong-T_DIVIDE-on-BSDs.patch) +* [0003-Python-Fix-auto-linking-logic-Windows-only.patch](1_67_0/0003-Python-Fix-auto-linking-logic-Windows-only.patch) + + +1.65.0 +------ + + +Combined patch: + [boost\_1\_65\_0.patch](1_65_0/boost_1_65_0.patch). + + +Individual patches: + + +* [0001-context-function-executed-by-resume\_with-has-to-retu.patch](1_65_0/0001-context-function-executed-by-resume_with-has-to-retu.patch) +* [0002-fiber-resume\_with-requires-tor-return-a-continuation.patch](1_65_0/0002-fiber-resume_with-requires-tor-return-a-continuation.patch) +* [0003-thread-130-Bug-in-boost-condition\_variable-on-Window.patch](1_65_0/0003-thread-130-Bug-in-boost-condition_variable-on-Window.patch) +* [0004-thread-130-Bug-in-boost-condition\_variable-on-Window.patch](1_65_0/0004-thread-130-Bug-in-boost-condition_variable-on-Window.patch) + + +1.58.0 +------ + + +* [0001-Fix-exec\_file-for-Python-3-3.4.patch](1_58_0/0001-Fix-exec_file-for-Python-3-3.4.patch) + (for libs/python). +* [0002-Fix-a-regression-with-non-constexpr-types.patch](1_58_0/0002-Fix-a-regression-with-non-constexpr-types.patch) + (for libs/fusion). + + +1.55.0 +------ + + +* [001-log\_fix\_dump\_avx2.patch](1_55_0/001-log_fix_dump_avx2.patch) + + +1.54.0 +------ + + +* [001-coroutine.patch](1_54_0/001-coroutine.patch) +* [002-date-time.patch](1_54_0/002-date-time.patch) +* [003-log.patch](1_54_0/003-log.patch) +* [004-thread.patch](1_54_0/004-thread.patch) + + + + + + + + + diff --git a/style-v2/css_0/alpha_blue_50.png b/style-v2/css_0/alpha_blue_50.png new file mode 100644 index 0000000..013fab0 Binary files /dev/null and b/style-v2/css_0/alpha_blue_50.png differ diff --git a/style-v2/css_0/alpha_white_50.png b/style-v2/css_0/alpha_white_50.png new file mode 100644 index 0000000..469418e Binary files /dev/null and b/style-v2/css_0/alpha_white_50.png differ diff --git a/style-v2/css_0/alpha_white_75.png b/style-v2/css_0/alpha_white_75.png new file mode 100644 index 0000000..6b918e0 Binary files /dev/null and b/style-v2/css_0/alpha_white_75.png differ diff --git a/style-v2/css_0/bkg.png b/style-v2/css_0/bkg.png new file mode 100644 index 0000000..150e81e Binary files /dev/null and b/style-v2/css_0/bkg.png differ diff --git a/style-v2/css_0/blank.png b/style-v2/css_0/blank.png new file mode 100644 index 0000000..764bf4f Binary files /dev/null and b/style-v2/css_0/blank.png differ diff --git a/style-v2/css_0/boost_bullet.gif b/style-v2/css_0/boost_bullet.gif new file mode 100644 index 0000000..f659f95 Binary files /dev/null and b/style-v2/css_0/boost_bullet.gif differ diff --git a/style-v2/css_0/caution.png b/style-v2/css_0/caution.png new file mode 100644 index 0000000..a5a5d34 Binary files /dev/null and b/style-v2/css_0/caution.png differ diff --git a/style-v2/css_0/draft.png b/style-v2/css_0/draft.png new file mode 100644 index 0000000..0084708 Binary files /dev/null and b/style-v2/css_0/draft.png differ diff --git a/style-v2/css_0/get-boost.png b/style-v2/css_0/get-boost.png new file mode 100644 index 0000000..281c13b Binary files /dev/null and b/style-v2/css_0/get-boost.png differ diff --git a/style-v2/css_0/home.png b/style-v2/css_0/home.png new file mode 100644 index 0000000..5584aac Binary files /dev/null and b/style-v2/css_0/home.png differ diff --git a/style-v2/css_0/important.png b/style-v2/css_0/important.png new file mode 100644 index 0000000..574cf28 Binary files /dev/null and b/style-v2/css_0/important.png differ diff --git a/style-v2/css_0/next.png b/style-v2/css_0/next.png new file mode 100644 index 0000000..59800b4 Binary files /dev/null and b/style-v2/css_0/next.png differ diff --git a/style-v2/css_0/next_disabled.png b/style-v2/css_0/next_disabled.png new file mode 100644 index 0000000..10a8c59 Binary files /dev/null and b/style-v2/css_0/next_disabled.png differ diff --git a/style-v2/css_0/note.png b/style-v2/css_0/note.png new file mode 100644 index 0000000..ad6296a Binary files /dev/null and b/style-v2/css_0/note.png differ diff --git a/style-v2/css_0/panel_bkg.png b/style-v2/css_0/panel_bkg.png new file mode 100644 index 0000000..740839c Binary files /dev/null and b/style-v2/css_0/panel_bkg.png differ diff --git a/style-v2/css_0/prev.png b/style-v2/css_0/prev.png new file mode 100644 index 0000000..d88a40f Binary files /dev/null and b/style-v2/css_0/prev.png differ diff --git a/style-v2/css_0/prev_disabled.png b/style-v2/css_0/prev_disabled.png new file mode 100644 index 0000000..ab3c17e Binary files /dev/null and b/style-v2/css_0/prev_disabled.png differ diff --git a/style-v2/css_0/theme_grape/header-bg.png b/style-v2/css_0/theme_grape/header-bg.png new file mode 100644 index 0000000..5be7cba Binary files /dev/null and b/style-v2/css_0/theme_grape/header-bg.png differ diff --git a/style-v2/css_0/theme_grape/header-fg.png b/style-v2/css_0/theme_grape/header-fg.png new file mode 100644 index 0000000..549c812 Binary files /dev/null and b/style-v2/css_0/theme_grape/header-fg.png differ diff --git a/style-v2/css_0/theme_grass/caution.png b/style-v2/css_0/theme_grass/caution.png new file mode 100755 index 0000000..c73b0aa Binary files /dev/null and b/style-v2/css_0/theme_grass/caution.png differ diff --git a/style-v2/css_0/theme_grass/footer-bg-left.png b/style-v2/css_0/theme_grass/footer-bg-left.png new file mode 100644 index 0000000..92fb6aa Binary files /dev/null and b/style-v2/css_0/theme_grass/footer-bg-left.png differ diff --git a/style-v2/css_0/theme_grass/footer-bg-right.png b/style-v2/css_0/theme_grass/footer-bg-right.png new file mode 100644 index 0000000..e31044a Binary files /dev/null and b/style-v2/css_0/theme_grass/footer-bg-right.png differ diff --git a/style-v2/css_0/theme_grass/footer-bg.png b/style-v2/css_0/theme_grass/footer-bg.png new file mode 100644 index 0000000..9d0d785 Binary files /dev/null and b/style-v2/css_0/theme_grass/footer-bg.png differ diff --git a/style-v2/css_0/theme_grass/header-bg.png b/style-v2/css_0/theme_grass/header-bg.png new file mode 100644 index 0000000..3588b91 Binary files /dev/null and b/style-v2/css_0/theme_grass/header-bg.png differ diff --git a/style-v2/css_0/theme_grass/header-fg.png b/style-v2/css_0/theme_grass/header-fg.png new file mode 100644 index 0000000..0dabd14 Binary files /dev/null and b/style-v2/css_0/theme_grass/header-fg.png differ diff --git a/style-v2/css_0/theme_grass/home.png b/style-v2/css_0/theme_grass/home.png new file mode 100755 index 0000000..f2047b8 Binary files /dev/null and b/style-v2/css_0/theme_grass/home.png differ diff --git a/style-v2/css_0/theme_grass/important.png b/style-v2/css_0/theme_grass/important.png new file mode 100755 index 0000000..fc0c9ce Binary files /dev/null and b/style-v2/css_0/theme_grass/important.png differ diff --git a/style-v2/css_0/theme_grass/next.png b/style-v2/css_0/theme_grass/next.png new file mode 100755 index 0000000..f3a1221 Binary files /dev/null and b/style-v2/css_0/theme_grass/next.png differ diff --git a/style-v2/css_0/theme_grass/next_disabled.png b/style-v2/css_0/theme_grass/next_disabled.png new file mode 100644 index 0000000..c3f7379 Binary files /dev/null and b/style-v2/css_0/theme_grass/next_disabled.png differ diff --git a/style-v2/css_0/theme_grass/note.png b/style-v2/css_0/theme_grass/note.png new file mode 100755 index 0000000..2c67184 Binary files /dev/null and b/style-v2/css_0/theme_grass/note.png differ diff --git a/style-v2/css_0/theme_grass/prev.png b/style-v2/css_0/theme_grass/prev.png new file mode 100755 index 0000000..f7f0361 Binary files /dev/null and b/style-v2/css_0/theme_grass/prev.png differ diff --git a/style-v2/css_0/theme_grass/prev_disabled.png b/style-v2/css_0/theme_grass/prev_disabled.png new file mode 100644 index 0000000..88f5600 Binary files /dev/null and b/style-v2/css_0/theme_grass/prev_disabled.png differ diff --git a/style-v2/css_0/theme_grass/tip.png b/style-v2/css_0/theme_grass/tip.png new file mode 100755 index 0000000..66892d2 Binary files /dev/null and b/style-v2/css_0/theme_grass/tip.png differ diff --git a/style-v2/css_0/theme_grass/up.png b/style-v2/css_0/theme_grass/up.png new file mode 100755 index 0000000..ef43407 Binary files /dev/null and b/style-v2/css_0/theme_grass/up.png differ diff --git a/style-v2/css_0/theme_grass/up_disabled.png b/style-v2/css_0/theme_grass/up_disabled.png new file mode 100644 index 0000000..6fcf6b3 Binary files /dev/null and b/style-v2/css_0/theme_grass/up_disabled.png differ diff --git a/style-v2/css_0/theme_grass/warning.png b/style-v2/css_0/theme_grass/warning.png new file mode 100755 index 0000000..e059a2d Binary files /dev/null and b/style-v2/css_0/theme_grass/warning.png differ diff --git a/style-v2/css_0/tip.png b/style-v2/css_0/tip.png new file mode 100644 index 0000000..e2fed5b Binary files /dev/null and b/style-v2/css_0/tip.png differ diff --git a/style-v2/css_0/toc-blank.png b/style-v2/css_0/toc-blank.png new file mode 100644 index 0000000..6ffad17 Binary files /dev/null and b/style-v2/css_0/toc-blank.png differ diff --git a/style-v2/css_0/toc-minus.png b/style-v2/css_0/toc-minus.png new file mode 100644 index 0000000..abbb020 Binary files /dev/null and b/style-v2/css_0/toc-minus.png differ diff --git a/style-v2/css_0/toc-plus.png b/style-v2/css_0/toc-plus.png new file mode 100644 index 0000000..941312c Binary files /dev/null and b/style-v2/css_0/toc-plus.png differ diff --git a/style-v2/css_0/up.png b/style-v2/css_0/up.png new file mode 100644 index 0000000..17d9c3e Binary files /dev/null and b/style-v2/css_0/up.png differ diff --git a/style-v2/css_0/up_disabled.png b/style-v2/css_0/up_disabled.png new file mode 100644 index 0000000..e22bc87 Binary files /dev/null and b/style-v2/css_0/up_disabled.png differ diff --git a/style-v2/css_0/warning.png b/style-v2/css_0/warning.png new file mode 100644 index 0000000..cdb17c9 Binary files /dev/null and b/style-v2/css_0/warning.png differ diff --git a/support/_template_.html b/support/_template_.html new file mode 100644 index 0000000..3e170a2 --- /dev/null +++ b/support/_template_.html @@ -0,0 +1,24 @@ +--- +title: Boost C++ Libraries +copyright: Rene Rivera 2007. +revised: +--- + + +Boost C++ Libraries + + + +Boost C++ Libraries +=================== + +{stuff} + + + + + + + + + diff --git a/users/_template_.html b/users/_template_.html new file mode 100644 index 0000000..3e170a2 --- /dev/null +++ b/users/_template_.html @@ -0,0 +1,24 @@ +--- +title: Boost C++ Libraries +copyright: Rene Rivera 2007. +revised: +--- + + +Boost C++ Libraries + + + +Boost C++ Libraries +=================== + +{stuff} + + + + + + + + + diff --git a/users/bibliography.html b/users/bibliography.html new file mode 100644 index 0000000..3287d49 --- /dev/null +++ b/users/bibliography.html @@ -0,0 +1,465 @@ +--- +title: Boost Bibliography +copyright: Rene Rivera 2005. Beman Dawes 2003. +revised: +--- + + +Boost Bibliography + + + +Boost Bibliography +================== + +* [Print publications about + Boost or Boost Libraries](#Print_publications) +* [Online publications about + Boost or Boost Libraries](#Online_publications) +* [Print mentions of Boost or + Boost Libraries](#Print_mentions) +* [Online mentions of Boost or + Boost Libraries](#Online_mentions) +* [How to update this page](#update) +* [Acknowledgements](#Acknowledgements) + + +Print publications about Boost or + Boost Libraries +-------------------------------------------------- + + +### 2000 +[MaddockCleary00] +John Maddock and Steve Cleary, C++ Type + Traits. Dr. Dobb's Journal, Vol. 25, Issue 10, + October, 2000, page 38. [www.boost.org/libs/type\_traits/c++\_type\_traits.htm](https://www.boost.org/libs/type_traits/cxx_type_traits.htm) + +### 2001 +[Maddock01] +John Maddock, Regular Expressions in C++. + Dr. Dobb's Journal, Vol. 26, Issue 10, October, 2001, page + 21. +[SiekLumsdaine01] +Jeremy Siek and Andrew Lumsdaine, C++ Concept + Checking. Dr. Dobb's Journal, Vol. 26, Issue 6, June, + 2001, page 64. + +### 2002 +[Karlsson02] +Björn Karlsson, Smart Pointers in + Boost. C/C++ Users Journal, April, 2002. [www.cuj.com/documents/s=8014/cuj0204karlsson/](http://www.cuj.com/documents/s=8014/cuj0204karlsson/) +[Karlsson02a] +Björn Karlsson, C/C++ Tip #9: Lexical + Conversions. C/C++ Users Journal, November, 2002. + [www.cuj.com/documents/s=8470/cuj0211karlsson/](http://www.cuj.com/documents/s=8470/cuj0211karlsson/) +[Kempf02] +Bill Kempf, The Boost.Threads Library. C/C++ + Users Journal, May, 2002. [www.cuj.com/documents/s=8013/cuj0205kempf/](http://www.cuj.com/documents/s=8013/cuj0205kempf/) +[SiekLeeLumsdaine02] +Jeremy Siek, Lie-Quan Lee and Andrew Lumsdaine, The + Boost Graph Library. Addison-Wesley, 2002. ISBN: + 0-201-72914-8. [www.informit.com/store/product.aspx?isbn=0201729148](http://www.informit.com/store/product.aspx?isbn=0201729148). + + + A sample chapter is available at: [tinyurl.com/24666](http://tinyurl.com/24666) + +### 2003 +[AbrahamsGrosse-Kunstleve03] +David Abrahams and Ralf W. Grosse-Kunstleve, + Building Hybrid Systems with Boost.Python. C/C++ + Users Journal, July, 2003. [www.cuj.com/documents/s=8470/cuj0307abrahams/](http://www.cuj.com/documents/s=8470/cuj0307abrahams/) +[GuzmanNuffer03] +Joel de Guzman and Dan Nuffer, The Spirit Library: + Inline Parsing in C++. C/C++ Users Journal, September, + 2003, Vol. 21, Issue 9, page 22. +[Karlsson03] +Björn Karlsson, Lambda Expressions & + C++. C/C++ Users Journal, December, 2003, Vol. 21, + Issue 12, page 20. +[Sutter03] +Herb Sutter, Generalized Function Pointers. + C/C++ Users Journal, August, 2003. [www.cuj.com/documents/s=8464/cujcexp0308sutter/](http://www.cuj.com/documents/s=8464/cujcexp0308sutter/) + +### 2004 +[AbrahamsGurtovoy04] +David Abrahams and Aleksey Gurtovoy, C++ Template + Metaprogramming: Concepts, Tools, and Techniques from Boost + and Beyond. Addison-Wesley, November, 2004. ISBN: + 0-321-22725-5. [www.informit.com/store/product.aspx?isbn=0321227255](http://www.informit.com/store/product.aspx?isbn=0321227255) + + + Additional information and two sample chapters are available + at: [boost-consulting.com/tmpbook/](http://boost-consulting.com/tmpbook/) +[Inaba04] +Kazuhiro Inaba, Boost C++ Library + Programming. Shuwa System, May, 2004. ISBN: + 4-7980-0786-2. [www.shuwasystem.co.jp/books/7980/0786-2/0786-2.html](http://www.shuwasystem.co.jp/books/7980/0786-2/0786-2.html) + + + Additional information and a sample chapter are available at: + [www.kmonos.net/pub/BoostBook/](http://www.kmonos.net/pub/BoostBook/) +[López04] +Joaquín M López Muñoz, The + Boost Multi-Index Containers Library. C/C++ Users + Journal, September, 2004, Vol. 22, Issue 9, page 6. + +### 2005 +[Karlsson05] +Björn Karlsson, Beyond the C++ Standard + Library: An Introduction to Boost. Addison-Wesley, + August 31, 2005. ISBN: 0-3211-3354-4. [www.informit.com/store/product.aspx?isbn=0321133544](http://www.informit.com/store/product.aspx?isbn=0321133544) + + + A sample chapter is available at: [www.informit.com/content/images/0321133544/samplechapter/karlsson\_ch09.pdf](http://www.informit.com/content/images/0321133544/samplechapter/karlsson_ch09.pdf) + +### 2009 +[Schaeling09] +Boris Schaeling, Die Boost C++ + Bibliotheken. [www.highscore.de/cpp/boost/](http://www.highscore.de/cpp/boost/) + +### 2010 +[Demming11] +Robert Demming, Daniel J Duffy Introduction to the Boost C++ Libraries; Volume I - Foundations. + [www.datasim-press.com/BoostVolumeI.html/](http://www.datasim-press.com/BoostVolumeI.html) + + +[Demming12] +Robert Demming, Daniel J Duffy Introduction to the Boost C++ Libraries; Volume II - Advanced Libraries. + [www.datasim-press.com/BoostVolumeII.html/](http://www.datasim-press.com/BoostVolumeII.html) + +### 2011 +[Schaeling09] +Boris Schaeling, The Boost C++ Libraries. + [en.highscore.de/cpp/boost/](http://en.highscore.de/cpp/boost/) + +### 2013 +[Polukhin13] +Antony Polukhin, Boost C++ Application Development Cookbook. + + +[Torjo13] +John Torjo, Boost.Asio C++ Network Programming. + [www.packtpub.com/boost-asio-cplusplus-network-programming/book](http://www.packtpub.com/boost-asio-cplusplus-network-programming/book) + +### 2014 +[Schaeling14] +Boris Schaeling, The Boost C++ Libraries, Second Edition. + +### 2017 +[Polukhin17] +Antony Polukhin, Boost C++ Application Development Cookbook, Second Edition. + +### 2020 +[Polukhin20] +Antony Polukhin (Антон Полухин), Разработка приложений на C++ с использованием Boost, Dmk Press, + ISBN: 978-5-97060-868-5. + + +Online publications about Boost or + Boost Libraries +--------------------------------------------------- + + +### 2002 +[Brownell02] +David Brownell, C++ Techniques for Tomorrow That + Can be Implemented Today (a.k.a. Boosting your Code). + NWCPP, November 13, 2002. [www.nwcpp.org/Meetings/2002/11.html](http://www.nwcpp.org/Meetings/2002/11.html) +[Long02] +Matt Long, Adding Regular Expressions to Your App + with Regex++. The Code Project, June 18, 2002. + [www.codeproject.com/KB/string/regex\_\_.aspx](http://www.codeproject.com/KB/string/regex__.aspx) +[Siek02] +Jeremy G. Siek, The Boost Graph Library. + InformIT, March 1, 2002. [tinyurl.com/2hc27](http://tinyurl.com/2hc27) +[Siek02a] +Jeremy G. Siek, A Boost Graph Library + Tutorial. InformIT, March 1, 2002. [tinyurl.com/2sa4s](http://tinyurl.com/2sa4s) + +### 2003 +[Abrahams03] +David Abrahams, The Boost Metaprogramming + Library. ACCU, 2003. [www.boost-consulting.com/writing/ACCU\_MPL\_slides.ppt](http://www.boost-consulting.com/writing/ACCU_MPL_slides.ppt) +[Dawes03] +Beman Dawes, Multiplatform Software + Development. 2003. [www.esva.net/~beman/multiplat\_dev.ppt](http://www.esva.net/~beman/multiplat_dev.ppt) +[Halleux03] +Jonathan de Halleux, Opening a door towards Spirit: + a parser framework. The Code Project, March 24, 2003. + [www.codeproject.com/KB/recipes/spiritintro.aspx](http://www.codeproject.com/KB/recipes/spiritintro.aspx) +[Kaiser03] +Hartmut Kaiser, Wave: a Standard conformant C++ + preprocessor library. The Code Project, March 25, + 2003. [www.codeproject.com/KB/recipes/wave\_preprocessor.aspx](http://www.codeproject.com/KB/recipes/wave_preprocessor.aspx) +[Trentini03] +Matthew S. Trentini, Introduction to + Boost. +[Walker03] +Andrew Walker, An Introduction to Boost. The + Code Project, July 7, 2003. [www.codeproject.com/KB/stl/boostintro.aspx](http://www.codeproject.com/KB/stl/boostintro.aspx) + + + A short and straightforward introduction to Boost. + +### 2004 +[Dawes04] +Beman Dawes, Boost for Visual C++ + Developers. MSDN, May 17, 2004. [tinyurl.com/2lzyh](http://tinyurl.com/2lzyh) +[D'Agostino04] +Jim D'Agostino, Designing Robust Objects with + Boost. The Code Project, August 17, 2004. [www.codeproject.com/KB/architecture/Designing\_Robust\_Objects.aspx](http://www.codeproject.com/KB/architecture/Designing_Robust_Objects.aspx) +[Handley04] +Dave Handley, An Introduction to the Boost Spirit + Parser framework. The Code Project, October 9, 2004. + [www.codeproject.com/KB/stl/introduction\_spirit.aspx](http://www.codeproject.com/KB/stl/introduction_spirit.aspx) +[Handley04a] +Dave Handley, Implementing Semantic Actions in the + Boost Spirit Parser Framework. The Code Project, + October 10, 2004. [www.codeproject.com/KB/stl/spirit\_semantic\_actions.aspx](http://www.codeproject.com/KB/stl/spirit_semantic_actions.aspx) +[Hauptmann04] +Peter Hauptmann, Smart Pointers to boost your + code. The Code Project, September 27, 2004. [www.codeproject.com/KB/stl/boostsmartptr.aspx](http://www.codeproject.com/KB/stl/boostsmartptr.aspx) +[Hauptmann04a] +Peter Hauptmann, boost 2: shared\_ptr wraps resource + handles. The Code Project, October 4, 2004. [www.codeproject.com/KB/stl/boostsp\_handleref.aspx](http://www.codeproject.com/KB/stl/boostsp_handleref.aspx) +[Wikipedia04] +Wikipedia, Boost (Programming). Wikipedia, + The Free Encyclopedia, 2004. [en.wikipedia.org/wiki/Boost\_(programming)](http://en.wikipedia.org/wiki/Boost_(programming)) +[Witt04] +Thomas Witt, The Boost Iterator Library. + ACCU Spring Conference, 2004. [www.accu.org/conference/presentations/Witt\_-\_Boost\_Iterator\_Library.pdf](http://www.accu.org/conference/presentations/Witt_-_Boost_Iterator_Library.pdf) + +### 2005 +[Karlsson05a] +Bjorn Karlsson, How the Boost Bind Library Can + Improve Your C++ Programs. InformIT, August 26, 2005. + [www.informit.com/articles/article.aspx?p=412354](http://www.informit.com/articles/article.aspx?p=412354) +[Cogswell05] +Jeff Cogswell, Adding an Easy File Save and File + Load Mechanism to Your C++ Program. InformIT, July 1, + 2005. [www.informit.com/articles/article.aspx?p=398702](http://www.informit.com/articles/article.aspx?p=398702) + + + Explains Boost.Serialization. +[Gurtovoy05] +Aleksey Gurtovoy and David Abrahams An In-Depth + Look at Metafunctions in C++. InformIT, April 1, 2005. + [www.informit.com/articles/article.aspx?p=375705](http://www.informit.com/articles/article.aspx?p=375705) + +### 2008 +[Schaeling08] +Boris Schaeling, The Boost C++ Libraries. + +### 2014 +[Douglas14] +Niall Douglas, Large Code Base Change Ripple Management in C++: + My thoughts on how a new Boost C++ Library could help. + +Print + mentions of Boost or Boost Libraries +------------------------------------------- + + +### 2001 +[HyslopSutter01] +Jim Hyslop and Herb Sutter, Conversations: I'd Hold + Anything for You. C/C++ Users Journal, December, 2001. + [www.cuj.com/documents/s=7988/cujcexp1912hyslop/](http://www.cuj.com/documents/s=7988/cujcexp1912hyslop/) + +`boost::any` +[Meyers01] +Scott Meyers, Item 50: Familiarize yourself with + STL-related web sites. Effective STL, Addison-Wesley, + 2001, page 221. ISBN: 0-201-74962-9 +[Sutter01] +Herb Sutter, The String Formatters of Manor + Farm. C/C++ Users Journal, Vol. 19, November, 2001. + [www.gotw.ca/publications/mill19.htm](http://www.gotw.ca/publications/mill19.htm) + +### 2002 +[Ablavsky02] +Vitaly Ablavsky, Applying BGL to Computational + Geometry. C/C++ Users Journal, August, 2002. [www.cuj.com/documents/s=8470/cuj0208ablavsky/](http://www.cuj.com/documents/s=8470/cuj0208ablavsky/) +[Alexandrescu02] +Andrei Alexandrescu, Generic: + Efficient Generic Sorting and Searching in C++ (I): In Search + of a Better Search. C/C++ Users Journal, October, + 2002. [www.cuj.com/documents/s=7978/cujcexp2010alexandr/](http://www.cuj.com/documents/s=7978/cujcexp2010alexandr/) + +`boost::type_traits` +[HyslopSutter02] +Jim Hyslop and Herb Sutter, Conversations: Getting + to the Point. C/C++ Users Journal, July, 2002. + [www.cuj.com/documents/s=7981/cujcexp2007hyslop/](http://www.cuj.com/documents/s=7981/cujcexp2007hyslop/) + + + smart pointer discussion. `boost::scoped_ptr, + shared_ptr, scoped_array, shared_array.` +[Sutter02] +Herb Sutter, The New C++: The Group of Seven - + Extensions under Consideration for the C++ Standard + Library. C/C++ Users Journal, April, 2002. [www.cuj.com/documents/s=7984/cujcexp2004sutter/](http://www.cuj.com/documents/s=7984/cujcexp2004sutter/) +[Sutter02a] +Herb Sutter, The New C++: Smart(er) + Pointers. C/C++ Users Journal, August, 2002. [www.cuj.com/documents/s=7980/cujcexp2008sutter/](http://www.cuj.com/documents/s=7980/cujcexp2008sutter/) + +### 2003 +[Besser03] +Mitch Besser, Generic Printable ENUM++. + C/C++ Users Journal, June, 2003. [www.cuj.com/documents/s=8470/cujboost0306besser/](http://www.cuj.com/documents/s=8470/cujboost0306besser/) + + + Mentions `BOOST_PP` +[Nasonov03] +Alexander Nasonov, I/O System: dynamic\_any + Campaign. C/C++ Users Journal, September, 2003. + [www.cuj.com/documents/s=8470/cujweb0309nasonov/](http://www.cuj.com/documents/s=8470/cujweb0309nasonov/) + + + Improved `boost::any` +[Sutter03a] +Herb Sutter, Generalizing Observer. C/C++ + Users Journal, September, 2003. [www.cuj.com/documents/s=8840/cujexp0309sutter/](http://www.cuj.com/documents/s=8840/cujexp0309sutter/) +[Tan03] +Kwee H. Tan, Exploring EDA Algorithms with the + Boost Graph Library. C/C++ Users Journal, July, 2003. + [www.cuj.com/documents/s=8470/cuj0307tan/](http://www.cuj.com/documents/s=8470/cuj0307tan/) +[VandervoordeJosuttis03] +David Vandevoorde and Nicolai M. Josuttis, Using + Templates in Practice. C/C++ Users Journal, February, + 2003. [www.cuj.com/documents/s=8208/cujweb0302vandevoorde/web0302b.htm](http://www.cuj.com/documents/s=8208/cujweb0302vandevoorde/web0302b.htm) + + + Concept Check Library + +### 2005 +[Meyers05] +Scott Meyers, Item 55: Familiarize yourself with + Boost. Effective C++, 3rd Edition, Addison-Wesley, May + 12, 2005. ISBN: 0-321-33487-6 + +### 2017 +[Polukhin17Online] +Antony Polukhin, Online Compilation and Examples: Boost C++ Application Development Cookbook. + + + Compile, modify and run online examples from the 'Boost Application Development Cookbook' without any need to install C++ compiler or Boost C++ Libraries. + +Online + mentions of Boost or Boost Libraries +-------------------------------------------- + + +### 2001 +[Siek01] +Jeremy G. Siek, An Implementation of Graph + Isomorphism Testing, December 9, 2001. [www.boost.org/libs/graph/doc/isomorphism-impl.pdf](https://www.boost.org/libs/graph/doc/isomorphism-impl.pdf) + +### 2002 +[Burnap02] +Steven R. Burnap, Boost::any, Kuro5hin, May + 1, 2002. [www.kuro5hin.org/story/2002/5/1/142321/9513](http://www.kuro5hin.org/story/2002/5/1/142321/9513) +[Carbon02] +David S?, Boost : The handy library of handy + libraries. Kuro5hin, July 18, 2002. [www.kuro5hin.org/story/2002/7/18/3313/01429](http://www.kuro5hin.org/story/2002/7/18/3313/01429) +[Curran02] +James Curran, Access Raw Data with Performance + Counters in Visual C++. DevX.com, October, 2002. + [www.devx.com/cplus/article/7951](http://www.devx.com/cplus/article/7951) + + Devotes several paragraphs to + `boost::shared_ptr<>`. +[Siek02b] +Jeremy G. Siek, Internet Packet Routing with the + Boost Graph Library. InformIT, March 1, 2002. [tinyurl.com/26dwj](http://tinyurl.com/26dwj) + +### 2003 +[Casad03] +Joe Casad, Introducing the Boost Corner. + C/C++ Users Journal, August, 2003. [www.cuj.com/documents/s=8470/cuj0308boostcorner/](http://www.cuj.com/documents/s=8470/cuj0308boostcorner/) +[Lischner03] +Ray Lischner, C++: Beyond the Standard + Library. O'Reilly Network, May 6, 2003. [www.oreillynet.com/lpt/a/3683](http://www.oreillynet.com/lpt/a/3683) + + Mentions `tuples, shared_ptr, lambda, + spirit`. + +### 2004 +[Inaba04a] +Kazuhiro Inaba, Let's Boost. 2004. [www.kmonos.net/alang/boost/](http://www.kmonos.net/alang/boost/) +[Stein04] +Sebastian Stein, How to use Boost Test for + automated testing. 2004. [www.hpfsc.de/boosttest/](http://www.hpfsc.de/boosttest/) + +### 2005 +[Lindrud05] +Jarl Lindrud, RMI for C++. The Code Project, + April 11, 2005. [www.codeproject.com/KB/threads/RMI\_For\_Cpp.aspx](http://www.codeproject.com/KB/threads/RMI_For_Cpp.aspx) + + + Uses Boost.Serialization. + +### 2013 +[Kormanyos13] +Christopher Kormanyos, + Real-Time C++: Efficient Object-Oriented and Template Microcontroller Programming. + + + + Uses C++11 including lambdas, templates, metatemplate programming for efficient + programming for microcontrollers including use of Boost.Math, Boost.Regex, Boost.Multiprecision + and other Boost libraries. + + +[Nakariakov13] +Sergei Nakariakov, + The Boost C++ Libraries: Generic Programming, ISBN 978-1484813911. + + + This book covers 24 Boost C++ Libraries with primary focus on generic programming + using Boost.TypeTraits, Boost.ConceptCheck, SFINAE, Generic Image Library, + Boost.Operators, Boost.TypeTraitsIntrospection and others. + + + Published by CreateSpace Independent Publishing Platform, and available from several distributors. + + +How to update this + page +------------------------ + + +Please help us keep this page updated - users can post new + citations to the mailing list, while Boost developers should + update the page directly in the repository. + + +* If a publication is available both in print and online, + cite it in the appropriate *print* section, with a + hyperlink to the online version. +* Bookmark the contents of [...] in the first column to + make it easy to link to the entry. +* Identify the first entry an author has in a given year + with just the two-digit year. Subsequent entries for the same + author and year should have **a-z** appended. +* Inside each section, entries are grouped by year and, + within a year, alphabetically sorted by author name. +* In the text, spell out absolute URL's so that printed + versions of this page include the full URL. + + +Acknowledgements +---------------- + + +Fredrik Blomqvist provided many of the initial citations. + + + + + + + + + diff --git a/users/download/boost_jam_3_1_18.html b/users/download/boost_jam_3_1_18.html new file mode 100644 index 0000000..209ad97 --- /dev/null +++ b/users/download/boost_jam_3_1_18.html @@ -0,0 +1,64 @@ +--- +title: Boost Jam 3.1.18 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Boost Jam 3.1.18 + + + + + + +Boost Jam 3.1.18 +================ + +Boost Jam 3.1.18 +---------------- + + +March 22nd, 2010 12:00 GMT + + +[Download this release.](http://sourceforge.net/projects/boost/files/boost-jam/3.1.18/) + + + After years of bjam developments.. This is going to be the last unbundled release + of the 3.1.x series. From this point forward bjam will only be bundled as part + of the larger Boost Build system. And hence will likely change name at some point. + As a side effect of this move people will get more frequent release of bjam (or + whatever it ends up being called). + +* New built-ins, MD5, SPLIT\_BY\_CHARACTERS, PRECIOUS, PAD, FILE\_OPEN, and UPDATE\_NOW. + -- *Vladimir P.* +* Ensure all file descriptors are closed when + executing actions complete on \*nix. -- *Noel B.* +* Fix warnings, + patch from Mateusz Loskot. -- *Vladimir P.* +* Add KEEP\_GOING + var to programatically override the '-q' option. -- *Vladimir P.* +* Add more parameters, up to 19 from 9, to rule invocations. Patch from Jonathan + Biggar. -- *Vladimir P.* +* Print failed command output even + if the normally quite '-d0' option. -- *Vladimir P.* +* Build + of bjam with vc10, aka Visual Studio 2010. -- *Vladimir P.* +* More macros for detection of OSPLAT, patch from John W. Bito. -- *Vladimir + P.* +* Add PARALLELISM var to programatically override the '-j' option. + -- *Vladimir P.* +* Tweak doc building to allow for PDF generation + of docs. -- *John M.* + + + + + + + + + + + diff --git a/users/download/index.html b/users/download/index.html new file mode 100644 index 0000000..337dcc9 --- /dev/null +++ b/users/download/index.html @@ -0,0 +1,60 @@ +--- +title: Boost Downloads +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Boost Downloads + + + +Boost Downloads +=============== + + +Other Downloads +--------------- + + +As well as the official releases, members of the community + provide other downloads for your convenience. Since these are + produced separately, there might be a delay before they're + available after a release and they're not be available for all + releases. + + +* [Prebuilt windows binaries](https://sourceforge.net/projects/boost/files/boost-binaries/). +* [PDF + documentation](https://sourceforge.net/projects/boost/files/boost-docs/) (only for BoostBook based + documentation). + + +Old Boost Releases +------------------ + + +Old versions of boost can be found on the [version history](/users/history/) page or from [the sourceforge + download page](http://sourceforge.net/projects/boost/files/). + + +Git + Repositories +----------------- + + +Boost uses [Git](http://git-scm.com/) to manage all of the data + associated with Boost's development, including the source code + to Boost, documentation for Boost libraries, and the Boost web + site. + + +Details of the git repositories are on the [Boost + wiki](https://svn.boost.org/trac/boost/wiki/ModularBoost). + + + + + + + diff --git a/users/faq.html b/users/faq.html new file mode 100644 index 0000000..b2035fe --- /dev/null +++ b/users/faq.html @@ -0,0 +1,279 @@ +--- +title: Boost FAQ +copyright: Beman Dawes 2001. +revised: +--- + + +Boost FAQ + + + +Boost FAQ +========= + +How do I download the + libraries? See the [downloads](download). + + +What do the Boost + version numbers mean? The scheme is x.y.z, where x is + incremented only for massive changes, such as a reorganization + of many libraries, y is incremented whenever a new library is + added, and z is incremented for maintenance releases. y and z + are reset to 0 if the value to the left changes. + + +Is there any + assurance libraries actually work as claimed? No. The + review process will hopefully eliminate the most seriously + flawed libraries, but a well constructed library with hidden + defects is likely to slip through. Encouraging ordinary users + to report their experience with a library is intended to + address such concerns. Consult the [test results](../development/testing.html) for an + indication of how well a library works on specific + platforms. + + +How can the Boost + libraries be used successfully for important projects? + Many of the Boost libraries are actively maintained and + improved, so backward compatibility with prior version isn't + always possible. Deal with this by freezing the version of the + Boost libraries used by your project. Only upgrade at points in + your project's life cycle where a bit of change will not cause + problems. Individual bug fixes can always be obtained from the + boost repository. + + +How can I contribute + to development? To participate in development, you need + to subscribe to the [Boost + developers' list](https://lists.boost.org/mailman/listinfo.cgi/boost). Once you've done that, some paths to + contribution are: + + +1. Submit patches for new features or bug fixes. Pick any + ticket from [our bug + tracking system](https://github.com/boostorg/) on GitHub and get started. If existing + library maintainers don't already know your work, this is + a good way to become known as someone they can trust to + do good work. +2. Become part of a particular library's community, and + become known to the library maintainer(s) by participating in + design discussions (some libraries, e.g. Spirit, have their + [own mailing + lists](/community/groups.html#projects) where you'd do that). +3. Become a library maintainer through the + [Boost + Library Official Maintainer Program](/community/official_library_maintainer_program.html) or as member of the + [Boost Community Maintenance Team](https://svn.boost.org/trac10/wiki/CommunityMaintenance) (CMT). To start, triage + existing issues and pull requests to make a list of all the ones + that seem trivial enough to begin with. Work on the issues in your + fork of the library and submit pull requests when ready. Make sure + the CI coverage is in place and the CI builds and tests pass. Then, + [contact the CMT](https://lists.boost.org/mailman/listinfo.cgi/boost-maint) requesting to review and merge your pull requests. + At some point, you will be granted a write access to repository + of the library. +4. Come up with a library idea of your own and begin the + [library submission + process](/development/submissions.html). + + +How is a library + accepted for posting on the site? See [Library Submission + Process](/development/submissions.html) + + +How does someone + submit a Formal Review comment? Send email to [boost@lists.boost.org](mailto:boost@lists.boost.org). See + the [Formal Review](/community/reviews.html) page + for more information. + + +How does someone + submit a library? See [Library Guidelines](/development/requirements.html) + + +Are commercial + libraries requiring a fee acceptable? No. However, a + library that a commercial enterprise makes available without + fee is acceptable. If the description of the library makes a + low-key plug for the supplier, that is acceptable as long as + the library delivers real value and isn't just a Trojan horse + for the plug. + + +Are shareware + libraries acceptable? No. Only free libraries will be + accepted. + + +Are open source + license libraries acceptable? Some are, many are not. + Open source licenses often require redistribution or + availability of source code, inclusion of license document with + machine-executable redistribution, give the initial developer + rights to licensee modifications, or need a lawyer to + understand. Boost aims to + avoid subjecting users to hard-to-comply-with license terms. + See [License + requirements](/development/requirements.html#License). + + +This is subject to review for a particularly + important piece of software, or as the industry changes. + + +Must full source code + be provided? Yes, these are source code libraries. + + +What about + documentation? A very simple library might be accepted + with only a well commented header file. For more substantial + libraries, some form of documentation is certainly going to be + expected. HTML is the preferred form. + + +Are platform specific + libraries acceptable? There is a preference for portable + libraries. Libraries will be accepted that have portable + interfaces but require platform specific implementations, as + long as the author supplies implementations for a couple of + disparate major operating systems. + + +Must a library do + useful work? No. A library meant as a teaching example + or demonstration might not actually do any work. + + +Can an existing + library be accepted by Boost? Yes, although it would + have to be "Boostified" to meet the requirements.  The + Boost Graph and Regex libraries are examples of libraries which + began life elsewhere. + + +Who owns the + libraries? Presumably many authors will copyright their + libraries. Others authors may wish to place their libraries in + the public domain. The Boost.org policy is to only accept + libraries with a clear copyright notice and meeting the + [License + requirements](/development/requirements.html#License). It is up to potential users to decide if the + terms acceptable, and not to use libraries with unacceptable + copyrights or licenses. + + +Is there a formal + relationship between Boost.org and the C++ Standards + Committee? No, although there is a strong informal + relationship in that many members of the committee participate + in Boost, and the people who started Boost were all committee + members. + + +Will the Boost.org + libraries become part of the next C++ Standard? Some + might, someday, but that is up to the standards committee. + Committee members who also participate in Boost will definitely + be proposing at least some Boost libraries for + standardization. + + +Libraries which are "existing practice" are most + likely to be accepted by the C++ committee for future + standardization. Having a library accepted by Boost is one way + to establish existing practice. + + +Where does the name + "Boost" come from? Boost began with Robert Klarer and I + fantasizing about a new library effort over dinner at a C++ + committee meeting in Sofia Antipolis, France, in 1998. Robert + mentioned that Herb Sutter was working on a spoof proposal for + a new language named Booze, which was supposed to be better + than Java. Somehow that kicked off the idea of "Boost" as a + name. We'd probably had a couple of glasses of good French wine + at that point. It was just a working name, but no one ever came + up with a replacement. (Beman Dawes) + + +Is the web site a + commercial business? No. The Boost Foundation is + incorporated as a nonprofit corporation, with a pending + application for 503(c)(3) tax exempt status. + + +Is there any charge + for submitting libraries or reviews to Boost.org? No. + Unlike the standards committees, you don't have to pay to + volunteer! + + +Will the site include + material beyond libraries? The main focus is on + libraries, but if people contribute occasional articles or + other material to make the site more interesting, that could be + a nice fit. + + +Why isn't there a + separate boost mailing list for my favorite library? One + of the reasons for boost's success has been the + cross-pollination of ideas between diverse library projects and + the occasional look into other threads by otherwise + uninterested parties. The more people participate, the less + they tend to be annoyed by "noise". + + +How can I cope with + the large volume of boost mailing list messages? One + approach is to use the "digest" option; that cuts the email + blizzard down to several (long) messages per day, so you can + glance over the subjects summary at the top and quickly read + what you think is important. The "no mail" option turns off + list email entirely. + + +Another approach is to follow the list traffic + via an NTTP newsgroup reader. See [Mailing List](/community/groups.html#newsgroup) newsgroup + information. + + +Why do Boost headers + have a .hpp suffix rather than .h or none at all? File + extensions communicate the "type" of the file, both to humans + and to computer programs. The '.h' extension is used for C + header files, and therefore communicates the wrong thing about + C++ header files. Using no extension communicates nothing and + forces inspection of file contents to determine type. Using + '.hpp' unambiguously identifies it as C++ header file, and + works well in actual practice. (Rainer Deyke) + + +What should I do if I + spot a bug in the Boost code or documentation? See the + suggestions on the [Bugs + page](/development/bugs.html). + + +How can I request a + new feature in a Boost Library? See the [Requesting New Features](/community/requests.html) + page. + + +Who's idea was + Boost? See the [original + proposal](proposal.pdf) (PDF). + + + + + + + + + diff --git a/users/history/in_progress.html b/users/history/in_progress.html new file mode 100644 index 0000000..ac41a10 --- /dev/null +++ b/users/history/in_progress.html @@ -0,0 +1,62 @@ +--- +title: In Progress Releases +copyright: Rene Rivera 2006-2007. +revised: +--- + + +In Progress Releases + + + + + + +In Progress Releases +==================== +Note: The release notes + on this page are for releases still under development. + Please don't use this page as a source of information, + it's here for development purposes only. Everything is + subject to change. +Version 1.81.0 +-------------- + + +In Progress + + +### New Libraries + + +* *TODO* + +### Updated Libraries + + +* *TODO* + +### Compilers Tested + Boost's primary test compilers are: + + + +* *TODO* + Boost's additional test compilers include: + + + +* *TODO* + +### Acknowledgements +*TODO* + + + + + + + + + + diff --git a/users/history/index.html b/users/history/index.html new file mode 100644 index 0000000..96f25fd --- /dev/null +++ b/users/history/index.html @@ -0,0 +1,25 @@ +--- +title: Boost Version History +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Boost Version History + + + + + +Boost Version History +===================== + + + + + + + + + + diff --git a/users/history/old_versions.html b/users/history/old_versions.html new file mode 100644 index 0000000..e3faba1 --- /dev/null +++ b/users/history/old_versions.html @@ -0,0 +1,116 @@ +--- +title: Old Versions +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Old Versions + +/\*\*/ + + + + + + + +Old Versions +============ + +Old Versions +------------ + + +December 14th, 1999 12:00 GMT + + +### 14 Dec 1999 +[Operators.hpp](/boost/operators.hpp) [documentation](/libs/utility/operators.htm) + improved. + + +### 13 Dec 1999 + Added iterator operators and helpers to [header + operators.hpp](/libs/utility/operators.htm), together with an iterator test program. This header + is maturing into something really useful for building arithmetic or iterator + user-defined types, so look it over even if you browsed one of the earlier + versions. + + +### 11 Dec 1999 + Added next() and prior() to [header utility.hpp](/libs/utility/utility.htm). + + +### 8 Dec 1999 + Minor improvements to the [smart pointer](/libs/smart_ptr/index.html) + library: `operator ==`, + `operator !=`, + and specializations for `std::swap` and + `std::less` now provided. + + +### 18 Nov 1999 + Minor improvements made to the [Operator + templates](/libs/utility/operators.htm). + + +### 15 Nov 1999 +[Operator templates](/libs/utility/operators.htm) have been + added to the [utility](/libs/utility/index.html) library. + + +### 11 Oct 1999 + Minor [smart pointer](/libs/smart_ptr/index.html) library + and [config.hpp](/boost/config.hpp) changes to improve portability. + + +### 26 Sep 1999 + Minor updates to several libraries: \* `polymorphic\_downcast<>` in the [utility](/libs/utility/index.html) + library [cast.hpp](/boost/cast.hpp) header now works for + multiple inheritance cases. \* `shared\_ptr<>` and `shared\_array<>` `swap()` functions added in the [smart + pointer](/libs/smart_ptr/index.html) library. \* [timer.hpp](/boost/timer.hpp) `elapsed\_max()` + and `elapsed\_min()` + functions added to the [timer](/libs/timer/index.html) library. + \* [integer](/libs/integer/index.html) library bin\_ubin.hpp + changes to eliminate compiler warning messages. \* [config.hpp](/boost/config.hpp) + minor changes to aid library developers. No impact on library users. + + +### 3 Sep 1999 + The cast functions in the [utility](/libs/utility/index.html) + library were considerably simplified. + + +### 1 Sep 1999 + The cast functions initially in [utility.hpp](/boost/utility.hpp) + have been moved to [cast.hpp](/boost/cast.hpp), still in + the [utility](/libs/utility/index.html) library. + + +### 1 Sep 1999 + The category "Experimental" has been added to the [library](/libs/libraries.htm) + page. The [integer](/libs/integer/index.html) library is + the first entry. + + + ...And the remainder are lost to the mists of time (for now, anyway).... + + + + + + + + + + + + diff --git a/users/history/version_1_10_3.html b/users/history/version_1_10_3.html new file mode 100644 index 0000000..f885dd6 --- /dev/null +++ b/users/history/version_1_10_3.html @@ -0,0 +1,58 @@ +--- +title: Version 1.10.3 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.10.3 + +/\*\*/ + + + + + + + +Version 1.10.3 +============== + +Version 1.10.3 +-------------- + + +December 30th, 1999 12:00 GMT + + + Minor fixes to the compose library examples, [operators + documentation](/libs/utility/operators.htm), [operators.hpp](/boost/operators.hpp), + [cast documentation](/libs/conversion/cast.htm), [cast.hpp](/boost/cast.hpp), + [config.hpp](/boost/config.hpp), and [smart\_ptr.hpp](/boost/smart_ptr.hpp). + + This is the first release with a version number. The version numbering scheme + is xxx.yyy.zzz. + + + +* xxx = Major version +* yyy = New library or feature added +* zzz = Bug fixes only + + + + + + + + + + + diff --git a/users/history/version_1_10_4.html b/users/history/version_1_10_4.html new file mode 100644 index 0000000..00c529e --- /dev/null +++ b/users/history/version_1_10_4.html @@ -0,0 +1,47 @@ +--- +title: Version 1.10.4 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.10.4 + +/\*\*/ + + + + + + + +Version 1.10.4 +============== + +Version 1.10.4 +-------------- + + +December 31st, 1999 12:00 GMT + + + Minor fixes to [smart\_ptr.hpp](/boost/smart_ptr.hpp) and [cast documentation](/libs/conversion/cast.htm). + + + + + + + + + + + + diff --git a/users/history/version_1_11_0.html b/users/history/version_1_11_0.html new file mode 100644 index 0000000..d1b402a --- /dev/null +++ b/users/history/version_1_11_0.html @@ -0,0 +1,51 @@ +--- +title: Version 1.11.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.11.0 + +/\*\*/ + + + + + + + +Version 1.11.0 +============== + +Version 1.11.0 +-------------- + + +February 1st, 2000 12:00 GMT + + + Added [Rational Number Library](/libs/rational/index.html). + Minor fixes to [cast.hpp](/boost/cast.hpp), [config.hpp](/boost/config.hpp), + [smart\_ptr.hpp](/boost/smart_ptr.hpp), [utility.hpp](/boost/utility.hpp), + and to the `min\_rand` sample programs. + Minor site cleanup (thanks to Paul Baxter). + + + + + + + + + + + + diff --git a/users/history/version_1_11_1.html b/users/history/version_1_11_1.html new file mode 100644 index 0000000..d5d92ae --- /dev/null +++ b/users/history/version_1_11_1.html @@ -0,0 +1,48 @@ +--- +title: Version 1.11.1 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.11.1 + +/\*\*/ + + + + + + + +Version 1.11.1 +============== + +Version 1.11.1 +-------------- + + +February 2nd, 2000 12:00 GMT + + + Minor fix to [cast.hpp](/boost/cast.hpp) (thanks to Doncho + Angelov). + + + + + + + + + + + + diff --git a/users/history/version_1_11_2.html b/users/history/version_1_11_2.html new file mode 100644 index 0000000..0c013c9 --- /dev/null +++ b/users/history/version_1_11_2.html @@ -0,0 +1,49 @@ +--- +title: Version 1.11.2 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.11.2 + +/\*\*/ + + + + + + + +Version 1.11.2 +============== + +Version 1.11.2 +-------------- + + +February 21st, 2000 12:00 GMT + + +[Smart pointer timings](/libs/smart_ptr/smarttests.htm) added + (thanks to Gavin Collings). Minor fix to the `min\_rand` + sample program. Minor fixes to [config.hpp](/boost/config.hpp). + + + + + + + + + + + + diff --git a/users/history/version_1_12_0.html b/users/history/version_1_12_0.html new file mode 100644 index 0000000..4b6311d --- /dev/null +++ b/users/history/version_1_12_0.html @@ -0,0 +1,49 @@ +--- +title: Version 1.12.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.12.0 + +/\*\*/ + + + + + + + +Version 1.12.0 +============== + +Version 1.12.0 +-------------- + + +February 23rd, 2000 12:00 GMT + + + Adds a [integer\_traits](/libs/integer/integer_traits.html) + header from Jens Maurer to the [Integer + Library](/libs/integer/index.html). + + + + + + + + + + + + diff --git a/users/history/version_1_13_0.html b/users/history/version_1_13_0.html new file mode 100644 index 0000000..872fff1 --- /dev/null +++ b/users/history/version_1_13_0.html @@ -0,0 +1,49 @@ +--- +title: Version 1.13.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.13.0 + +/\*\*/ + + + + + + + +Version 1.13.0 +============== + +Version 1.13.0 +-------------- + + +February 29th, 2000 12:00 GMT + + + Adds [Utility Library](/libs/utility/index.html) [type\_traits](/libs/type_traits/index.html), + [call\_traits](/libs/utility/call_traits.htm), and [compressed\_pair](/libs/utility/compressed_pair.htm) + headers from John Maddock, Steve Cleary and Howard Hinnant. + + + + + + + + + + + + diff --git a/users/history/version_1_14_0.html b/users/history/version_1_14_0.html new file mode 100644 index 0000000..761dcc6 --- /dev/null +++ b/users/history/version_1_14_0.html @@ -0,0 +1,49 @@ +--- +title: Version 1.14.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.14.0 + +/\*\*/ + + + + + + + +Version 1.14.0 +============== + +Version 1.14.0 +-------------- + + +March 5th, 2000 12:00 GMT + + +[Integer Library](/libs/integer/index.html) status upgraded + after removing bin\_bun.hpp. The "Experimental" library category has + been removed; the boost files/vault now serves the purpose. Minor fix to [smart\_ptr.hpp](/boost/smart_ptr.hpp) line endings. + + + + + + + + + + + + diff --git a/users/history/version_1_14_1.html b/users/history/version_1_14_1.html new file mode 100644 index 0000000..2396493 --- /dev/null +++ b/users/history/version_1_14_1.html @@ -0,0 +1,51 @@ +--- +title: Version 1.14.1 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.14.1 + +/\*\*/ + + + + + + + +Version 1.14.1 +============== + +Version 1.14.1 +-------------- + + +March 17th, 2000 12:00 GMT + + + Minor fix to [rational.hpp](/boost/rational.hpp). Minor documentation + changes to the [Smart Pointer](/libs/smart_ptr/index.html) + Library and [call\_traits](/libs/utility/call_traits.htm), + [compressed\_pair](/libs/utility/compressed_pair.htm), and type\_traits. + Updated [Library Guidelines](/more/lib_guide.htm) and [People](/users/people.html) page. + + + + + + + + + + + + diff --git a/users/history/version_1_14_2.html b/users/history/version_1_14_2.html new file mode 100644 index 0000000..57522be --- /dev/null +++ b/users/history/version_1_14_2.html @@ -0,0 +1,49 @@ +--- +title: Version 1.14.2 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.14.2 + +/\*\*/ + + + + + + + +Version 1.14.2 +============== + +Version 1.14.2 +-------------- + + +May 9th, 2000 12:00 GMT + + + No libraries updated. [Library Requirements and + Guidelines](/more/lib_guide.htm) expanded, [Library + Submission Process](/more/submission_process.htm) added. + + + + + + + + + + + + diff --git a/users/history/version_1_14_3.html b/users/history/version_1_14_3.html new file mode 100644 index 0000000..a0662cd --- /dev/null +++ b/users/history/version_1_14_3.html @@ -0,0 +1,50 @@ +--- +title: Version 1.14.3 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.14.3 + +/\*\*/ + + + + + + + +Version 1.14.3 +============== + +Version 1.14.3 +-------------- + + +May 29th, 2000 12:00 GMT + + + Minor additions to [config.hpp](/boost/config.hpp) for Borland + compilers. Minor fix to `type\_traits` + example. Minor web site fixes. [Library + Formal Review Process](/more/formal_review_process.htm) page added. + + + + + + + + + + + + diff --git a/users/history/version_1_15_0.html b/users/history/version_1_15_0.html new file mode 100644 index 0000000..ec7b884 --- /dev/null +++ b/users/history/version_1_15_0.html @@ -0,0 +1,50 @@ +--- +title: Version 1.15.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.15.0 + +/\*\*/ + + + + + + + +Version 1.15.0 +============== + +Version 1.15.0 +-------------- + + +June 17th, 2000 12:00 GMT + + +[Random Number Library](/libs/random/index.html) from Jens + Maurer added. Updated utility library [operators](/libs/utility/operators.htm) + eliminates code bloat. Minor additions to [config.hpp](/boost/config.hpp) + and [cast.hpp](/boost/cast.hpp) for Microsoft compilers. + + + + + + + + + + + + diff --git a/users/history/version_1_15_1.html b/users/history/version_1_15_1.html new file mode 100644 index 0000000..50d5181 --- /dev/null +++ b/users/history/version_1_15_1.html @@ -0,0 +1,51 @@ +--- +title: Version 1.15.1 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.15.1 + +/\*\*/ + + + + + + + +Version 1.15.1 +============== + +Version 1.15.1 +-------------- + + +June 21st, 2000 12:00 GMT + + + Fixes to [cast.hpp](/boost/cast.hpp) and [operators](/libs/utility/operators.htm) + fix. Minor additions to [config.hpp](/boost/config.hpp) for + Microsoft compilers. The 1.15.0 operators changes seem to have introduced incompatibilities. + We are working on fixing them, and have started to build a regression test to + prevent similar future problems. + + + + + + + + + + + + diff --git a/users/history/version_1_16_0.html b/users/history/version_1_16_0.html new file mode 100644 index 0000000..2a8ccbe --- /dev/null +++ b/users/history/version_1_16_0.html @@ -0,0 +1,64 @@ +--- +title: Version 1.16.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.16.0 + +/\*\*/ + + + + + + + +Version 1.16.0 +============== + +Version 1.16.0 +-------------- + + +June 28th, 2000 12:00 GMT + +* Added [Functional Library](/libs/functional/index.html) + - Enhanced function object adaptors from Mark Rodgers. +* Added missing [Random Number Library](/libs/random/index.html) + files. +* Updated [operators docs](/libs/utility/operators.htm) and + [operators.hpp](/boost/operators.hpp). +* New [iterator.hpp](/boost/iterator.hpp) header. +* Minor [rational.hpp](/boost/rational.hpp), [rational\_example.cpp](/libs/rational/rational_example.cpp), + and [integer\_traits\_test.cpp](/libs/integer/integer_traits_test.cpp) + changes to support more compilers. +* Revised [cast.hpp](/boost/cast.hpp): removed implicit\_cast, + plus fixes for broken compilers. +* Minor [smart\_ptr.hpp](/boost/smart_ptr.hpp) workaround + for some GCC builds. +* Several [config.hpp](/boost/config.hpp) changes for Microsoft, + Intel, and other compilers. +* Added [Configuration Header](/libs/config/index.html) page + and test program. +* Added Experimental [Compiler Status](/status/compiler_status.html) + page showing what library works with which compilers. + + + + + + + + + + + diff --git a/users/history/version_1_16_1.html b/users/history/version_1_16_1.html new file mode 100644 index 0000000..fe5b380 --- /dev/null +++ b/users/history/version_1_16_1.html @@ -0,0 +1,56 @@ +--- +title: Version 1.16.1 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.16.1 + +/\*\*/ + + + + + + + +Version 1.16.1 +============== + +Version 1.16.1 +-------------- + + +July 5th, 2000 12:00 GMT + +* [Integer](/libs/integer/index.html) library: fixed + [cstdint.hpp](/boost/cstdint.hpp) bug, added [cstdint\_test.cpp](/libs/integer/cstdint_test.cpp), + updated [docs](/libs/integer/cstdint.htm). +* [Random Number Library](/libs/random/index.html): minor + fixes to [random.hpp](/boost/random.hpp) and [random\_test.cpp](/libs/random/random_test.cpp) + to support more compilers. +* Updated [cast.hpp](/boost/cast.hpp) with more Microsoft + compiler workarounds. +* Updated [call\_traits docs](/libs/utility/call_traits.htm), + added [call\_traits\_test.cpp](/libs/utility/call_traits_test.cpp). +* Cleanup and bug fixes for [operators.hpp](/boost/operators.hpp) + and [operators\_test.cpp](/libs/utility/operators_test.cpp). + + + + + + + + + + + diff --git a/users/history/version_1_17_0.html b/users/history/version_1_17_0.html new file mode 100644 index 0000000..2aa20f3 --- /dev/null +++ b/users/history/version_1_17_0.html @@ -0,0 +1,59 @@ +--- +title: Version 1.17.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.17.0 + +/\*\*/ + + + + + + + +Version 1.17.0 +============== + +Version 1.17.0 +-------------- + + +August 3rd, 2000 12:00 GMT + +* [Array Library](/libs/array/index.html) added - An + STL compliant container wrapper for arrays of constant size from Nicolai + Josuttis. +* array traits header renamed array\_traits.hpp (was array.hpp). +* [Random Number Library](/libs/random/index.html): more + minor changes to support more compilers. +* [Smart Pointer Library](/libs/smart_ptr/index.html): + performance + reducing exception-specifications removed. +* Compiler and test program fixes for call\_traits, compressed\_pair, and type\_traits. +* Updated [cast.hpp](/boost/cast.hpp) to clear compiler warning + messages. +* Linux [Compiler Status](/status/compiler_status.html) added. +* Boost source code now lives in a publicly accessible Concurrent Versions + System (CVS) repository. + + + + + + + + + + + diff --git a/users/history/version_1_18_0.html b/users/history/version_1_18_0.html new file mode 100644 index 0000000..786750b --- /dev/null +++ b/users/history/version_1_18_0.html @@ -0,0 +1,64 @@ +--- +title: Version 1.18.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.18.0 + +/\*\*/ + + + + + + + +Version 1.18.0 +============== + +Version 1.18.0 +-------------- + + +September 28th, 2000 12:00 GMT + +* Preliminary release of two important new libraries: + + + [Graph Library](/libs/graph/doc/table_of_contents.html) - + Generic graph components and algorithms from Jeremy Siek and a University + of Notre Dame team. + + [Regular Expression Library](/libs/regex/index.html) - + Text pattern matching in all its glory from John Maddock. +* Other changes: + + + [Array Library](/libs/array/index.html) improvements + reflecting formal review comments. + + [functional.hpp](/boost/functional.hpp) compiler + workarounds added. + + `tie() + function template` + added to utility.hpp for easier handling of std::pair<> return + values. + + [Integer Library](/libs/integer/index.html) improved + handling of 64-bit integers. + + Minor web site page updates. + + + + + + + + + + + diff --git a/users/history/version_1_18_1.html b/users/history/version_1_18_1.html new file mode 100644 index 0000000..4072d24 --- /dev/null +++ b/users/history/version_1_18_1.html @@ -0,0 +1,53 @@ +--- +title: Version 1.18.1 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.18.1 + +/\*\*/ + + + + + + + +Version 1.18.1 +============== + +Version 1.18.1 +-------------- + + +October 15th, 2000 12:00 GMT + +* [Graph Library](/libs/graph/doc/table_of_contents.html), + [Random Number Library](/libs/random/index.html), and + [Regular Expression Library](/libs/regex/index.html): Minor + fixes. +* [Configuration Header](/libs/config/index.html) additions + for various compiler foibles. +* Portability Hints: Borland C++ 5.5.1 from Jens Maurer added. +* [Compiler Status](/status/compiler_status.html) updated + for latest versions of several compilers. + + + + + + + + + + + diff --git a/users/history/version_1_18_2.html b/users/history/version_1_18_2.html new file mode 100644 index 0000000..128ca63 --- /dev/null +++ b/users/history/version_1_18_2.html @@ -0,0 +1,57 @@ +--- +title: Version 1.18.2 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.18.2 + +/\*\*/ + + + + + + + +Version 1.18.2 +============== + +Version 1.18.2 +-------------- + + +November 3rd, 2000 12:00 GMT + +* [Cast Library](/libs/conversion/cast.htm) Fix numeric\_cast<> + bugs with floating types. +* [Graph Library](/libs/graph/doc/table_of_contents.html) + minor + fixes. +* [Regular Expression Library](/libs/regex/index.html) minor + fixes. +* [Configuration Header](/libs/config/index.html) more + fixes for broken compilers. +* Boost Header Dependencies page added. +* Terminology change: Several headers previously lumped together as a "utility" + library are now considered separate libraries. For historical reasons, their + non-header files still live in the "utility" sub-directory. + + + + + + + + + + + diff --git a/users/history/version_1_18_3.html b/users/history/version_1_18_3.html new file mode 100644 index 0000000..ea9013f --- /dev/null +++ b/users/history/version_1_18_3.html @@ -0,0 +1,55 @@ +--- +title: Version 1.18.3 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.18.3 + +/\*\*/ + + + + + + + +Version 1.18.3 +============== + +Version 1.18.3 +-------------- + + +November 18th, 2000 12:00 GMT + +* [Graph Library](/libs/graph/doc/table_of_contents.html) + minor + fixes and additions. +* [Regular Expression Library](/libs/regex/index.html) minor + fixes. +* [cast.hpp](/boost/cast.hpp) Borland compiler fixes. +* [cstdint.hpp](/boost/cstdint.hpp) changed to no longer + expose names to the global namespace. +* BeOS5/Intel compiler status contributed by John Maddock. +* [Compiler Status](/status/compiler_status.html) added + two additional test programs. + + + + + + + + + + + diff --git a/users/history/version_1_19_0.html b/users/history/version_1_19_0.html new file mode 100644 index 0000000..4933d7e --- /dev/null +++ b/users/history/version_1_19_0.html @@ -0,0 +1,60 @@ +--- +title: Version 1.19.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.19.0 + +/\*\*/ + + + + + + + +Version 1.19.0 +============== + +Version 1.19.0 +-------------- + + +December 10th, 2000 12:00 GMT + +* [Concept Check Library](/libs/concept_check/concept_check.htm) added + - tools for generic programming from Jeremy Siek. +* [Python Library](/libs/python/doc/index.html) added + - reflects C++ classes and functions into Python, from Dave Abrahams. +* [Static Assert Library](/libs/static_assert/static_assert.htm) added + - compile time assertions from John Maddock +* [Property Map Concepts](/libs/property_map/property_map.html) added + - interfaces which map key objects to value objects from Jeremy Siek. +* [Graph Library](/libs/graph/doc/table_of_contents.html) + minor + updates. +* [Regular Expression Library](/libs/regex/index.html) minor + updates. +* [Library Requirements and Guidelines](/more/lib_guide.htm) + - directory name policy added. +* [FAQ](/more/faq.htm) updated. + + + + + + + + + + + diff --git a/users/history/version_1_20_0.html b/users/history/version_1_20_0.html new file mode 100644 index 0000000..1d17dd0 --- /dev/null +++ b/users/history/version_1_20_0.html @@ -0,0 +1,58 @@ +--- +title: Version 1.20.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.20.0 + +/\*\*/ + + + + + + + +Version 1.20.0 +============== + +Version 1.20.0 +-------------- + + +January 6th, 2001 12:00 GMT + +* [Conversion Library](/libs/conversion/index.html) added + - [cast](/libs/conversion/cast.htm) and [lexical\_cast](/libs/conversion/lexical_cast.htm) + headers from Dave Abrahams and Kevlin Henney. +* Web site moved to a larger host after the old ISP collapsed unexpectedly. +* Regression tests now include execution testing. See [Compiler + Status](/status/compiler_status.html). +* [Discussion Policy](/more/discussion_policy.htm) page added. +* [Array Library](/libs/array/index.html) minor documentation + improvements. +* [Graph Library](/libs/graph/doc/table_of_contents.html) + minor + updates. +* [Regular Expression Library](/libs/regex/index.html) minor + updates. + + + + + + + + + + + diff --git a/users/history/version_1_20_1.html b/users/history/version_1_20_1.html new file mode 100644 index 0000000..ff926e1 --- /dev/null +++ b/users/history/version_1_20_1.html @@ -0,0 +1,52 @@ +--- +title: Version 1.20.1 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.20.1 + +/\*\*/ + + + + + + + +Version 1.20.1 +============== + +Version 1.20.1 +-------------- + + +January 10th, 2001 12:00 GMT + +* [compressed\_pair.hpp](/boost/compressed_pair.hpp) minor + update fixes test failures of other libraries under VC++. +* [Graph Library](/libs/graph/doc/table_of_contents.html) + minor + updates. +* [Regular Expression Library](/libs/regex/index.html) minor + updates. +* Minor website fixes including missing files in boost\_all.zip. + + + + + + + + + + + diff --git a/users/history/version_1_20_2.html b/users/history/version_1_20_2.html new file mode 100644 index 0000000..d67c55f --- /dev/null +++ b/users/history/version_1_20_2.html @@ -0,0 +1,74 @@ +--- +title: Version 1.20.2 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.20.2 + +/\*\*/ + + + + + + + +Version 1.20.2 +============== + +Version 1.20.2 +-------------- + + +February 10th, 2001 12:00 GMT + +Downloads| Platform | File | +| unix | [boost-1.20.2.tar.bz2](https://sourceforge.net/projects/boost/files/boost/1.20.2/boost-1.20.2.tar.bz2) | +| [boost-1.20.2.tar.gz](https://sourceforge.net/projects/boost/files/boost/1.20.2/boost-1.20.2.tar.gz) | +| windows | [boost-1\_20\_2.zip](https://sourceforge.net/projects/boost/files/boost/1.20.2/boost-1_20_2.zip) | + +* Array traits: minor portability fix. +* [Graph Library](/libs/graph/doc/table_of_contents.html) - + Changes to [`breadth\_first\_search()`](/libs/graph/doc/breadth_first_search.html) + re: [BFSVisitor](/libs/graph/doc/BFSVisitor.html), added + max flow algorithms [`edmunds\_karp\_max\_flow()`](/libs/graph/doc/edmunds_karp_max_flow.html) + and [`push\_relabel\_max\_flow()`](/libs/graph/doc/push_relabel_max_flow.html), + added [`adjacency\_matrix`](/libs/graph/doc/adjacency_matrix.html) + graph class, added [`filtered\_graph`](/libs/graph/doc/filtered_graph.html) adaptor +* [Integer Library](/libs/integer/index.html): minor + fixes to integer.hpp and integer\_test.cpp +* [Portability Hints: Microsoft Visual C++](microsoft_vcpp.html) + added. +* [Random Number Library](/libs/random/index.html): Minor + portability fixes +* [Rational Number Library](/libs/rational/index.html): + documentation + updates, efficiency improvements, co-operates with user-defined types, regression + tests +* [Regular Expression Library](/libs/regex/index.html): minor + updates. +* [Smart Pointer Library](/libs/smart_ptr/index.html): + shared\_ptr + example added. +* [Timer Library](/libs/timer/index.html): changed + to an all inline implementation. + + + + + + + + + + + diff --git a/users/history/version_1_21_0.html b/users/history/version_1_21_0.html new file mode 100644 index 0000000..2f604a4 --- /dev/null +++ b/users/history/version_1_21_0.html @@ -0,0 +1,75 @@ +--- +title: Version 1.21.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.21.0 + +/\*\*/ + + + + + + + +Version 1.21.0 +============== + +Version 1.21.0 +-------------- + + +March 9th, 2001 12:00 GMT + +* [Iterator Adaptor + Library](/libs/utility/iterator_adaptors.htm) added. Adapt a base type into a standard conforming iterator, + and more, from Dave Abrahams, Jeremy Siek, and John Potter. +* [Pool Library](/libs/pool/doc/index.html) added. + Memory pool management from Steve Cleary. +* [Test Library](/libs/test/doc/index.html) added. + Support for program testing and execution from Beman Dawes. +* [Generic Programming Techniques](/more/generic_programming.html) + page added, contributed by Dave Abrahams. +* [Graph Library](/libs/graph/doc/table_of_contents.html): + Updated + use of iterator adaptors. Changed `operator +==` for `adjacency\_list::edge\_descriptor` + to improve semantics for multigraphs. Moved `adjacency\_iterator\_generator` + from namespace `detail` to + `boost` and added [documentation](/libs/graph/doc/adjacency_iterator.html). + Renamed `dynamic\_components()` to [`incremental\_components()`](/libs/graph/doc/incremental_components.html), + better matching graph literature terminology. Cleaned up interface of [`connected\_components()`](/libs/graph/doc/connected_components.html) and created separate [`strong\_components()`](/libs/graph/doc/strong_components.html) + function using Tarjan's more efficient algorithm. Fixed documentation figures + for [`adjacency\_list`](/libs/graph/doc/adjacency_list.html) + and [`adjacency\_matrix`](/libs/graph/doc/adjacency_matrix.html). + Added docs for [`cuthill\_mckee\_ordering()`](/libs/graph/doc/cuthill_mckee_ordering.html) + algorithm. +* [Python Library](/libs/python/doc/index.html) upgraded. + Better compatibility with Python 2.0, NULL pointers and smart-pointers get + converted to/from python None, massive documentation review/revision. +* [Regular Expression Library](/libs/regex/index.html): Minor + fixes for Unicode platforms. +* [Type Traits Library](/libs/type_traits/index.html) + upgraded: + Major revision. + + + + + + + + + + + diff --git a/users/history/version_1_21_1.html b/users/history/version_1_21_1.html new file mode 100644 index 0000000..47e4e05 --- /dev/null +++ b/users/history/version_1_21_1.html @@ -0,0 +1,57 @@ +--- +title: Version 1.21.1 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.21.1 + +/\*\*/ + + + + + + + +Version 1.21.1 +============== + +Version 1.21.1 +-------------- + + +March 14th, 2001 12:00 GMT + +Downloads| Platform | File | +| unix | [boost\_1\_21\_1.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.21.1/boost_1_21_1.tar.bz2) | +| [boost\_1\_21\_1.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.21.1/boost_1_21_1.tar.gz) | +| windows | [boost\_1\_21\_1.zip](http://sourceforge.net/projects/boost/files/boost/1.21.1/boost_1_21_1.zip) | + +* New download page. The .zip and .tar.gz files now live on the SourceForge + ftp site. +* [Graph Library](/libs/graph/doc/index.html): Minor + docs fixes. +* [Python Library](/libs/python/doc/index.html): Minor + docs fixes. +* [Regex Library](/libs/regex/index.html): Minor portability + fixes. + + + + + + + + + + + diff --git a/users/history/version_1_21_2.html b/users/history/version_1_21_2.html new file mode 100644 index 0000000..37f2225 --- /dev/null +++ b/users/history/version_1_21_2.html @@ -0,0 +1,67 @@ +--- +title: Version 1.21.2 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.21.2 + +/\*\*/ + + + + + + + +Version 1.21.2 +============== + +Version 1.21.2 +-------------- + + +April 24th, 2001 12:00 GMT + +Downloads| Platform | File | +| unix | [boost\_1\_21\_2.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.21.2/boost_1_21_2.tar.bz2) | +| [boost\_1\_21\_2.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.21.2/boost_1_21_2.tar.gz) | +| windows | [boost\_1\_21\_2.zip](http://sourceforge.net/projects/boost/files/boost/1.21.2/boost_1_21_2.zip) | + +* [Compatibility Library](/libs/compatibility/index.html) + added: + Help for non-conforming standard libraries missing CXX headers from Ralf + Grosse-Kunstleve, and help for missing standard library header + from Jens Maurer. (These are unreviewed implementation libraries, treated + as maintenance steps only.) +* [Random Number Library](/libs/random/index.html): Split + into separate headers, updated documentation, added lagged\_fibonacci generator. +* [Integer Library](/libs/integer/index.html): Minor + portability update. +* [Graph Library](/libs/graph/doc/table_of_contents.html): + Changed + algorithm interfaces to use named parameters technique. Added graph isomorphism + algorithm. +* Download refinements - files now available from either FTP or web server. +* [Tracker](http://sourceforge.net/tracker/?group_id=7586) + Added: View and submit bug, support, and feature requests. +* Minor portability fixes in several other libraries. + + + + + + + + + + + diff --git a/users/history/version_1_22_0.html b/users/history/version_1_22_0.html new file mode 100644 index 0000000..ce82755 --- /dev/null +++ b/users/history/version_1_22_0.html @@ -0,0 +1,62 @@ +--- +title: Version 1.22.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.22.0 + +/\*\*/ + + + + + + + +Version 1.22.0 +============== + +Version 1.22.0 +-------------- + + +May 25th, 2001 12:00 GMT + +Downloads| Platform | File | +| unix | [boost\_1\_22\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.22.0/boost_1_22_0.tar.bz2) | +| [boost\_1\_22\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.22.0/boost_1_22_0.tar.gz) | +| windows | [boost\_1\_22\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.22.0/boost_1_22_0.zip) | + +* [CRC Library](/libs/crc/index.html) added. Compute + cyclic redundancy codes from Daryle Walker. +* [Graph Library](/libs/graph/doc/index.html): Minor + fixes. +* [Integer Traits](/libs/integer/integer_traits.html): added + wchar\_t specialization, minor portability fixes. +* [Regex Library](/libs/regex/index.html): Minor portability + fixes. +* [Smart Pointer Library](/libs/smart_ptr/smart_ptr.htm): + fixed + bugs, tightened requirements, added examples. +* [Utility Library](/libs/utility/utility.htm): added + checked\_delete() and checked\_array\_delete() functions. + + + + + + + + + + + diff --git a/users/history/version_1_23_0.html b/users/history/version_1_23_0.html new file mode 100644 index 0000000..6e27ee3 --- /dev/null +++ b/users/history/version_1_23_0.html @@ -0,0 +1,64 @@ +--- +title: Version 1.23.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.23.0 + +/\*\*/ + + + + + + + +Version 1.23.0 +============== + +Version 1.23.0 +-------------- + + +July 6th, 2001 12:00 GMT + +Downloads| Platform | File | +| unix | [boost\_1\_23\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.23.0/boost_1_23_0.tar.bz2) | +| [boost\_1\_23\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.23.0/boost_1_23_0.tar.gz) | +| windows | [boost\_1\_23\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.23.0/boost_1_23_0.zip) | + +* [Any Library](/libs/any/index.html) added. Safe, + generic container for single values of different value types, from Kevlin + Henney. +* [Function Library](/libs/function/index.html) added. + Function object wrappers for deferred calls or callbacks, from Doug Gregor. +* [Tokenizer Library](/libs/tokenizer/index.html) added. + Break a string into a series of tokens, from John Bandela. +* [Special functions](/doc/html/boost_math/math_special_functions.html), + [octonions](/doc/html/boost_math/octonions.html), [quaternions](/doc/html/boost_math/quaternions.html) added, from + Hubert Holin. +* [Smart Pointer Library](/libs/smart_ptr/smart_ptr.htm): + shared\_ptr + polymorphic pointers now work on more broken compilers. +* IBM/Aix Compiler status table contributed by Toon Knapen. +* Minor fixes to a number of other libraries. + + + + + + + + + + + diff --git a/users/history/version_1_24_0.html b/users/history/version_1_24_0.html new file mode 100644 index 0000000..636cfd3 --- /dev/null +++ b/users/history/version_1_24_0.html @@ -0,0 +1,59 @@ +--- +title: Version 1.24.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.24.0 + +/\*\*/ + + + + + + + +Version 1.24.0 +============== + +Version 1.24.0 +-------------- + + +August 19th, 2001 12:00 GMT + +Downloads| Platform | File | +| unix | [boost\_1\_24\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.24.0/boost_1_24_0.tar.bz2) | +| [boost\_1\_24\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.24.0/boost_1_24_0.tar.gz) | +| windows | [boost\_1\_24\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.24.0/boost_1_24_0.zip) | + +* [Tuple Library](/libs/tuple/doc/tuple_users_guide.html) + added. + Tuples ease definition of functions returning multiple values, and more, + from Jaakko Jarvi. +* Minor fixes to some other libraries. +* [Boost Build System](/tools/build/index.html) added. + Preliminary release of an innovative build system for Boost libraries, from + Dave Abrahams and others. +* [Formal Review Schedule](/more/formal_review_schedule.html) + added. Shows current, future, and recent past review dates. + + + + + + + + + + + diff --git a/users/history/version_1_25_0.html b/users/history/version_1_25_0.html new file mode 100644 index 0000000..a46d3b7 --- /dev/null +++ b/users/history/version_1_25_0.html @@ -0,0 +1,74 @@ +--- +title: Version 1.25.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.25.0 + +/\*\*/ + + + + + + + +Version 1.25.0 +============== + +Version 1.25.0 +-------------- + + +October 1st, 2001 12:00 GMT + +Downloads| Platform | File | +| unix | [boost\_1\_25\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.25.0/boost_1_25_0.tar.bz2) | +| [boost\_1\_25\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.25.0/boost_1_25_0.tar.gz) | +| windows | [boost\_1\_25\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.25.0/boost_1_25_0.zip) | + +* [Thread Library](/libs/thread/doc/index.html) added. + Portable C++ multi-programming at last, from William Kempf. +* [Base From Member](/libs/utility/base_from_member.html) + added to [Utility Library](/libs/utility/utility.htm). + Support for the base from member idiom, from Daryle Walker. +* [Bind](/libs/bind/bind.html) and [mem\_fn](/libs/bind/mem_fn.html) + added - Generalized binders for function/object/pointers and member functions, + from Peter Dimov. +* [Array Library](/libs/array/index.html): Minor updates, + from Nico Josuttis. +* [Config Library](/libs/config/config.htm): major + redesign with much improved and automated configuration of Boost libraries + for specific compilers, from John Maddock. +* [Random Number Library](/libs/random/index.html): Fixed + bug when copying normal\_distribution and improved the documentation, from + Michael Stevens and Jens Maurer. +* [Special functions](/doc/html/boost_math/math_special_functions.html), + [octonions](/doc/html/boost_math/octonions.html), [quaternions](/doc/html/boost_math/quaternions.html) updated, + now useable with many more compilers, plus three new special functions, from + Hubert Holin, Eric Ford, and others. +* [Tokenizer Library](/libs/tokenizer/index.html): + fixes/enhancements + to escaped\_list\_separator based on empty fields and tokens comments from + Johan Nillson and Jens Maurer. +* Coming Soon - A mailing list for Boost users! + + + + + + + + + + + diff --git a/users/history/version_1_25_1.html b/users/history/version_1_25_1.html new file mode 100644 index 0000000..11e0036 --- /dev/null +++ b/users/history/version_1_25_1.html @@ -0,0 +1,67 @@ +--- +title: Version 1.25.1 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.25.1 + +/\*\*/ + + + + + + + +Version 1.25.1 +============== + +Version 1.25.1 +-------------- + + +November 5th, 2001 12:00 GMT + +Downloads| Platform | File | +| unix | [boost\_1\_25\_1.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.25.1/boost_1_25_1.tar.bz2) | +| [boost\_1\_25\_1.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.25.1/boost_1_25_1.tar.gz) | +| windows | [boost\_1\_25\_1.zip](http://sourceforge.net/projects/boost/files/boost/1.25.1/boost_1_25_1.zip) | + +* [Boost Build System](/tools/build/index.html): Continued + improvements. +* [Config Library](/libs/config/config.htm): Continued + refinements. +* [Graph Library](/libs/graph/doc/index.html): Final + cleanup for upcoming the Boost Graph Library book. +* [Thread Library](/libs/thread/doc/index.html): Minor + fixes - tests now pass on most Win32 and POSIX systems including Linux and + Solaris. Semaphore removed as too error prone. +* [Function Library](/libs/function/index.html): direct + support for member function pointers and documentation updates. +* [Boost-Users](http://groups.yahoo.com/group/Boost-Users) + mailing list has been created to address topics of interest to users of Boost + libraries. +* [Boost + Wiki web](http://www.crystalclearsoftware.com/cgi-bin/boost_wiki/wiki.pl) added. Provides a place for Boost users to openly discuss + and document the use of Boost libraries. It is not officially maintained + by Boost developers. + + + + + + + + + + + diff --git a/users/history/version_1_26_0.html b/users/history/version_1_26_0.html new file mode 100644 index 0000000..718cf8c --- /dev/null +++ b/users/history/version_1_26_0.html @@ -0,0 +1,68 @@ +--- +title: Version 1.26.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.26.0 + +/\*\*/ + + + + + + + +Version 1.26.0 +============== + +Version 1.26.0 +-------------- + + +November 30th, 2001 12:00 GMT + +Downloads| Platform | File | +| unix | [boost\_1\_26\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.26.0/boost_1_26_0.tar.bz2) | +| [boost\_1\_26\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.26.0/boost_1_26_0.tar.gz) | +| windows | [boost\_1\_26\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.26.0/boost_1_26_0.zip) | + +* [Common Factor Library](/libs/math/doc/common_factor.html) + added. + Greatest common divisor and least common multiple, from Daryle Walker. +* [Preprocessor Library](/libs/preprocessor/doc/index.html) + added. + Preprocessor metaprogramming tools including repetition and recursion, from + Vesa Karvonen. +* [Iterator Adaptor + Library](/libs/utility/iterator_adaptors.htm): Added [generator + iterator](/libs/utility/generator_iterator.htm) adaptor, from Jens Maurer. +* [Random Number Library](/libs/random/index.html): Removed + iterator interface. Fixed overflows in uniform\_int<>. Both changes + cause random number sequences to differ compared to previous boost releases. +* [phase library..[operators.hpp](/libs/utility/operators.htm):] + Improvements from Daryle and Helmut Ziesel +* [Boost.Build](/tools/build/index.html): Continuing + improvements, including pre-built [Boost.Jam + executables](/tools/build/index.html). +* Minor fixes to a number of other libraries. + + + + + + + + + + + diff --git a/users/history/version_1_27_0.html b/users/history/version_1_27_0.html new file mode 100644 index 0000000..6977166 --- /dev/null +++ b/users/history/version_1_27_0.html @@ -0,0 +1,80 @@ +--- +title: Version 1.27.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.27.0 + +/\*\*/ + + + + + + + +Version 1.27.0 +============== + +Version 1.27.0 +-------------- + + +February 5th, 2002 12:00 GMT + +Downloads| Platform | File | +| unix | [boost\_1\_27\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.27.0/boost_1_27_0.tar.bz2) | +| [boost\_1\_27\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.27.0/boost_1_27_0.tar.gz) | +| windows | [boost\_1\_27\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.27.0/boost_1_27_0.zip) | + +* [Python Library](/libs/python/doc/index.html): Scott + Snyder contributed inplace operator support. +* [Integer Library](/libs/integer/index.html): Daryle + Walker contributed enhancements to the [type + selection templates](/libs/integer/integer.htm), and added new compile-time [bit + mask](/libs/integer/doc/integer_mask.html), [binary logarithm](/libs/integer/doc/static_log2.html), + and [extrema](/libs/integer/doc/static_min_max.html) templates. +* [Function Library](/libs/function/index.html): user + may request that `boost::function` objects store a reference to a + function object target instead of a copy, using [`ref`](/libs/bind/ref.html). Stateless objects are optimized + so that they require no dynamic storage. +* [Quaternions](/doc/html/boost_math/quaternions.html): added + support for GCC 2.95.x. +* [Octonions](/doc/html/boost_math/octonions.html): added + support for GCC 2.95.x. +* [Smart Pointers Library](/libs/smart_ptr/index.html): Peter + Dimov contributed a new implementation that fixes some bugs and adds some + features including [thread + safety](/libs/smart_ptr/compatibility.htm#threadsafe) when manipulating the use count, [custom + delete functions](/libs/smart_ptr/shared_ptr.htm#constructors), a new [weak\_ptr](/libs/smart_ptr/weak_ptr.htm), + and shared\_static\_cast and shared\_dynamic\_cast. +* [Preprocessor Library](/libs/preprocessor/doc/index.html): + changed + macro prefix from BOOST\_PREPROCESSOR to BOOST\_PP, added support for list + data structure manipulation, added examples, made library ANSI C friendly, + added generalized [repetition](/libs/preprocessor/doc/ref/for.html) + and [iteration](/libs/preprocessor/doc/ref/while.html) + primitives, improved reference manual. +* [Threads Library](/libs/thread/doc/index.html): Mac + Carbon implementation contributed by Mac Murrett. +* Minor fixes to many libraries. + + + + + + + + + + + diff --git a/users/history/version_1_28_0.html b/users/history/version_1_28_0.html new file mode 100644 index 0000000..34077a8 --- /dev/null +++ b/users/history/version_1_28_0.html @@ -0,0 +1,72 @@ +--- +title: Version 1.28.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.28.0 + +/\*\*/ + + + + + + + +Version 1.28.0 +============== + +Version 1.28.0 +-------------- + + +May 15th, 2002 12:00 GMT + +Downloads| Platform | File | +| unix | [boost\_1\_28\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.28.0/boost_1_28_0.tar.bz2) | +| [boost\_1\_28\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.28.0/boost_1_28_0.tar.gz) | +| windows | [boost\_1\_28\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.28.0/boost_1_28_0.zip) | + +* The Boost mailing lists are now also accessible as [newsgroups](/more/mailing_lists.htm#newsgroup). +* A powerful [mailing + list archive](http://aspn.activestate.com/ASPN/Mail/Archives/boost/) has been contributed by the [ActiveState + Programmer Network](http://aspn.activestate.com/ASPN). +* [Lambda Library](/libs/lambda/doc/index.html) added, + from Jaakko Jarvi and Gary Powell. Define small unnamed function objects + at the actual call site: for\_each( a.begin(), a.end(), std::cout << + \_1 << ' ' ); +* [I/O State Saver Library added](/libs/io/doc/ios_state.html) - + Save I/O state to prevent jumbled data, from Daryle Walker. +* [Configuration Library](/libs/config/config.htm): User + code should not use BOOST\_NO\_LIMITS. +* [Random Number Library](/libs/random/index.html): Avoid + compiler warnings. +* [Smart Pointers Library](/libs/smart_ptr/index.html): Added + shared\_polymorphic\_cast and shared\_polymorphic\_downcast. +* [Function Library](/libs/function/index.html): Now + supports function objects with the unary `&` + operator overloaded. +* [Utility Library](/libs/utility/utility.htm): Added + `addressof()` + function. +* The usual small fixes and tweaks. + + + + + + + + + + + diff --git a/users/history/version_1_29_0.html b/users/history/version_1_29_0.html new file mode 100644 index 0000000..4ee8877 --- /dev/null +++ b/users/history/version_1_29_0.html @@ -0,0 +1,81 @@ +--- +title: Version 1.29.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.29.0 + +/\*\*/ + + + + + + + +Version 1.29.0 +============== + +Version 1.29.0 +-------------- + + +October 10th, 2002 12:00 GMT + +Downloads| Platform | File | +| unix | [boost\_1\_29\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.29.0/boost_1_29_0.tar.bz2) | +| [boost\_1\_29\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.29.0/boost_1_29_0.tar.gz) | +| windows | [boost\_1\_29\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.29.0/boost_1_29_0.zip) | + +* [Date-Time Library](/libs/date_time/doc/index.html) added + - Dates, times, leap seconds, infinity, and more, from Jeff Garland. +* [Dynamic Bitset](/libs/dynamic_bitset/dynamic_bitset.html) + added + - A runtime sized version of the `std::bitset` + class from Jeremy Siek and Chuck Allison. +* [Format Library](/libs/format/index.html) added - + Type-safe 'printf-like' format operations, from Samuel Krempp. +* [Function Library](/libs/function/index.html): Major + syntactic changes have been made. Some old syntax and little-used features + have been deprecated (and will be removed shortly), and the syntax for the + `boost::function` class template has been greatly + improved on conforming compilers. Please see the compatibility note for more + information. +* [Multi-array Library](/libs/multi_array/doc/index.html) + added + - Multidimensional containers and adaptors for arrays of contiguous data, + from Ron Garcia. +* [Preprocessor Library](/libs/preprocessor/index.html): + Major + upgrade, from Paul Mensonides. +* [Python Library](/libs/python/doc/index.html) - Version + 2 is released, from Dave Abrahams and others. This is a major rewrite which + works on many more compilers and platforms, with a completely new interface + and lots of new features. Boost.Python v2 requires Python 2.2 or later. +* [Signals Library](/libs/signals/doc/index.html) added + - Managed signals & slots callback implementation, from Doug Gregor. +* [Test Library](/libs/test/doc/index.html): Major + new version, including full unit test capabilities, from Gennadiy Rozental. +* [uBLAS Library](/libs/numeric/ublas/doc/index.htm) added + - Basic linear algebra for dense, packed and sparse matrices, from Joerg + Walter and Mathias Koch. + + + + + + + + + + + diff --git a/users/history/version_1_30_0.html b/users/history/version_1_30_0.html new file mode 100644 index 0000000..ec22b5c --- /dev/null +++ b/users/history/version_1_30_0.html @@ -0,0 +1,104 @@ +--- +title: Version 1.30.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.30.0 + +/\*\*/ + + + + + + + +Version 1.30.0 +============== + +Version 1.30.0 +-------------- + + +March 19th, 2003 12:00 GMT + +Downloads| Platform | File | +| unix | [boost\_1\_30\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.30.0/boost_1_30_0.tar.bz2) | +| [boost\_1\_30\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.30.0/boost_1_30_0.tar.gz) | +| windows | [boost\_1\_30\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.30.0/boost_1_30_0.zip) | + +* [Filesystem Library](/libs/filesystem/doc/index.htm) added + - Portable paths, iteration over directories, and other useful filesystem + operations, from Beman Dawes. +* [Optional Library](/libs/optional/doc/optional.html) added + - A discriminated-union wrapper for optional values, from Fernando Cacciola. +* [Interval Library](/libs/numeric/interval/doc/interval.htm) + added + - Extends the usual arithmetic functions to mathematical intervals, from + Guillaume Melquiond, Herve Bronnimann and Sylvain Pion. +* [MPL](/libs/mpl/doc/index.html) added - Template + metaprogramming framework of compile-time algorithms, sequences and metafunction + classes, from Aleksey Gurtovoy. +* [Spirit Library](/libs/spirit/index.html) added - + An LL (unlimited lookahead) parser framework that represents parsers directly + as EBNF grammars in inlined C++ source code, complete with semantic actions, + ASTs and much more, from Joel de Guzman and team. +* [Smart Pointers Library](/libs/smart_ptr/index.html) - + cast functions are now spelled [static\_pointer\_cast](/libs/smart_ptr/shared_ptr.htm#static_pointer_cast) + / [dynamic\_pointer\_cast](/libs/smart_ptr/shared_ptr.htm#dynamic_pointer_cast); + [enable\_shared\_from\_this](/libs/smart_ptr/enable_shared_from_this.html) + added; shared\_ptr::shared\_ptr(), shared\_ptr::reset(), weak\_ptr::weak\_ptr(), + weak\_ptr::reset() no longer throw; [get\_deleter](/libs/smart_ptr/shared_ptr.htm#get_deleter) + added; weak\_ptr::get() removed; make\_shared is now spelled [weak\_ptr::lock()](/libs/smart_ptr/weak_ptr.htm#lock) + ; [intrusive\_ptr documentation](/libs/smart_ptr/intrusive_ptr.html) + added; some experimental undocumented shared\_ptr features have been removed; + a [page describing some smart + pointer programming techniques](/libs/smart_ptr/sp_techniques.html) has been added. +* [boost/assert.hpp](/libs/utility/assert.html), [boost/current\_function.hpp](/libs/utility/current_function.html), + [boost/throw\_exception.hpp](/libs/utility/throw_exception.html), + [boost/checked\_delete.hpp](/libs/utility/checked_delete.html) + have been documented. +* [Date-Time Library](/libs/date_time/doc/index.html) - + several fixes and small additions including an interface change to partial\_date. + See the Date-Time Change History for more details. +* [Function Library](/libs/function/index.html) - added + support for assignment to zero (to clear) and comparison against zero (to + check if empty). +* [Operators Library](/libs/utility/operators.htm#symmetry) - + now takes advantage of named return value optimization (NRVO) when available, + from Daniel Frey. +* [Regression Tests](/status/compiler_status.html) - Much + expanded, plus a very nice [summary + page](http://boost.sourceforge.net/regression-logs/) from Rene Rivera. +* [Test Library](/libs/test/index.html) - introduced + following new facilities: + + Automatic registration of unit tests + + XML log format + + XML report format + + BOOST\_CHECK\_NO\_THROW test tool + + BOOST\_BITWISE\_CHECK test + tool + + For a complete list of changes see the Test Library [release + notes](/libs/test/doc/release_notes.html#v1_30_0). +* Many fixes and enhancements to other libraries. + + + + + + + + + + + diff --git a/users/history/version_1_30_1.html b/users/history/version_1_30_1.html new file mode 100644 index 0000000..9a85561 --- /dev/null +++ b/users/history/version_1_30_1.html @@ -0,0 +1,78 @@ +--- +title: Version 1.30.1 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.30.1 + +/\*\*/ + + + + + + + +Version 1.30.1 +============== + +Version 1.30.1 +-------------- + + +August 4th, 2003 12:00 GMT + + + This release was withdrawn on the 12 Aug 2003. + + Fixes were made to the following libraries: \* The [Boost.Lambda](/libs/lambda/doc/index.html) + ..library is now usable with gcc-2.95.2 \* [Boost.Spirit](/libs/spirit/index.html): + \* + Fixed. Using MSVC++6 (SP5), calling the assign action with a string value on + parsers using the file\_iterator will not work. \* Fixed: using assign semantic + action in a grammar with a multi\_pass iterator adaptor applied to an std::istream\_iterator + resulted in a failure to compile under msvc 7.0. \* Fixed: There is a bug in the + range\_run::set(range const& r) + function in "../boost/spirit/utility/impl/chset/range\_run.ipp". \* Fixed: + handling of trailing whitespace bug (ast\_parse/pt\_parse related) \* Fixed: comment\_p + and end of data bug \* Fixed: Most trailing space bug \* Fixed: `chset<>::operator ~(range<>)` + bug, `operator &(chset<>, range<>)` + bug, `operator &(range<>, chset<>)` + bug \* Fixed: `impl::detach\_clear` bug \* Fixed: mismatch closure + return type bug \* Fixed: `access\_node\_d[]` and `access\_match\_d[]` iterator bugs \* Fixed a bug regarding thread + safety of Phoenix/Spirit closures. \* The Boost Template [Metaprogramming + Library (MPL)](/libs/mpl/doc/index.html)'s ..typeof implementation is now compatible with Metrowerks + CodeWarrior Pro8. \* [Boost.Function](/libs/function/index.html): workaround + for the new Borland patch (version 0x564) and MSVC++ .NET 2003. \* [Boost.Config](/libs/config/index.html), [Boost.Format](/libs/format/doc/format.html), + and [Boost.Regex](/libs/regex/index.html) ..have been adjusted + to avoid warnings with GCC-3.3, and Boost.Format also now works with string types + other than `std::string`. \* [Smart + Pointers](/libs/smart_ptr/index.html): + \* `checked\_delete` + now works on more platforms \* Compatibility with the SunPro compiler \* Added + missing `#include`s. \* [Boost.Python](/libs/python/index.html): + \* warning suppression for + finicky compilers \* fixed a crashing bug in the `raw\_function` + facility when no keyword arguments were passed. \* Improved conversion of NULL + `shared\_ptr`s to Python. + + + + + + + + + + + + diff --git a/users/history/version_1_30_2.html b/users/history/version_1_30_2.html new file mode 100644 index 0000000..972d7c3 --- /dev/null +++ b/users/history/version_1_30_2.html @@ -0,0 +1,73 @@ +--- +title: Version 1.30.2 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.30.2 + +/\*\*/ + + + + + + + +Version 1.30.2 +============== + +Version 1.30.2 +-------------- + + +August 19th, 2003 12:00 GMT + +Downloads| Platform | File | +| unix | [boost\_1\_30\_2.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.30.2/boost_1_30_2.tar.bz2) | +| [boost\_1\_30\_2.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.30.2/boost_1_30_2.tar.gz) | +| windows | [boost\_1\_30\_2.zip](http://sourceforge.net/projects/boost/files/boost/1.30.2/boost_1_30_2.zip) | + +* [Boost Consulting](http://www.boost-consulting.com) is + now hosting Boost CVS mirrors - see our [download + page](/more/getting_started.html#CVS). +* Backported changes to the [config system](/libs/config/config.htm), + to better handle new compiler releases. +* Bugs in regression reporting in subproject tests were fixed. +* Tests are now run in the context of the user's PATH environment settings +* msvc-stlport and intel-win32-stlport toolsets now build static libraries + with multithreading enabled, to be compatible with the STLPort builds. +* intel-win32 toolset now handles `wchar\_t` + correctly when intel is installed over msvc6. +* Backported fixes from the main trunk which prevent errors building the [Boost.Test](/libs/test/doc/index.html) library in its default + configuration. +* Backported portability improvements for [checked\_delete](/libs/utility/checked_delete.html). +* Locale support for metrowerks (requiring a statically-linked runtime) is + more uniformly handled. +* Backported [conversion/lexical\_cast](/libs/conversion/lexical_cast.htm)'s + `wchar\_t` fixes from the main + trunk. +* intel-linux-tools: added rt to FINDLIBS in order to make + the `clock\_gettime()` + function available (backport of a patch in CVS HEAD). +* [regression/compiler\_status.cpp](/tools/regression/index.htm): + backported fixes in error log links generation. + + + + + + + + + + + diff --git a/users/history/version_1_31_0.html b/users/history/version_1_31_0.html new file mode 100644 index 0000000..b221597 --- /dev/null +++ b/users/history/version_1_31_0.html @@ -0,0 +1,169 @@ +--- +title: Version 1.31.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.31.0 + +/\*\*/ + + + + + + + +Version 1.31.0 +============== + +Version 1.31.0 +-------------- + + +January 26th, 2004 12:00 GMT + + +[Documentation](/doc/libs/1_31_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_31\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.31.0/boost_1_31_0.tar.bz2) | +| [boost\_1\_31\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.31.0/boost_1_31_0.tar.gz) | +| windows | [boost\_1\_31\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.31.0/boost_1_31_0.zip) | + + +### New License + A unified [Boost Software + License](/doc/libs/1_31_0/more/license_info.html) has been developed and will gradually replace the individual + licenses for most Boost libraries. The new license offers better legal protection + for both users and developers, and should speed user's legal reviews of Boost + libraries. Dave Abrahams led the Boost effort to develop better licensing. + The legal team was led by [Diane + Cabell](http://cyber.law.harvard.edu/people/cabell/index.html), Director, Clinical Programs, [Berkman + Center for Internet & Society](http://cyber.law.harvard.edu), Harvard Law School. [Devin + Smith](http://www.nixonpeabody.com/attorneys_detail1.asp?ID=121), attorney, [Nixon + Peabody LLP](http://www.nixonpeabody.com/default.asp), wrote the Boost License. Eva Chan, Harvard Law School, + contributed analysis of issues and drafts of various legal documents. + + Note: Many of the Boost libraries are still using earlier licenses, though + all conform to the [Boost + License Requirements](/doc/libs/1_31_0/more/lib_guide.htm#license). After this release we will begin an effort to + move toward uniform use of the new license. + + +### Build and Installation + + +* New [Getting Started](/doc/libs/1_31_0/more/getting_started.html) + procedures ease download and installation, from Rene Rivera and others. +* Improved support for libraries requiring [separate + compilation](/doc/libs/1_31_0/more/separate_compilation.html), from John Maddock and others. + +### New Libraries + + +* [enable\_if](/doc/libs/1_31_0/libs/utility/enable_if.html): Selective + inclusion of function template overloads, from Jaakko Jarvi, Jeremiah Willcock, + and Andrew Lumsdaine. This is an important new technique which exploits + the SFINAE (substitution-failure-is-not-an-error) principle. +* [Variant Library](/doc/libs/1_31_0/libs/variant/index.html): Safe, + generic, stack-based discriminated union container, from Eric Friedman + and Itay Maman. + +### Updated Libraries + + +* [Compose](/doc/libs/1_31_0/libs/compose/index.htm): This + library has been deprecated and will be removed in a future release. Use + [Bind](/doc/libs/1_31_0/libs/bind/bind.html) or [Lambda](/doc/libs/1_31_0/libs/lambda/doc/index.html) instead. +* [Date + Time Library](/doc/libs/1_31_0/libs/date_time/doc/index.html): A whole host of bug fixes, new features, and documentation + improvements. See the Date Time Change History for details. +* [Filesystem + Library](/doc/libs/1_31_0/libs/filesystem/doc/index.htm): + Several added functions, including improved checking for + directory and file name portability. +* [Iterator + Library](/doc/libs/1_31_0/libs/iterator/doc/index.html): Major version upgrade, with interface as proposed for the + C++ library TR, including an improved iterator\_adaptor + design plus several new components, from David Abrahams, Jeremy Siek, and + Thomas Witt. +* [MultiArray](/doc/libs/1_31_0/libs/multi_array/index.html): The + multi\_array class template now provides an element-preserving + resize operation as well as default construction (see the [reference + manual](/doc/libs/1_31_0/libs/multi_array/doc/reference.html) for more information). +* [Python Library](/doc/libs/1_31_0/libs/python/index.html): + + + Support for Python 2.3 and Intel C++ on Linux + + Container [Indexing + Suite](/doc/libs/1_31_0/libs/python/doc/v2/indexing.html) added. + + injected constructors and wrapped function objects. + + wrapping static data members. + + `std::wstring` conversions. + + Improved [keyword + arguments](/doc/libs/1_31_0/libs/python/doc/v2/args.html). + + Better error messages, including name demangling for GCC. + + Simpler [build + procedure](/doc/libs/1_31_0/libs/python/doc/building.html). + + *...and more....* +* [Random Number + Library](/doc/libs/1_31_0/libs/random/index.html): Interface changed to match the C++ [TR + proposal](/doc/libs/1_31_0/libs/random/wg21-proposal.html), from Jens Maurer. +* [Regex](/doc/libs/1_31_0/libs/regex/doc/index.html): Completely + new matching algorithm is now much faster than before, plus a selection + of [new features + and enhancements](/doc/libs/1_31_0/libs/regex/doc/history.html). +* [Boost.Spirit + 1.8.0](/doc/libs/1_31_0/libs/spirit/index.html): + + + Multiple grammar start rules + + Multiple Scanner rules (no more scanner business woes) + + More dynamic parsers + + Predefined actors + + Numerous bug fixes and QOI stuff + + *and more...* + + Starting from Spirit v1.8.0, ill conforming compilers will no longer be + supported. If you are still using one of these older compilers, please use + Spirit v1.6.x. See [@http://spirit.sf.net Spirit's Site] for more details. +* [Test Library](/doc/libs/1_31_0/libs/test/index.html): + + + Free function template based test case + + Custom exception translators support in execution monitor and + register\_exception\_translator added for unit test framework + + Added support for multi-module unit tests in automatic + registration facility + + Floating point comparison algorithm reworked (Is not backward + compatible!!!) + + Added support for custom users predicate returning both boolean + result code and possibly error message + + Documentation structure rework and update + + For a complete list of changes see the Test Library + [release notes](/doc/libs/1_31_0/libs/test/doc/release_notes.html#v1_31_0). + +### Miscellaneous + + +* Expanded testing and fixes for non-conforming compilers. +* Web site hosting now provided by [SourceForge](http://www.sourceforge.net/). + + + + + + + + + + + diff --git a/users/history/version_1_32_0.html b/users/history/version_1_32_0.html new file mode 100644 index 0000000..0cb5bd8 --- /dev/null +++ b/users/history/version_1_32_0.html @@ -0,0 +1,197 @@ +--- +title: Version 1.32.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.32.0 + +/\*\*/ + + + + + + + +Version 1.32.0 +============== + +Version 1.32.0 +-------------- + + +November 19th, 2004 12:00 GMT + + +[Documentation](/doc/libs/1_32_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_32\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.32.0/boost_1_32_0.tar.bz2) | +| [boost\_1\_32\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.32.0/boost_1_32_0.tar.gz) | +| windows | [boost\_1\_32\_0.exe](http://sourceforge.net/projects/boost/files/boost/1.32.0/boost_1_32_0.exe) | +| [boost\_1\_32\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.32.0/boost_1_32_0.zip) | + + +### Important + - New Toolset Names + The names of some the Boost.Build [toolsets](/doc/libs/1_32_0/more/getting_started.html#Tools) + have been changed to remove the "." (dot) character + and to fix some other naming inconsistencies. For example, vc7.1 + toolset was renamed to become vc-7\_1. Please refer to the + [Supported Toolsets](/doc/libs/1_32_0/more/getting_started.html#Tools) + section of the installation guide for the complete list of the current toolset + names. This change was made as a part of the effort to make the Boost distribution + compatible with ISO 9660 level 2 requirements. + + +### New Libraries + + +* [Assignment + Library](/doc/libs/1_32_0/libs/assign/index.html): Filling containers with constant or generated data has + never been easier, from Thorsten Ottosen. +* [Minmax + Library](/doc/libs/1_32_0/libs/algorithm/minmax/index.html): Standard library extensions for simultaneous min/max and + min/max element computations, from Herve Bronnimann. +* [Multi-index + Containers Library](/doc/libs/1_32_0/libs/multi_index/doc/index.html): Containers with multiple STL-compatible access + interfaces, from Joaquin M Lopez Munoz. +* [Numeric + Conversion Library](/doc/libs/1_32_0/libs/numeric/conversion/index.html): Optimized policy-based numeric conversions, + from Fernando Cacciola. +* [Program + Options Library](/doc/libs/1_32_0/doc/html/program_options.html): Access to configuration data given on command line, + in config files and other sources, from Vladimir Prus. +* [Range Library](/doc/libs/1_32_0/libs/range/index.html): a + new infrastructure for generic algorithms that builds on top of the new + iterator concepts, from Thorsten Ottosen. +* [Serialization + Library](/doc/libs/1_32_0/libs/serialization/doc/index.html): Serialization/de-serialization of arbitrary C++ data structures + to various formats including text, binary, and xml, from Robert Ramey. +* [String + Algorithms Library](/doc/libs/1_32_0/libs/algorithm/string/index.html): Collection of string related algorithms for + case conversion, trimming, find/replace operations and more, from Pavol + Droba. +* [Tribool](/doc/libs/1_32_0/doc/html/tribool.html): 3-state + boolean type library, from Doug Gregor. + +### Updated Libraries + + +* Compose: This deprecated library has been removed. +* [Graph](/doc/libs/1_32_0/libs/graph/index.html): + + + Added [bundled + properties](/doc/libs/1_32_0/libs/graph/doc/bundles.html) to the [`adjacency\_list`](/doc/libs/1_32_0/libs/graph/doc/adjacency_list.html) and [`adjacency\_matrix`](/doc/libs/1_32_0/libs/graph/doc/adjacency_matrix.html) class + templates, greatly simplifying the introduction of internal vertex + and edge properties. + + The [LEDA + graph adaptors](/doc/libs/1_32_0/libs/graph/doc/leda_conversion.html) have been ported to LEDA 4.5. + + Added algorithms for [betweenness + centrality](/doc/libs/1_32_0/libs/graph/doc/betweenness_centrality.html) and [betweenness + centrality clustering](/doc/libs/1_32_0/libs/graph/doc/bc_clustering.html). + + Added [circle + layout](/doc/libs/1_32_0/libs/graph/doc/circle_layout.html) and [undirected + spring layout](/doc/libs/1_32_0/libs/graph/doc/kamada_kawai_spring_layout.html) algorithms. +* [MPL Library](/doc/libs/1_32_0/libs/mpl/doc/index.html): + + + Updated to use the Boost Software License. + + New [documentation](/doc/libs/1_32_0/libs/mpl/doc/index.html), + including a complete [reference + manual.](/doc/libs/1_32_0/libs/mpl/doc/refmanual.html) + + Major interface changes and improvements, many of which are not backward + compatible. Please refer to the [1.32 + changelog](/doc/libs/1_32_0/libs/mpl/doc/tutorial/changes-in-boost-1-32-0.html) for the detailed information about upgrading to + the new version. +* [Python + Library](/doc/libs/1_32_0/libs/python/doc/index.html): + + + Updated to use the Boost Software License. + + a new, [better + method of wrapping classes with virtual functions](/doc/libs/1_32_0/libs/python/doc/tutorial/doc/html/python/exposing.html#python.class_virtual_functions) has been + implemented. + + Support for the new Python Bool type, thanks to Daniel Holth. + + Support for upcoming GCC symbol export control features have been + folded in, thanks to Niall Douglas. + + Improved support for `std::auto\_ptr`-like + types. + + Components used by other libraries have been moved out of python/detail + and into boost/detail to improve dependency relationships. + + Miscellaneous bug fixes and compiler workarounds. +* [Signals Library](/doc/libs/1_32_0/doc/html/signals.html): Introduced + deterministic slot ordering, permitting slots to be connected at the beginning + or end of slot groups or the slot list itself. Combiners may safely have + state and are accessible from the signal. +* [Utility](/doc/libs/1_32_0/libs/utility/utility.htm): class + template [result\_of](/doc/libs/1_32_0/libs/utility/utility.htm#result_of) + added. +* [Test Library](/doc/libs/1_32_0/libs/test/index.html): + + + namespace names gets shorten; old one still supported till next + release + + added proper encoding of XML PCDATA + + support for wide string comparison implemented + + For complete list of changes see Test Library + [release notes](/doc/libs/1_32_0/libs/test/doc/release_notes.html#v1_32_0). + +### Regression tests + This release has been extensively tested on a variety of different compilers + and platforms. It is known to contain no regressions against the previous reference + release on the compilers and configurations tested. Please refer to the corresponding + [regression + reports](http://www.meta-comm.com/engineering/boost-regression/1_32_0/index.html) to see how well your compiler performs on the new Boost codebase. + + +### Acknowledgements +![[]](http://boost.sourceforge.net/photos/aleksey_gurtovoy2.jpg) [Aleksey + Gurtovoy](/users/people/aleksey_gurtovoy.html) managed this release. [Managing + a release](/doc/libs/1_32_0/more/release_procedures.htm) at all is an enormous job, and Aleksey always goes beyond + merely meeting requirements by insisting on the highest possible quality. The + Boost membership owes him a debt of gratitude. + + This release wouldn't have been possible without the dedicated effort of many, + many members of the Boost community who generously contributed their outstanding + expertise, time and energy to making it happen. For patches, bug fixes, troubleshooting, + expert advice, and prompt responses to the release manager's requests we thank: + + David Abrahams, Misha Bergal, Jonathan Brandmeyer, Fernando Cacciola, Marshall + Clow, Christopher Currie, Pavol Droba, Caleb Epstein, Eric Friedman, Jeff Garland, + Michael Glassford, Doug Gregor, Joel de Guzman, Hubert Holin, Jaakko Jarvi, + Hartmut Kaiser, Bronek Kozicki, Tarjei Knapstad, Toon Knapen, Aaron W. LaFramboise, + Joaquin M Lopez Munoz, Christoph Ludwig, John Maddock, Paul Mensonides, Guillaume + Melquiond, Thorsten Ottosen, Vladimir Prus, Robert Ramey, Rene Rivera, Gennadiy + Rozental, Stefan Slapeta, Jonathan Turkanis, Pavel Vozenilek, Jonathan Wakely, + Daryle Walker, Victor A. Wagner Jr. and Martin Wille. + + Also, our special thanks go to: John Maddock for the managing the effort of + converting the majority of the Boost libraries to the [Boost + Software License](/doc/libs/1_32_0/more/license_info.html), Eric Niebler and Joel de Guzman for taking on the + important job of improving the Boost documentation's look and feel, and last, + but not least, to our regression test runners, without whom we simply would + never have released: Toon Knapen, Bronek Kozicki, Rene Rivera, Markus Schopflin, + Stefan Slapeta, Victor A. Wagner Jr. and Martin Wille. + + Thank you everybody! + + + + + + + + + + + + diff --git a/users/history/version_1_33_0.html b/users/history/version_1_33_0.html new file mode 100644 index 0000000..924d3bb --- /dev/null +++ b/users/history/version_1_33_0.html @@ -0,0 +1,244 @@ +--- +title: Version 1.33.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.33.0 + +/\*\*/ + + + + + + + +Version 1.33.0 +============== + +Version 1.33.0 +-------------- + + +August 11th, 2005 12:00 GMT + +Downloads| Platform | File | +| unix | [boost\_1\_33\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.33.0/boost_1_33_0.tar.bz2) | +| [boost\_1\_33\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.33.0/boost_1_33_0.tar.gz) | +| windows | [boost\_1\_33\_0.exe](http://sourceforge.net/projects/boost/files/boost/1.33.0/boost_1_33_0.exe) | +| [boost\_1\_33\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.33.0/boost_1_33_0.zip) | + + +### New Libraries + + +* [Iostreams + Library](/doc/libs/1_33_1/libs/iostreams/doc/index.html): + Framework for defining streams, stream buffers and i/o + filters, from Jonathan Turkanis. +* [Functional/Hash + Library](/doc/libs/1_33_1/libs/functional/hash/index.html): A TR1 hash function object that can be extended to hash + user defined types, from Daniel James. +* [Parameter + Library](/doc/libs/1_33_1/libs/parameter/doc/html/index.html): + Write functions that accept arguments by name: especially + useful when a function has more than one argument with a useful default + value, since named arguments can be passed in any order. +* [Pointer + Container Library](/doc/libs/1_33_1/libs/ptr_container/index.html): + Containers for storing heap-allocated polymorphic + objects to ease OO-programming, from Thorsten Ottosen. +* [Wave](/doc/libs/1_33_1/libs/wave/index.html): Standards + conformant implementation of the mandated C99/C++ preprocessor functionality + packed behind an easy to use iterator interface, from Hartmut Kaiser. + +### Updated Libraries + + +* [Any Library](/doc/libs/1_33_1/doc/html/any.html): `any\_cast` has been enhanced to allow direct + access to `any`'s held value. +* [Assignment + Library](/doc/libs/1_33_1/libs/assign/doc/index.html): Support for [Pointer + Container Library](/doc/libs/1_33_1/libs/ptr_container/index.html) and new efficient functions `ref\_list\_of()` and `cref\_list\_of()` for generating anonymous ranges. +* [Bind Library](/doc/libs/1_33_1/libs/bind/bind.html): Bind + expressions now support [comparisons + and negation](/doc/libs/1_33_1/libs/bind/bind.html#operators). Example: `bind(&X::name, \_1) < bind(&X::name, \_2)`. +* [Date-Time + Library](/doc/libs/1_33_1/doc/html/date_time.html): + + + Added [local + time and time zone classes](/doc/libs/1_33_1/doc/html/date_time/local_time.html). + + Added [format-based + Input/Output facets](/doc/libs/1_33_1/doc/html/date_time/date_time_io.html). + + For a complete list of changes, see the library [change + history](/doc/libs/1_33_1/doc/html/date_time/details.html#date_time.changes). +* [Graph Library](/doc/libs/1_33_1/libs/graph/doc/index.html): Introduced + several new algorithms and improved existing algorithms: + + + [Experimental + Python bindings](/doc/libs/1_33_1/libs/graph/doc/python.html), from Doug Gregor and Indiana University. + + [`floyd warshall + all pairs + shortest paths`](/doc/libs/1_33_1/libs/graph/doc/floyd_warshall_shortest.html), + from Lauren Foutz and Scott Hill. + + [`astar search`](/doc/libs/1_33_1/libs/graph/doc/astar_search.html), + from Kristopher Beevers and Jufeng Peng. + + [`fruchterman reingold + force directed + layout`](/doc/libs/1_33_1/libs/graph/doc/fruchterman_reingold.html), from Doug + Gregor and Indiana University. + + [`biconnected components` + and `articulation points`](/doc/libs/1_33_1/libs/graph/doc/biconnected_components.html), from Jeremy Siek, + Janusz Piwowarski, and Doug Gregor. + + [`sequential vertex + coloring`](/doc/libs/1_33_1/libs/graph/doc/sequential_vertex_coloring.html) has been + updated, tested, and documented. + + [`gursoy atun + layout`](/doc/libs/1_33_1/libs/graph/doc/gursoy_atun_layout.html), from Jeremiah + Willcock and Doug Gregor of Indiana University. + + [`king ordering`](/doc/libs/1_33_1/libs/graph/doc/king_ordering.html), + from D. Kevin McGrath of Indiana University. + + [`cuthill mckee + ordering`](/doc/libs/1_33_1/libs/graph/doc/cuthill_mckee_ordering.html) has been + recast as an invocation of `breadth + first search` + and now supports graphs with multiple components. + + [`dijkstra shortest + paths`](/doc/libs/1_33_1/libs/graph/doc/dijkstra_shortest_paths.html) now uses + a relaxed heap [[61](/doc/libs/1_33_1/libs/graph/doc/bibliography.html#driscoll88)] + as its priority queue, improving its complexity to O(V log V) and + improving real-world performance for larger graphs. + + [`read graphviz`](/doc/libs/1_33_1/libs/graph/doc/read_graphviz.html) + now has a new, Spirit-based parser that works for all graph types + and supports arbitrary properties on the graph, from Ron Garcia. + The old, Bison-based GraphViz reader has been deprecated and will + be removed in a future Boost release. [`write graphviz`](/doc/libs/1_33_1/libs/graph/doc/write-graphviz.html) + also supports dynamic properties. + + [`subgraph`](/doc/libs/1_33_1/libs/graph/doc/subgraph.html): `get\_property` now refers to the + subgraph property, not the root graph's property. + + See the [history](/doc/libs/1_33_1/libs/graph/doc/history.html#by-version) + for additional changes and bug fixes. +* [Multi-index + Containers Library](/doc/libs/1_33_1/libs/multi_index/doc/index.html): + + + New [hashed + indices](/doc/libs/1_33_1/libs/multi_index/doc/tutorial/indices.html#hashed_indices). + + Added [serialization + support](/doc/libs/1_33_1/libs/multi_index/doc/tutorial/creation.html#serialization). + + For a complete list of changes, see the library [release + notes](/doc/libs/1_33_1/libs/multi_index/doc/release_notes.html). +* [Program + Options Library](/doc/libs/1_33_1/libs/program_options/doc/index.html): + + + Option descriptions are now printed with word wrapping. + + Command line parser can bypass unregistered options, instread of + throwing. + + Removed support for "implicit" (optional) values. + + New customization method 'command\_line\_parser::extra\_style\_parser'. + Unlike 'additional\_parser', allows the user to parse several tokens + and return a vector of options, not just a single option. + + Work with disabled exceptions. +* [Property + Map Library](/doc/libs/1_33_1/libs/property_map/property_map.html): Introduced the [`dynamic properties`](/doc/libs/1_33_1/libs/property_map/doc/dynamic_property_map.html) + class, which provides dynamically-typed access to a set of property maps. +* [Boost.Python](/doc/libs/1_33_1/libs/python/doc/index.html): + + + Added support for docstrings on nonstatic properties. + + We now export the client-provided docstrings for `init >` + and *XXX*`\_FUNCTION\_OVERLOADS()` for only the last overload. + + Support for Embedded VC++ 4 and GCC-3.3 on MacOS added + + Introduced better support for rvalue from-python conversions of shared\_ptr. + + Support for exposing `vector` with the indexing suite. + + updated visual studio project build file. + + Added search feature to the index page. +* [Random Number + Library](/doc/libs/1_33_1/libs/random/index.html): + Improved initialization for `mersenne\_twister`, + algorithm by Makoto Matsumoto and Takuji Nishimura, implemented for Boost + by Jens Maurer. + + +Note: All test vectors for `mersenne\_twister`s + constructed or seeded without parameters or with a single `unsigned int` + parameter become invalid. +* [Range Library](/doc/libs/1_33_1/libs/range/index.html): Minor + addition of convenience functions to `iterator +range` like `front(), back()` and `operator[]()`. +* [Regex Library](/doc/libs/1_33_1/libs/regex/index.html): + + + Rewritten front end parser now supports (?imsx-imsx) constructs, + plus lookbehind assertions and conditional expressions. + + Thin wrapper classes improve integration with MFC/ATL code. + + Full (optional) Unicode support via the ICU library. Refer to the + [regex history + page](/doc/libs/1_33_1/libs/regex/doc/history.html) for more information on these and other small changes. +* [Serialization + Library](/doc/libs/1_33_1/libs/serialization/doc/index.html): + + + DLL version. + + Auto-linking. + + Serialization of variants. + + Improved serialization of shared pointers. +* [Signals Library](/doc/libs/1_33_1/doc/html/signals.html): added + slot blocking/unblocking, from Frantz Maerten. Huge improvements to signal + invocation performance from Robert Zeh. + +### Supported Compilers + Boost is tested on a wide range of compilers and platforms. Since Boost libraries + rely on modern C++ features not available in all compilers, not all Boost libraries + will work with every compiler. The following compilers and platforms have been + extensively tested with Boost, although many other compilers and platforms + will work as well. For more information, see the [regression + test results](https://www.boost.org/regression/release/user/). + + + +* [Apple GCC](http://developer.apple.com/) 3.x on Mac OS + X. +* [Borland C++](http://www.codegear.com/products/cppbuilder) + 5.6.4 on Windows. +* [GNU C++](http://gcc.gnu.org) 2.95.3 (with and without + STLport), 3.2.x., 3.3.x, 3.4.x, 4.0.x on Windows, Linux and Solaris. +* [Intel + C++](http://www.intel.com/cd/software/products/asmo-na/eng/compilers/index.htm) 8.1, 9.0 on Windows, Linux. +* [Metrowerks CodeWarrior](http://www.metrowerks.com) 8.3, + 9.4, 9.5 on Mac OS X and Windows. +* [Microsoft Visual C++](http://msdn.microsoft.com/visualc/) + 6.0 (sp5, with and without STLport), 7.0, 7.1, 8.0 beta. Note: due to intermittent + problems with Visual C++ 8.0 beta, and the presence of a variety of pre-release + compiler builds, we are unable to guarantee compatibility until the final + compiler is released. + +### Acknowledgements +![[]](/gfx/boost_1_33_0.jpg)[Douglas Gregor](/users/people/doug_gregor.html) + managed this release. + + A great number of people contributed their time and expertise to make this + release possible. Special thanks go to Aleksey Gurtovoy and Misha Bergal, who + managed to keep the regression testing system working throughout the release + process; David Abrahams, Beman Dawes, Aleksey Gurtovoy, Rene Rivera and Jonathan + Turkanis for greatly improving the quality of this release; Rene Rivera for + the new Boost web page design; and Zoltan "cad" Juhasz for the new + Boost logo. + + + + + + + + + + + + + diff --git a/users/history/version_1_33_1.html b/users/history/version_1_33_1.html new file mode 100644 index 0000000..27aff21 --- /dev/null +++ b/users/history/version_1_33_1.html @@ -0,0 +1,171 @@ +--- +title: Version 1.33.1 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.33.1 + +/\*\*/ + + + + + + + +Version 1.33.1 +============== + +Version 1.33.1 +-------------- + + +December 5th, 2006 12:00 GMT + + +[Documentation](/doc/libs/1_33_1/) + + +Downloads| Platform | File | +| unix | [boost\_1\_33\_1.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.33.1/boost_1_33_1.tar.bz2) | +| [boost\_1\_33\_1.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.33.1/boost_1_33_1.tar.gz) | +| windows | [boost\_1\_33\_1.exe](http://sourceforge.net/projects/boost/files/boost/1.33.1/boost_1_33_1.exe) | +| [boost\_1\_33\_1.zip](http://sourceforge.net/projects/boost/files/boost/1.33.1/boost_1_33_1.zip) | + + +### Updated Libraries + + +* [Any Library](/doc/libs/1_33_1/doc/html/any.html): Cast + to reference types introduced in 1.33.0 is now documented on `any\_cast` documentation page. +* [Bind Library](/doc/libs/1_33_1/libs/bind/bind.html): Bind + expressions now support [comparisons + and negation](/doc/libs/1_33_1/libs/bind/bind.html#operators). Example: `bind(&X::name, \_1) < bind(&X::name, \_2)`. +* [Config Library](/doc/libs/1_33_1/libs/config/index.html): Don't + undef `BOOST\_LIB\_TOOLSET` + after use. +* [Boost.Python](/doc/libs/1_33_1/libs/python/doc/index.html): + + + The build now assumes Python 2.4 by default, rather than 2.2 + + Support Python that's built without Unicode support + + Support for wrapping classes with overloaded address-of (`&`) operators +* [Smart Pointer + Library](/doc/libs/1_33_1/libs/smart_ptr/index.html): Fixed problems under Metrowerks CodeWarrior on PowerPC + (Mac OS X) with inlining on, GNU GCC on PowerPC 64. +* [Regex Library](/doc/libs/1_33_1/libs/regex/doc/index.html): Fixed + the supplied makefiles, and other small compiler specific changes. Refer + to the [regex + history page](/doc/libs/1_33_1/libs/regex/doc/history.html) for more information on these and other small changes. +* [Iostreams + Library](/doc/libs/1_33_1/libs/iostreams/doc/index.html): + Improved the interface for accessing a chain's components, + added `is\_open` members to + the file and file descriptor devices, fixed memory-mapped files on Windows, + and made minor changes to the documentation. +* [Boost.Python](/doc/libs/1_33_1/libs/python/doc/index.html): + + + Added support for docstrings on nonstatic properties. + + We now export the client-provided docstrings for `init >` + and *XXX*`\_FUNCTION\_OVERLOADS()` for only the last overload. + + Support for Embedded VC++ 4 and GCC-3.3 on MacOS added + + Introduced better support for rvalue from-python conversions of shared\_ptr. + + Support for exposing `vector` with the indexing suite. + + updated visual studio project build file. + + Added search feature to the index page. +* [Functional/Hash + Library](/doc/libs/1_33_1/libs/functional/hash/index.html): + Fixed the points example. +* [Multi-index + Containers Library](/doc/libs/1_33_1/libs/multi_index/doc/index.html): + Fixed a problem with multithreaded code, and + other minor changes. Refer to the library [release + notes](/doc/libs/1_33_1/libs/multi_index/doc/release_notes.html#boost_1_33_1) for further details. +* [Graph + Library](/doc/libs/1_33_1/libs/graph/doc/table_of_contents.html): + + + Fixed a problem with the relaxed heap on x86 Linux (fixes bug in + `dijkstra\_shortest\_paths`). + + Fixed problems with [`cuthill\_mckee\_ordering`](/doc/libs/1_33_1/libs/graph/doc/cuthill_mckee_ordering.html) + and [`king\_ordering`](/doc/libs/1_33_1/libs/graph/doc/king_ordering.html) producing + no results. + + Added `color\_map` parameter + to `dijkstra\_shortest\_paths`. +* [Signals + Library](/doc/libs/1_33_1/libs/signals/doc/index.html): Fixed problems with the use of Signals across shared library + boundaries. +* [Thread + library](/doc/libs/1_33_1/libs/thread/doc/index.html): +`read\_write\_mutex` + has been removed due to problems with deadlocks. +* [Wave library](/doc/libs/1_33_1/libs/wave/index.html) + (V1.2.1): Fixed a couple of problems, refer to the [change + log](/doc/libs/1_33_1/libs/wave/ChangeLog) for further details. + +### Supported Compilers + Boost is tested on a wide range of compilers and platforms. Since Boost libraries + rely on modern C++ features not available in all compilers, not all Boost libraries + will work with every compiler. The following compilers and platforms have been + extensively tested with Boost, although many other compilers and platforms + will work as well. For more information, see the [regression + test results](https://www.boost.org/regression/release/user/). + +*New for this release*: Support for building with the newest + STLport-5.0 was added. The support includes building with MinGW Runtime 3.8 + plus STLport-5.0 improved to support wide character operations. Apple GCC 4.0, + HP Tru64 C++, and Microsoft Visual C++ 8.0 are supported platforms. We have + added an experimental autoconf-like configure script for + Unix-like systems: run configure --help for more information. + + + +* [Apple GCC](http://developer.apple.com/) 3.3, 4.0 on + Mac OS X. +* [Borland C++](http://www.codegear.com/products/cppbuilder) + 5.6.4 on Windows. +* [GNU C++](http://gcc.gnu.org) 2.95.3 (with and without + STLport), 3.2.x., 3.3.x, 3.4.x, 4.0.x on Windows, Linux and Solaris. +* [HP C++ for Tru64 UNIX 7.1](http://h30097.www3.hp.com/cplus/). +* [Intel + C++](http://www.intel.com/cd/software/products/asmo-na/eng/compilers/index.htm) 8.1, 9.0 on Windows, Linux. +* [Metrowerks CodeWarrior](http://www.metrowerks.com) 8.3, + 9.4, 9.5 on Mac OS X and Windows. +* [Microsoft Visual C++](http://msdn.microsoft.com/visualc/) + 6.0 (sp5, with and without STLport), 7.0, 7.1, 8.0. Note: Boost does not + support the non-standard "Safe" C++ Library shipping with Visual + C++ 8.0, which may result in many spurious warnings from Boost headers + and other standards-conforming C++ code. To suppress these warnings, define + the macro `\_SCL\_SECURE\_NO\_DEPRECATE`. + +### Acknowledgements +![Medieval Mr. Gregor](/gfx/boost_1_33_0.jpg) +[Douglas + Gregor](/users/people/doug_gregor.html) managed this release. + + A great number of people contributed their time and expertise to make this + release possible. Special thanks go to Aleksey Gurtovoy and Misha Bergal, who + managed to keep the regression testing system working throughout the release + process; David Abrahams, Beman Dawes, Aleksey Gurtovoy, Bronek Kozicki, Rene + Rivera and Jonathan Turkanis for greatly improving the quality of this release; + Rene Rivera for the new Boost web page design; and Zoltan "cad" Juhasz + for the new Boost logo. + + + + + + + + + + + + diff --git a/users/history/version_1_34_0.html b/users/history/version_1_34_0.html new file mode 100644 index 0000000..1c3db98 --- /dev/null +++ b/users/history/version_1_34_0.html @@ -0,0 +1,318 @@ +--- +title: Version 1.34.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.34.0 + +/\*\*/ + + + + + + + +Version 1.34.0 +============== + +Version 1.34.0 +-------------- + + +May 12th, 2007 12:00 GMT + + +[Documentation](/doc/libs/1_34_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_34\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.34.0/boost_1_34_0.tar.bz2) | +| [boost\_1\_34\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.34.0/boost_1_34_0.tar.gz) | +| windows | [boost\_1\_34\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.34.0/boost_1_34_0.zip) | + + +### New Libraries + + +* [Foreach Library](/doc/libs/1_34_0/doc/html/foreach.html): `BOOST\_FOREACH` macro for easily iterating + over the elements of a sequence, from Eric Niebler. +* [Statechart + Library](/doc/libs/1_34_0/libs/statechart/doc/index.html): + Arbitrarily complex finite state machines can be implemented + in easily readable and maintainable C++ code, from Andreas Huber. +* [TR1 Library](/doc/libs/1_34_0/libs/tr1/index.html): An + implementation of the C++ Technical Report on Standard Library Extensions, + from John Maddock. This library does not itself implement the TR1 components, + rather it's a thin wrapper that will include your standard library's TR1 + implementation (if it has one), otherwise it will include the Boost Library + equivalents, and import them into namespace `std::tr1`. + Highlights include: Reference Wrappers, Smart Pointers, result\_of, Function + Object Binders, Polymorphic function wrappers, Type Traits, Random Number + Generators and Distributions, Tuples, Fixed Size Array, Hash Function Objects, + Regular Expressions, and Complex Number Additional Algorithms. +* [Typeof Library](/doc/libs/1_34_0/doc/html/typeof.html): Typeof + operator emulation, from Arkadiy Vertleyb and Peder Holt. +* [Xpressive + Library](/doc/libs/1_34_0/doc/html/xpressive.html): Regular expressions that can be written as strings or as + expression templates, and that can refer to each other and themselves recursively + with the power of context-free grammars, from Eric Niebler. + +### Updated Libraries + + +* [Assign Library](/doc/libs/1_34_0/libs/assign/index.html): + + + Support for `ptr\_map` via the new function `ptr\_map\_insert()` + + Support for initialization of [Pointer + Containers](/doc/libs/1_34_0/libs/ptr_container/index.html) when the containers hold pointers to an abstract + base class. +* [Date\_time + library](/doc/libs/1_34_0/doc/html/date_time.html): + + + Support for new US/Canada timezone rules and other bug fixes. See + [Change + History](/doc/libs/1_34_0/doc/html/date_time/details.html#changes) for details. +* [Filesystem + Library](/doc/libs/1_34_0/libs/filesystem/doc/index.htm): Major upgrade in preparation for submission to the C++ + Standards Committee for TR2. Changes include: + + + [Internationalization](/doc/libs/1_34_0/libs/filesystem/doc/i18n.html#Internationalization), + provided by class templates *basic\_path*, *basic\_filesystem\_error*, + *basic\_directory\_iterator*, and *basic\_directory\_entry*. + + [Simplification](/doc/libs/1_34_0/libs/filesystem/doc/i18n.html#Simplification) + of the path interface by eliminating special constructors to identify + native formats. + + [Rationalization](/doc/libs/1_34_0/libs/filesystem/doc/i18n.html#Rationalization) + of predicate function design, including the addition of several new + functions. + + Clearer specification by reference to [POSIX](/doc/libs/1_34_0/libs/filesystem/doc/design.htm#POSIX-01), + the ISO/IEEE Single Unix Standard, with provisions for Windows and + other operating systems. + + [Preservation](/doc/libs/1_34_0/libs/filesystem/doc/i18n.html#Preservation) + of existing user code whenever possible. + + [More + efficient](/doc/libs/1_34_0/libs/filesystem/doc/i18n.html#More_efficient) directory iteration. + + Addition of a [recursive + directory iterator](/doc/libs/1_34_0/libs/filesystem/doc/tr2_proposal.html#Class-template-basic_recursive_directory_iterator). +* [Function + Library](/doc/libs/1_34_0/libs/function/index.html): + Boost.Function now implements a small buffer optimization, + which can drastically improve the performance when copying or constructing + Boost.Function objects storing small function objects. For instance, `bind(&X:foo, &x, \_1, \_2)` requires no heap allocation when placed + into a Boost.Function object. +* [Functional/Hash + Library](/doc/libs/1_34_0/libs/functional/hash/index.html): + + + Use declarations for standard classes, so that the library doesn't + need to include all of their headers + + Deprecated the + headers. + + Add support for the `BOOST\_HASH\_NO\_EXTENSIONS` + macro, which disables the extensions to TR1 + + Minor improvements to the hash functions for floating point numbers. +* [Graph Library](/doc/libs/1_34_0/libs/graph/doc/index.html): + + + [`edmonds\_maximum\_cardinality\_matching`](/doc/libs/1_34_0/libs/graph/doc/maximum_matching.html), + from Aaron Windsor. + + [`lengauer\_tarjan\_dominator\_tree`](/doc/libs/1_34_0/libs/graph/doc/lengauer_tarjan_dominator.htm), + from JongSoo Park. + + [`compressed\_sparse\_row\_graph`](/doc/libs/1_34_0/libs/graph/doc/compressed_sparse_row.html), + from Jeremiah Willcock and Douglas Gregor of Indiana University. + + [`sorted\_erdos\_renyi\_iterator`](/doc/libs/1_34_0/libs/graph/doc/sorted_erdos_renyi_gen.html), + from Jeremiah Willcock of Indiana University. + + [`biconnected\_components`](/doc/libs/1_34_0/libs/graph/doc/biconnected_components.html) + now supports a visitor and named parameters, from Janusz Piwowarski. + + [`adjacency\_matrix`](/doc/libs/1_34_0/libs/graph/doc/adjacency_matrix.html) now models + the [Bidirectional + Graph](/doc/libs/1_34_0/libs/graph/doc/BidirectionalGraph.html) concept. + + [`dijkstra\_shortest\_paths`](/doc/libs/1_34_0/libs/graph/doc/dijkstra_shortest_paths.html) + now calls `vis.initialize\_vertex` for each vertex + during initialization. + + *Note:* the name of the compiled library for the + [GraphViz + reader](/doc/libs/1_34_0/libs/graph/doc/read_graphviz.html) has changed to boost\_graph (from + bgl-viz) to match Boost conventions. + + See the [complete + revision history](/doc/libs/1_34_0/libs/graph/doc/history.html#1.34.0) for more information. +* [MultiArray + Library](/doc/libs/1_34_0/libs/multi_array/index.html): + Boost.MultiArray now by default provides range-checking + for `operator[]`. + Range checking can be disabled by defining the macro `BOOST\_DISABLE\_ASSERTS` + before including multi\_array.hpp. A bug in `multi\_array::resize()` + related to storage orders was fixed. +* [Multi-index + Containers Library](/doc/libs/1_34_0/libs/multi_index/doc/index.html): + + + New [random + access indices](/doc/libs/1_34_0/libs/multi_index/doc/tutorial/indices.html#rnd_indices). + + Non key-based indices feature new [rearrange + facilities](/doc/libs/1_34_0/libs/multi_index/doc/tutorial/indices.html#rearrange). + + This version also includes a number of optimizations and usage improvements. + For a complete list of changes, see the library [release + notes](/doc/libs/1_34_0/libs/multi_index/doc/release_notes.html#boost_1_34). +* [Optional + Library](/doc/libs/1_34_0/libs/optional/index.html): + + + `boost::none\_t and + boost::none` now added to Optional's documentation + + Relational operators now directly support arguments of type `'T'` and `'none\_t'` + + operator->() now also works with reference types. + + Helper functions `make\_optional(val), make\_optional(cond,val) and get\_optional\_value\_or(opt,alternative\_value)` + added. + + Constructor taking a boolean condition (as well as a value) added. + + Member function `get\_value\_or(alternative\_value)` added. + + Incompatbility bug with mpl::apply<> fixed. + + Converting assignment bug with uninitialized lvalues fixed. +* [Parameter + Library](/doc/libs/1_34_0/libs/parameter/index.html): + + + Every ArgumentPack is now a valid [MPL + Forward Sequence.](/doc/libs/1_34_0/libs/mpl/doc/refmanual/forward-sequence.html) + + Support for unnamed arguments (those whose keyword is deduced from + their types) is added. + + Support for named and unnamed template arguments is added. + + New overload generation macros solve the [forwarding + problem](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm) directly. + + See also the Python library changes, below. +* [Pointer + Container Library](/doc/libs/1_34_0/libs/ptr_container/index.html): + + + Support for serialization via [Boost.Serialization.](/doc/libs/1_34_0/libs/serialization/index.html) + + Exceptions can be disabled by defining the macro BOOST\_PTR\_CONTAINER\_NO\_EXCEPTIONS + before including any header. This macro is defined by default if + BOOST\_NO\_EXCEPTIONS is defined. + + Additional `std::auto\_ptr` + overloads added s.t. one can also pass `std::auto\_ptr` instead of only `T\*` + arguments to member functions. + + `transfer()` + now has weaker requirements s.t. one can transfer objects from `ptr\_container` + to `ptr\_container`, +* [Python Library](/doc/libs/1_34_0/libs/python/index.html): + + + Boost.Python now automatically appends C++ signatures to docstrings. + The new [docstring\_options.hpp](/doc/libs/1_34_0/libs/python/doc/v2/docstring_options.html) + header is available to control the content of docstrings. + + [`stl\_input\_iterator`](/doc/libs/1_34_0/libs/python/doc/v2/stl_iterator.html#stl_input_iterator-spec), for + turning a Python iterable object into an STL input iterator, from + Eric Niebler. + + Support for `void\*` + conversions is added. + + Integrated support for wrapping C++ functions built with the parameter + library; keyword names are automatically known to docsstrings. + + Enhancements to the API for better embedding support (`boost::python::import()`, + `boost::python::exec()`, + and `boost::python::exec\_file()`). +* [Signals Library](/doc/libs/1_34_0/doc/html/signals.html): More + improvements to signal invocation performance from Robert Zeh. +* [Smart + Pointers Library](/doc/libs/1_34_0/libs/smart_ptr/smart_ptr.htm): + + + [Allocator + support](/doc/libs/1_34_0/libs/smart_ptr/shared_ptr.htm#allocator_constructor) as proposed in [N1851](http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1851.pdf) + (162 Kb PDF). + + [`pointer\_cast`](/doc/libs/1_34_0/libs/smart_ptr/pointer_cast.html) and [`pointer\_to\_other`](/doc/libs/1_34_0/libs/smart_ptr/pointer_to_other.html) utilities + to allow pointer-independent code, from Ion Gaztanaga. +* [String + Algorithm Library](/doc/libs/1_34_0/libs/algorithm/string/index.html): + + + `lexicographical\_compare` + + `join` + + New comparison predicates `is\_less`, + `is\_not\_greater`. + + Negative indexes support (like Perl) in various algorihtms (`\*\_head/tail`, + `\*\_nth`). +* [Wave Library](/doc/libs/1_34_0/libs/wave/index.html): + + + Wave now correctly recognizes pp-number tokens as mandated by the + C++ Standard, which are converted to C++ tokens right before they + are returned from the library. + + Several new preprocessing hooks have been added. For a complete description + please refer to the related documentation page: [The + Context Policy](/doc/libs/1_34_0/libs/wave/doc/class_reference_ctxpolicy.html). + + Shared library (dll) support has been added for the generated Wave + libraries. + + The overall error handling has been improved. It is now possible + to recover and continue after an error or a warning was issued. + + Support for optional comment and/or full whitespace preservation + in the generated output stream has been added. + + The Wave library now performs automatic include guard detection to + avoid accessing header files more than once, if appropriate. + + Full interactive mode has been added to the Wave tool. Now the Wave + tool can be used just like Python or Perl for instance to interactively + try out your BOOST\_PP macros. Additionally it is now possible to + load and save the current state of an interactive session (macro + tables et.al.). + + The overall performance has been improved by upto 40-60%, depending + on the concrete files to process. + + Support for new pragmas has been added allowing to control certain + library features from inside the preprocessed sources (partial output + redirection, control of generated whitespace and #line directives). + + Optional support for #pragma message "..." has been added. + + This version also includes a number of bug fixes and usage improvements. + For a complete list of changes, see the libraries [change + log](/doc/libs/1_34_0/libs/wave/ChangeLog). + +### Supported Compilers + Boost is tested on a wide range of compilers and platforms. Since Boost libraries + rely on modern C++ features not available in all compilers, not all Boost libraries + will work with every compiler. The following compilers and platforms have been + extensively tested with Boost, although many other compilers and platforms + will work as well. For more information, see the [regression + test results](https://www.boost.org/regression/release/user/). + + + +* [Apple GCC](http://developer.apple.com/) 4.0.1 on Mac + OS X. +* [Borland C++](http://www.codegear.com/products/cppbuilder) + 5.8.2 on Windows. +* [GNU C++](http://gcc.gnu.org/) + + + 3.2.x., 3.3.x, 3.4.x, 4.0.x, 4.1.x on Linux + + 4.1.x on Solaris + + 3.4.x on Windows +* [HP aC++ A.06.14](http://h30097.www3.hp.com/cplus/). +* [Intel + C++](http://www.intel.com/cd/software/products/asmo-na/eng/compilers/index.htm) 9.1 on Windows, 9.0 on Linux. +* [Metrowerks CodeWarrior](http://www.metrowerks.com/) + 9.4 on Windows. +* [Microsoft Visual C++](http://msdn.microsoft.com/visualc/) + 6.0 (sp5, with and without STLport), 7.0, 7.1, 8.0. Note: Boost does not + support the non-standard "Safe" C++ Library shipping with Visual + C++ 8.0, which may result in many spurious warnings from Boost headers + and other standards-conforming C++ code. To suppress these warnings, define + the macro `\_SCL\_SECURE\_NO\_DEPRECATE`. +* [Sun + Studio 11](http://developers.sun.com/sunstudio/compilers_index.html) on Solaris. + +### Acknowledgements +[Thomas Witt](/users/people/thomas_witt.html) managed this + release. + + A great number of people contributed their time and expertise to make this + release possible. Special thanks go to Vladimir Prus for making Boost.Build + version 2 a reality, David Abrahams for authoring a new getting started guide + and Greg D. for answering countless questions. + + + + + + + + + + + + diff --git a/users/history/version_1_34_1.html b/users/history/version_1_34_1.html new file mode 100644 index 0000000..b05bf8f --- /dev/null +++ b/users/history/version_1_34_1.html @@ -0,0 +1,104 @@ +--- +title: Version 1.34.1 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.34.1 + +/\*\*/ + + + + + + + +Version 1.34.1 +============== + +Version 1.34.1 +-------------- + + +July 24th, 2007 12:00 GMT + + +[Documentation](/doc/libs/1_34_1/) + + +Downloads| Platform | File | +| unix | [boost\_1\_34\_1.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.34.1/boost_1_34_1.tar.bz2) | +| [boost\_1\_34\_1.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.34.1/boost_1_34_1.tar.gz) | +| windows | [boost\_1\_34\_1.7z](http://sourceforge.net/projects/boost/files/boost/1.34.1/boost_1_34_1.7z) | +| [boost\_1\_34\_1.zip](http://sourceforge.net/projects/boost/files/boost/1.34.1/boost_1_34_1.zip) | + + + This is a bug fix release addressing many problems with the 1.34.0 release. It + is a recommended upgrade for all users of Boost 1.34.0. For a complete list of + fixes see [Boost + Trac](http://svn.boost.org/trac/boost/query?status=closed&milestone=Boost+1.34.1). + +### Supported Compilers + New in this release is improved support for the IBM XL C/C++ compiler. + + Boost is tested on a wide range of compilers and platforms. Since Boost libraries + rely on modern C++ features not available in all compilers, not all Boost libraries + will work with every compiler. New in this release The following compilers + and platforms have been extensively tested with Boost, although many other + compilers and platforms will work as well. For more information, see the [regression test results](https://www.boost.org/regression/release/user/). + + + +* [Apple GCC](http://developer.apple.com/) 4.0.1 on Mac + OS X. +* [Borland C++](http://www.codegear.com/products/cppbuilder) + 5.8.2 on Windows. +* [GNU C++](http://gcc.gnu.org/) + + + 3.2.x., 3.3.x, 3.4.x, 4.0.x, 4.1.x on Linux + + 4.1.x on Solaris + + 3.4.x on Windows +* [HP C++ for Tru64 UNIX 7.1](http://h30097.www3.hp.com/cplus/). +* [HP aC++ A.06.14](http://www.hp.com/go/c++). +* [Intel + C++](http://www.intel.com/cd/software/products/asmo-na/eng/compilers/index.htm) 9.1 on Windows, 9.0 on Linux. +* [Metrowerks CodeWarrior](http://www.metrowerks.com/) + 9.4 on Windows. +* [Microsoft Visual C++](http://msdn.microsoft.com/visualc/) + 6.0 (sp5, with and without STLport), 7.0, 7.1, 8.0. Note: Boost does not + support the non-standard "Safe" C++ Library shipping with Visual + C++ 8.0, which may result in many spurious warnings from Boost headers + and other standards-conforming C++ code. To suppress these warnings, define + the macro `\_SCL\_SECURE\_NO\_DEPRECATE`. +* [Sun Studio 11](http://developers.sun.com/sunstudio/index.jsp) + on Solaris. + +### Acknowledgements +[Thomas Witt](/users/people/thomas_witt.html) managed this + release. + + A great number of people contributed their time and expertise to make this + release possible. Special thanks go to Kim Barrett consolidating Boost.Iostreams + changes from various branches and Rene Rivera for general build and installation + support. + + + + + + + + + + + + diff --git a/users/history/version_1_35_0.html b/users/history/version_1_35_0.html new file mode 100644 index 0000000..fb31da7 --- /dev/null +++ b/users/history/version_1_35_0.html @@ -0,0 +1,273 @@ +--- +title: Version 1.35.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.35.0 + +/\*\*/ + + + + + + + +Version 1.35.0 +============== + +Version 1.35.0 +-------------- + + +March 29th, 2008 12:00 GMT + + +[Documentation](/doc/libs/1_35_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_35\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.35.0/boost_1_35_0.tar.bz2) | +| [boost\_1\_35\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.35.0/boost_1_35_0.tar.gz) | +| windows | [boost\_1\_35\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.35.0/boost_1_35_0.7z) | +| [boost\_1\_35\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.35.0/boost_1_35_0.zip) | + + +### New Libraries + + +* [Asio](/libs/asio/index.html): Portable networking, + including sockets, timers, hostname resolution and socket iostreams, from + Chris Kohlhoff. +* [Bimap](/libs/bimap/index.html): Boost.Bimap is + a bidirectional maps library for C++. With Boost.Bimap you can create associative + containers in which both types can be used as key, from Matias Capeletto. +* [Circular Buffer](/libs/circular_buffer/index.html): STL + compliant container also known as ring or cyclic buffer, from Jan Gaspar. +* [Function Types](/libs/function_types/index.html): + Boost.FunctionTypes + provides functionality to classify, decompose and synthesize function, + function pointer, function reference and pointer to member types. From + Tobias Schwinger. +* [Fusion](/libs/fusion/index.html): + Library for + working with tuples, including various containers, algorithms, etc. From + Joel de Guzman, Dan Marsden and Tobias Schwinger. +* [GIL](/libs/gil/doc/index.html): + Generic Image + Library, from Lubomir Bourdev and Hailin Jin. +* [Interprocess](/libs/interprocess/index.html): + Shared + memory, memory mapped files, process-shared mutexes, condition variables, + containers and allocators, from Ion Gaztañaga. +* [Intrusive](/libs/intrusive/index.html): + Intrusive + containers and algorithms, from Ion Gaztañaga. +* [Math/Special + Functions](/libs/math/doc/sf_and_dist/html/index.html): + A wide selection of mathematical special functions from + John Maddock, Paul Bristow, Hubert Holin and Xiaogang Zhang. +* [Math/Statistical + Distributions](/libs/math/doc/sf_and_dist/html/index.html): + A wide selection of univariate statistical distributions + and functions that operate on them from John Maddock and Paul Bristow +* [MPI](/doc/html/mpi.html): + Message Passing Interface + library, for use in distributed-memory parallel application programming, + from Douglas Gregor and Matthias Troyer. +* [System](/libs/system/index.html): + Operating system + support, including the diagnostics support that will be part of the C++0x + standard library, from Beman Dawes. + +### Updated Libraries + + +* [Graph](/libs/graph/doc/index.html): + Generic graph + components and algorithms. Highlights: + + + `kolmogorov\_max\_flow`, + from Stephan Diederich as part of the 2006 Google Summer of Code. + + `read\_dimacs\_max\_flow` + and `write\_dimacs\_max\_flow` + for max-flow problems, from Stephan Diederich. + + `read\_graphml` and + `write\_graphml` for + GraphML input/output, from Tiago de Paula Peixoto. + + `minimum\_cycle\_ratio` + and `maximum\_cycle\_ratio`, + from Dmitry Bufistov and Andrey Parfenov. + + `boyer\_myrvold\_planarity\_test`, + along with a suite of algorithms for planar graphs, from Aaron Windsor. + + LEDA Adaptor improvements, from Jens Müller. +* [Hash](/libs/functional/hash/index.html): + A TR1 + hash function object, from Daniel James. Highlights: + + + Support for `long long`, + `std::complex`. + + Improved the algorithm for hashing floating point numbers. + + A few bug and warning fixes. +* [Iostreams](/libs/iostreams/index.html): Framework + for defining streams, stream buffers and i/o filters, from Jonathan Turkanis. + Highlights: + + + Clarified the semantics of close(). This fixes several bugs but will + break some existing code. See [Release + Notes](/libs/iostreams/doc/index.html?path=12) for details. + + Numerous other bug fixes and optimizations. +* [Multi Array](/libs/multi_array/index.html): + + + Added "dimensionality" compile-time constante to the MultiArray + concept. + + For greater control over error situations, uses of C++ assert have + been replaced with BOOST\_ASSERT. + + Fixed a bug with simultaneous resizing and reindexing. +* [Multi-index Containers](/libs/multi_index/doc/index.html): + + + New [`global\_fun`](/libs/multi_index/doc/tutorial/key_extraction.html#global_fun) predefined key + extractor. + + Added [`iterator\_to`](/libs/multi_index/doc/tutorial/indices.html#iterator_to) facility. + + Included [support + for non-standard allocators](/libs/multi_index/doc/tutorial/creation.html#special_allocator) such as those of [Boost.Interprocess](/libs/interprocess/index.html), + which makes `multi\_index\_container`s + placeable in shared memory. + + New versions of `modify` + and `modify\_key` with + rollback, as described in the [tutorial](/libs/multi_index/doc/tutorial/basics.html#ord_updating). + + A number of optimizations and minor improvements have also been included. + For a complete list of changes, see the library [release + notes](/libs/multi_index/doc/release_notes.html#boost_1_35). +* [Serialization](/libs/serialization/index.html): + Boost.Serialization + has been updated with optimizations for dense arrays. +* [Thread](/libs/thread/index.html): + + + The Thread library has been updated to be more in line with the C++0x + working draft. + + Instances of boost::thread and of the various lock types are now + movable. + + Threads can be interrupted at interruption points. + + Condition variables can now be used with any type that implements + the Lockable concept, through the use of `boost::condition\_variable\_any` + (`boost::condition` is a typedef to `boost::condition\_variable\_any`, provided + for backwards compatibility). `boost::condition\_variable` + is provided as an optimization, and will only work with `boost::unique\_lock` + (`boost::mutex::scoped\_lock`). + + Thread IDs are separated from boost::thread, so a thread can obtain + it's own ID (using `boost::this\_thread::get\_id()`), and IDs can be used as keys in + associative containers, as they have the full set of comparison operators. + + Timeouts are now implemented using the Boost DateTime library, through + a typedef `boost::system\_time` for absolute timeouts, + and with support for relative timeouts in many cases. `boost::xtime` is supported for backwards + compatibility only. + + Locks are implemented as publicly accessible templates `boost::lock\_guard`, `boost::unique\_lock`, + `boost::shared\_lock`, and `boost::upgrade\_lock`, which are templated + on the type of the mutex. The Lockable concept has been extended + to include publicly available `lock()` and `unlock()` member functions, which are used + by the lock types. + + `boost::try\_mutex` has been removed, and + the functionality subsumed into `boost::mutex`. + `boost::try\_mutex` is left as a typedef, + but is no longer a separate class. + + `boost::recursive\_try\_mutex` has been removed, + and the functionality subsumed into `boost::recursive\_mutex`. + `boost::recursive\_try\_mutex` is left as + a typedef, but is no longer a separate class. + + `boost::detail::thread::lock\_ops` has been removed. Code + that relies on the `lock\_ops` + implementation detail will no longer work, as this has been removed, + as it is no longer necessary now that mutex types now have public + `lock()` + and `unlock()` + member functions. + + `scoped\_lock` constructors + with a second parameter of type bool are no longer provided. With + previous boost releases, `boost::mutex::scoped\_lock + some\_lock(some\_mutex,false);` + could be used to create a lock object that was associated with a + mutex, but did not lock it on construction. This facility has now + been replaced with the constructor that takes a `boost::defer\_lock\_type` + as the second parameter: `boost::mutex::scoped\_lock + some\_lock(some\_mutex,boost::defer\_lock);` + + The broken `boost::read\_write\_mutex` + has been replaced with `boost::shared\_mutex`. +* [Wave](/libs/wave/index.html): Standards conformant + implementation of the mandated C99/C++ preprocessor functionality packed + behind an easy to use iterator interface, from Hartmut Kaiser. Highlights: + + + Added the possibility to continue the preprocessing after an error + occured. + + Added the macro introspection API to the wave::context object. + + Added threading support to the library. + + Improved the overall performance by upto 30%. + + Changed and unified preprocessor hook interface (this is an interface + breaking change!), added several new preprocessor hook functions. + + Added serialization support. + + Added new examples (for instance: Hannibal - a partial C++ parser, + by Danny Havenith). + + Added a new lexical analyzer based on Ben Hansons Lexertl library. + + Fixed a large number of other bugs and problems. +* [Xpressive](/libs/xpressive/index.html): Regular + expressions that can be written as strings or as expression templates, + and that can refer to each other and themselves recursively with the power + of context-free grammars, from Eric Niebler. Highlights: + + + Added *semantic actions* to static regexes. A + semantic action is code that executes when part of a regular expression + matches. + + Added *custom assertions* to static regexes. A + custom assertion is a Boolean predicate that can participate in the + regex match. + + Added *named regexes* for embedding a static or + dynamic regex into a dynamic regex. This can be used to create dynamic + regex grammars. + + Added *named captures* to dynamic regexes, like + Perl. + +### Supported Compilers + The following compilers are officially supported in this release: + + + +* HP aC++ A.06.14 on HP-UX +* Darwin GCC 4.01. +* GNU GCC up to version 4.2.1, on Linux and Solaris. +* Intel C++ 9.1 on Linux. +* Intel C++ 10.1 on Windows. +* Microsoft Visual C++ 7.1 and 8 on Windows (Visual Sudio .NET 2003 and 2005). + In addition the following compilers should be well supported, but weren't part + of our release criteria for 1.35: + + + +* IBM Visual Age 9.0 on AIX. +* Intel C++ 10 and later on Linux. +* GNU GCC 4.3 and later on Linux and Solaris. +* Microsoft Visual C++ 9 (Visual Studio .NET 2008). + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html) managed this + release. + + + + + + + + + + + + diff --git a/users/history/version_1_36_0.html b/users/history/version_1_36_0.html new file mode 100644 index 0000000..349c0fa --- /dev/null +++ b/users/history/version_1_36_0.html @@ -0,0 +1,253 @@ +--- +title: Version 1.36.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.36.0 + +/\*\*/ + + + + + + + +Version 1.36.0 +============== + +Version 1.36.0 +-------------- + + +August 14th, 2008 12:00 GMT + + +[Documentation](/doc/libs/1_36_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_36\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.36.0/boost_1_36_0.tar.bz2) | +| [boost\_1\_36\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.36.0/boost_1_36_0.tar.gz) | +| windows | [boost\_1\_36\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.36.0/boost_1_36_0.7z) | +| [boost\_1\_36\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.36.0/boost_1_36_0.zip) | + + +### New Libraries + + +* [Accumulators](/libs/accumulators/index.html): Framework + for incremental calculation, and collection of statistical accumulators, + from Eric Niebler. +* [Exception](/libs/exception/doc/boost-exception.html): + A + library for transporting of arbitrary data in exception objects, and transporting + of exceptions between threads, from Emil Dotchevski. +* [Units](/libs/units/index.html): + Zero-overhead + dimensional analysis and unit/quantity manipulation and conversion, from + Matthias Schabel and Steven Watanabe +* [Unordered](/libs/unordered/index.html): + Unordered + associative containers, from Daniel James. + +### Updated Libraries + + +* [Asio](/libs/asio/index.html): + + + Added support for serial ports. + + Added support for UNIX domain sockets. + + Added support for raw sockets and ICMP. + + Added wrappers for POSIX stream-oriented file descriptors (excluding + regular files). + + Added wrappers for Windows stream-oriented `HANDLE`s + such as named pipes (requires `HANDLE`s + that work with I/O completion ports). + + Added wrappers for Windows random-access `HANDLE`s + such as files (requires `HANDLE`s + that work with I/O completion ports). + + Added support for reactor-style operations (i.e. they report readiness + but perform no I/O) using a new `null\_buffers` + type. + + Added an iterator type for bytewise traversal of buffer sequences. + + Added new `read\_until()` and `async\_read\_until()` overloads that take a user-defined + function object for locating message boundaries. + + Added an experimental two-lock queue (enabled by defining `BOOST\_ASIO\_ENABLE\_TWO\_LOCK\_QUEUE`) + that may provide better `io\_service` + scalability across many processors. + + Various fixes, performance improvements, and more complete coverage + of the custom memory allocation support. +* [Assign](/libs/assign/index.html): +`list\_of()` + (and its variants) now has overloaded comparison operators. This allows + you to write test code such as `BOOST\_CHECK\_EQUAL( my\_container, list\_of(2)(3)(4)(5) +);`. +* [Circular Buffer](/libs/circular_buffer/index.html): + + + Default constructor now doesn't allocate memory, and sets the capacity + of the buffer to 0 +* [Foreach](/libs/foreach/index.html): `BOOST\_FOREACH` macro for easily iterating + over the elements of a sequence, from Eric Niebler. + + + New `BOOST\_REVERSE\_FOREACH` + macro for iterating over a sequence in reverse. +* [Function](/libs/function/index.html): + + + Improved allocator support, from Emil Dotchevski. +* [Hash](/libs/functional/hash/index.html): + Minor + updates and fixes, for more info see the [change + log](/doc/html/hash/changes.html#hash.changes.boost_1_36_0). +* [Interprocess](/libs/interprocess/index.html): + + + Added anonymous shared memory for UNIX systems. + + Fixed missing move semantics on managed memory classes. + + Added copy\_on\_write and open\_read\_only options for shared memory + and mapped file managed classes. + + `shared\_ptr` is movable + and supports aliasing. +* [Intrusive](/libs/intrusive/index.html): + + + Added `linear<>` + and `cache\_last<>` + options to singly linked lists. + + Added `optimize\_multikey<>` option to unordered container + hooks. + + Optimized unordered containers when `store\_hash` + option is used in the hook. + + Implementation changed to avoid explicit use of `try`-`catch` blocks and be compilable with + exceptions disabled. +* [Math](/libs/math/doc/sf_and_dist/html/index.html): + + + Added new non-central Chi-Square, Beta, F and T distributions. + + Added Exponential Integral and Zeta special functions. + + Added Rounding, Truncation, and Unit-in-the-last-place functions. + + Added support for compile time powers of a runtime base. + + Added a few SSE2 based optimisations for the Lanczos approximations. +* [MPI](/doc/html/mpi.html): + + + Added support for non-blocking operations in Python, from Andreas + Klöckner. + + Added support for graph topologies. +* [Multi-index Containers](/libs/multi_index/doc/index.html): + Minor + additions and maintenance fixes. Consult the library [release + notes](/libs/multi_index/doc/release_notes.html#boost_1_36) for further information. +* [PtrContainer](/libs/ptr_container/index.html): + Support + for a few more containers, and addition of insert iterators. For details + see [upgrading + details](/libs/ptr_container/doc/ptr_container.html#upgrading-from-boost-v-1-35). +* [Spirit](/libs/spirit/index.html): + Integrated the + "Classic" Spirit V1.8.x code base with Spirit V2, "The New + Generation". See [Change + Log](/libs/spirit/classic/change_log.html). +* [Thread](/libs/thread/index.html): + + + New generic `lock` + and `try\_lock` functions + for locking multiple mutexes at once. + + Rvalue reference support for move semantics where the compilers supports + it. + + A few bugs fixed and missing functions added (including the serious + win32 condition variable bug). + + `scoped\_try\_lock` types + are now backwards-compatible with Boost 1.34.0 and previous releases. + + Support for passing function arguments to the thread function by + supplying additional arguments to the `thread` + constructor. + + Backwards-compatibility overloads added for `timed\_lock` + and `timed\_wait` functions + to allow use of `xtime` + for timeouts. +* [Wave](/libs/wave/index.html): + + + Wave V2.0 is a new major release introducing some breaking API changes, + preventing it to be used with Boost versions earlier than V1.36.0. + Mainly, the API and hook interface have been streamlined for more + consistency. + + Fixed a couple of bugs, improved regression test system to include + testing of the preporcessing hooks interface (for details see: [Changelog](/libs/wave/ChangeLog)). +* [Xpressive](/libs/xpressive/index.html): + Regular + expressions that can be written as strings or as expression templates, + and that can refer to each other and themselves recursively with the power + of context-free grammars, from Eric Niebler. + + + `skip()` + for specifying which parts of the input sequence to ignore when matching + it against a regex. + + `regex\_replace()` + accepts formatter objects and formatter expressions in addition to + format strings. + + Range-based `regex\_replace()` algorithm. + + Fix crash when semantic actions are placed in look-aheads, look-behinds + or independent sub-expressions. + +### Compilers Tested + Boost's primary test compilers are: + + + +* GCC 4.01 on Mac OS X 10.4.10 with both Intel and Power PC +* GCC 4.2.3 on Ubuntu Linux 8.04.1 +* HP C/aC++ B3910B A.06.17 on HP-UX 64-bit +* Visual C++ 9.0 SP1 beta, 8.0 SP1, and 7.1, all on Windows XP SP-2 + Boost's additional test compilers include: + + + +* GCC 4.2.1 on FreeBSD-7 +* GCC 4.1.2 on NetBSD +* HP aCC on OS: HP-UX B.11.31 U ia64 and HP-UX B.11.31 9000/800 RISC +* IBM XL C/C++ Enterprise Edition for AIX, V10.1.0.0, on AIX Version 5.3.0.40 +* Intel 9.1, 10.0, and 10.1, on Mac OS X 10.4.1 +* Compaq C++ V7.1-006 for Compaq Tru64 Unix on an OSF1 V5.1 platform. +* Sun C++ 5.7, 5.8, 5.9 and GCC 3.4.6 on Sun Solaris 5.10. +* On Linux: + + + GCC 3.4.3, 4.0.1, 4.2.1, 4.3.0. + + GCC 4.3.0 with C++0x extensions. + + GCC 3.4.6, 4.1.1, 4.2.1 on 64 bit linux. + + Intel C++ 8.1, 9.0 and 9.1. + + QLogic PathScale(TM) Compiler Suite: Version 3.1 + + pgCC 7.2-3 64-bit target on x86-64 Linux +* On Windows: + + + Intel 10.1, with Visual C++ 9 backend. + + Lots of tests on Visual C++ 7.1, 8.0, 9.0 + + Visual C++ 7.1 with Apache C++ Standard Library 4.2.x branch. + + Visual C++ 8.0 with STLport 5.1 + + Visual C++ 8.0 with STLport 5.1 cross-compiling for Windows Mobile + 5.0 Pocket PC SDK (ARMV4I). + + Borland 5.6.4, 5.8.2, 5.9.3 + + 64 bit Intel 10.1, with Visual C++ 9 backend. + + 64 bit Visual C++ 9. + + Comeau C++ 4.3.10.1 beta 2, with Visual C++ 9 backend. + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), [Rene + Rivera](/users/people/rene_rivera.html), and Daniel James managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_37_0.html b/users/history/version_1_37_0.html new file mode 100644 index 0000000..55daa3a --- /dev/null +++ b/users/history/version_1_37_0.html @@ -0,0 +1,186 @@ +--- +title: Version 1.37.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.37.0 + +/\*\*/ + + + + + + + +Version 1.37.0 +============== + +Version 1.37.0 +-------------- + + +November 3rd, 2008 12:00 GMT + + +[Documentation](/doc/libs/1_37_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_37\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.37.0/boost_1_37_0.tar.bz2) | +| [boost\_1\_37\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.37.0/boost_1_37_0.tar.gz) | +| windows | [boost\_1\_37\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.37.0/boost_1_37_0.7z) | +| [boost\_1\_37\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.37.0/boost_1_37_0.zip) | + + +### New Libraries + + +* [Proto](/libs/proto/index.html): + + + Expression template library and compiler construction toolkit for + domain-specific embedded languages, from Eric Niebler. + +### Updated Libraries + + +* [Asio](/libs/asio/index.html): + + + Enhanced CompletionCondition concept with the signature `size\_t CompletionCondition(error\_code + ec, + size\_t total)`, where the return value indicates + the maximum number of bytes to be transferred on the next read or + write operation. (The old CompletionCondition signature is still + supported for backwards compatibility). + + New windows::overlapped\_ptr class to allow arbitrary overlapped I/O + functions (such as TransmitFile) to be used with Asio. + + On recent versions of Linux, an eventfd descriptor is now used (rather + than a pipe) to interrupt a blocked select/epoll reactor. + + Added const overloads of lowest\_layer(). + + Synchronous read, write, accept and connect operations are now thread + safe (meaning that it is now permitted to perform concurrent synchronous + operations on an individual socket, if supported by the OS). + + Reactor-based io\_service implementations now use lazy initialisation + to reduce the memory usage of an io\_service object used only as a + message queue. +* [Circular Buffer](/libs/circular_buffer/index.html): + + + Added new methods `is\_linearized()` and `rotate(const\_iterator)`. + + Minor bug fixes and documentation updates. +* [Dynamic Bitset](/libs/dynamic_bitset/): + + + Constructor "do the right thing" dispatch, a la standard + sequence containers (follows the proposed resolution of [library + issue 438](http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#438), currently in the C++0x working + paper). + + Improvements to documentation, code examples and implementation. +* [Exception](/libs/exception/index.html): + + + Support for non-RTTI builds. + + Optimizations. + + A new macro `BOOST\_THROW\_EXCEPTION` + which can be used instead of `boost::throw\_exception` + when throwing, to automatically record information about the location + of the throw in the exception object. +* [Hash](/libs/functional/hash/index.html): + + + Minor bug fix ([ticket + 2264](http://svn.boost.org/trac/boost/ticket/2264)). +* [Interprocess](/libs/interprocess/index.html): + + + Added placement insertion (`emplace()`, `emplace\_back()`...) methods to containers. + + Containers can be used now in recursive types. + + Minor bug fixes. +* [Intrusive](/libs/intrusive/index.html): + + + Intrusive now takes advantage of compilers with variadic templates. + + `clone\_from` functions + now copy predicates and hash functions of associative containers. + + Added incremental hashing to unordered containers via `incremental<>` + option. + + Minor bug fixes. +* [Math.Special + Functions](/libs/math/doc/sf_and_dist/html/index.html): + Improved accuracy and testing of the inverse hypergeometric + functions. +* [Type Traits](/libs/type_traits/index.html): + Added + better support for the Codegear compiler. +* [Unordered](/libs/unordered/index.html): + + + Rename overload of `emplace` + with hint, to `emplace\_hint` + as specified in [n2691](http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2691.pdf). + + Provide forwarding headers at `` + and ``. + + Move all of the implementation inside the `boost/unordered` + directory. + +### Compilers Tested + Boost's primary test compilers are: + + + +* GCC 4.01 on Mac OS X 10.4.10 with both Intel and Power PC +* GCC 4.2.4 on Ubuntu Linux 8.10 +* GCC 4.3.2 on Debian Sid +* GCC 4.2.1 on HP-UX Integrity +* HP C/aC++ B3910B A.06.17 on HP-UX 64-bit +* Visual C++ 9.0 SP1, 8.0, and 7.1 SP1, all on Windows XP + Boost's additional test compilers include: + + + +* GCC 4.1.2 on NetBSD +* HP aCC on OS: HP-UX B.11.31 U ia64 and HP-UX B.11.31 9000/800 RISC +* IBM XL C/C++ Enterprise Edition for AIX, V10.1.0.0, on AIX Version 5.3.0.40 +* Intel 9.1, 10.0, and 10.1, on Mac OS X 10.4.10 +* Compaq C++ V7.1-006 for Compaq Tru64 Unix on an OSF1 V5.1 platform. +* Sun C++ 5.7, 5.8, 5.9 and GCC 3.4.6 on Sun Solaris 5.10. +* On Linux: + + + GCC 3.4.3, 4.0.1, 4.2.1, 4.2.4, 4.3.2. + + GCC 4.3.2 with C++0x extensions. + + GCC 4.1.1, 4.2.1 on 64 bit linux. + + Intel C++ 8.1, 9.0, 9.1 and 10.0 + + QLogic PathScale(TM) Compiler Suite: Version 3.1 + + Sun Compiler 5.9, 5.10 with stdcxx +* On Windows: + + + Several testers using Visual C++ 7.1, 8.0, 9.0 and 10.0 + + Visual C++ 7.1 with Apache C++ Standard Library 4.2.x branch. + + Visual C++ 8.0 with STLport 5.1 + + Visual C++ 8.0 with STLport 5.1 cross-compiling for Windows Mobile + 5.0 Pocket PC SDK (ARMV4I). + + Intel 10.1, with Visual C++ 9 backend. + + Borland 5.9.3 and 6.10.0 + + 64 bit Intel 10.1, with Visual C++ 9 backend. + + 64 bit Visual C++ 9.0. + + 64-bit Visual C++ 9.0 with Apache C++ Standard Library 4.2.x branch. + + Comeau C++ 4.3.10.1 beta 2, with Visual C++ 9 backend. + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), and Daniel + James managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_38_0.html b/users/history/version_1_38_0.html new file mode 100644 index 0000000..6e67cb4 --- /dev/null +++ b/users/history/version_1_38_0.html @@ -0,0 +1,325 @@ +--- +title: Version 1.38.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.38.0 + +/\*\*/ + + + + + + + +Version 1.38.0 +============== + +Version 1.38.0 +-------------- + + +February 8th, 2009 12:00 GMT + + +[Documentation](/doc/libs/1_38_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_38\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.38.0/boost_1_38_0.tar.bz2) | +| [boost\_1\_38\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.38.0/boost_1_38_0.tar.gz) | +| windows | [boost\_1\_38\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.38.0/boost_1_38_0.7z) | +| [boost\_1\_38\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.38.0/boost_1_38_0.zip) | + + +### New Libraries + + +* [Flyweight](/libs/flyweight/index.html): + + + Design pattern to manage large quantities of highly redundant objects, + from Joaquín M López Muñoz. +* [ScopeExit](/libs/scope_exit/doc/html/index.html): + + + Execute arbitrary code at scope exit, from Alexander Nasonov. +* [Swap](/libs/utility/swap.html): + + + Enhanced generic swap function, from Joseph Gauterin. + +### Updated Libraries + + +* [Accumulators](/libs/accumulators/index.html): + + + Add `rolling\_sum`, + `rolling\_count` and + `rolling\_mean` accumulators. +* [Any](/doc/html/any.html): + + + Use a by-value argument for `operator=` ([#2311](https://svn.boost.org/trac/boost/ticket/2311)). +* [Asio](/libs/asio/index.html): + + + Improved compatibility with some Windows firewall software. + + Ensured arguments to `windows::overlapped\_ptr::complete()` are correctly passed to the completion + handler ([#2614](https://svn.boost.org/trac/boost/ticket/2614)). + + Fixed a link problem and multicast failure on QNX ([#2504](https://svn.boost.org/trac/boost/ticket/2504), + [#2530](https://svn.boost.org/trac/boost/ticket/2530)). + + Fixed a compile error in SSL support on MinGW / g++ 3.4.5. + + Drop back to using a pipe for notification if eventfd is not available + at runtime on Linux ([#2683](https://svn.boost.org/trac/boost/ticket/2683)). + + Various minor bug and documentation fixes ([#2534](https://svn.boost.org/trac/boost/ticket/2534), + [#2541](https://svn.boost.org/trac/boost/ticket/2541), + [#2607](https://svn.boost.org/trac/boost/ticket/2607), + [#2617](https://svn.boost.org/trac/boost/ticket/2617), + [#2619](https://svn.boost.org/trac/boost/ticket/2619)) +* [Config](/libs/config/index.html): + + + Add new macros BOOST\_NO\_STD\_UNORDERED and BOOST\_NO\_INITIALIZER\_LISTS. + + Added Codegear compiler support. + + Added Dragonfly to the BSD family of configs. + + Updated MSVC's binary ABI settings to match compiler default when + doing 64-bit builds. + + Recognise latest compilers from MS and Intel. +* [Date\_Time](/libs/date_time/index.html): + + + Added support for formatting and reading time durations longer than + 24 hours with new formatter: `%0`. + + Removed the `testfrmwk.hpp` + file from the public include directory. + + Fixed several bugs and compile errors. + + For full details see the [change + history](/doc/libs/1_38_0/doc/html/date_time/details.html#date_time.changes) +* [Exception](/libs/exception/index.html): + + + Improved and more customizable [diagnostic\_information](/libs/exception/doc/diagnostic_information.html) + output. +* [Filesystem](/libs/filesystem/index.html): + + + Fix native(name) test failures on POSIX-like systems. + + Several bugfixes ([#2543](https://svn.boost.org/trac/boost/ticket/2543), + [#2224](https://svn.boost.org/trac/boost/ticket/2224), + [#2531](https://svn.boost.org/trac/boost/ticket/2531), + [#1840](https://svn.boost.org/trac/boost/ticket/1840), + [#2542](https://svn.boost.org/trac/boost/ticket/2542)). +* [Graph](/libs/graph/index.html): + + + Added a new algorithms for Travelling Salesman Problem approximation + (`metric\_tsp\_approx`) + and resource-constrained Shortest Paths (`r\_c\_shortest\_paths`). + + Support for named vertices in `adjacency\_list`. + + A number of bugfixes ( [#416](https://svn.boost.org/trac/boost/ticket/416), + [#1622](https://svn.boost.org/trac/boost/ticket/1622), + [#1700](https://svn.boost.org/trac/boost/ticket/1700), + [#2209](https://svn.boost.org/trac/boost/ticket/2209), + [#2392](https://svn.boost.org/trac/boost/ticket/2392), + [#2460](https://svn.boost.org/trac/boost/ticket/2460), + and [#2550](https://svn.boost.org/trac/boost/ticket/2550)) +* [Hash](/libs/functional/hash/index.html): + + + `boost/functional/detail/container\_fwd.hpp` has been moved to `boost/detail/container\_fwd.hpp`. The current location is deprecated. + + For more detail, see the [library + changelog](/doc/html/hash/changes.html#hash.changes.boost_1_38_0). +* [Interprocess](/libs/interprocess/index.html): + + + Updated documentation to show rvalue-references functions instead + of emulation functions. + + More non-copyable classes are now movable. + + Move-constructor and assignments now leave moved object in default-constructed + state instead of just swapping contents. + + Several bugfixes ([#2391](https://svn.boost.org/trac/boost/ticket/2391), + [#2431](https://svn.boost.org/trac/boost/ticket/2431), + [#1390](https://svn.boost.org/trac/boost/ticket/1390), + [#2570](https://svn.boost.org/trac/boost/ticket/2570), + [#2528](https://svn.boost.org/trac/boost/ticket/2528)). +* [Intrusive](/libs/intrusive/index.html): + + + New treap-based containers: treap, treap\_set, treap\_multiset. + + Corrected compilation bug for Windows-based 64 bit compilers. + + Corrected exception-safety bugs in container constructors. + + Updated documentation to show rvalue-references functions instead + of emulation functions. +* [Lexical Cast](/libs/conversion/lexical_cast.htm): + + + Changed to work without RTTI when `BOOST\_NO\_TYPEID` + is defined ([#1220](https://svn.boost.org/trac/boost/ticket/1220)). +* [Math](/libs/math/doc/sf_and_dist/html/index.html): + + + Added Johan Råde's optimised floating point classification routines. + + Fixed code so that it compiles in GCC's -pedantic mode (bug report + [#1451](https://svn.boost.org/trac/boost/ticket/1451)). +* [Multi-index Containers](/libs/multi_index/doc/index.html): + Some + redundant type definitions have been deprecated. Consult the library [release notes](/libs/multi_index/doc/release_notes.html#boost_1_38) + for further information. +* [Proto](/libs/proto/index.html): + + + Fix problem with SFINAE of binary operators (Bug [2407](https://svn.boost.org/trac/boost/ticket/2407)). + + Fix `proto::call` transform for callable transforms + with >3 arguments. + + `result\_of::value` changed behavior for array-by-value + terminals. + + `unpack\_expr` requires + only Forward Sequences rather than Random Access Sequences. + + Deprecate legacy undocumented `BOOST\_PROTO\_DEFINE\_(VARARG\_)FUNCTION\_TEMPLATE` + macros. + + Add `BOOST\_PROTO\_REPEAT` + and `BOOST\_PROTO\_LOCAL\_ITERATE` + macros to help with repetitive code generation + + Support for nullary expressions with tag types other than `proto::tag::terminal` + + Allow 0- and 1-argument variants of `proto::or\_` + and `proto::and\_` +* [Regex](/libs/regex/index.html): + + + *Breaking change*: empty expressions, and empty + alternatives are now allowed when using the Perl regular expression + syntax. This change has been added for Perl compatibility, when the + new `syntax\_option\_type` + *no\_empty\_expressions* is set then the old behaviour + is preserved and empty expressions are prohibited. This is issue + [#1081](https://svn.boost.org/trac/boost/ticket/1081). + + Added support for Perl style ${n} expressions in format strings (issue + [#2556](https://svn.boost.org/trac/boost/ticket/2556)). + + Added support for accessing the location of sub-expressions within + the regular expression string (issue [#2269](https://svn.boost.org/trac/boost/ticket/2269)). + + Fixed compiler compatibility issues [#2244](https://svn.boost.org/trac/boost/ticket/2244), + [#2514](https://svn.boost.org/trac/boost/ticket/2514), + and [#2458](https://svn.boost.org/trac/boost/ticket/2244). +* [Thread](/doc/html/thread.html): + + + No longer catches unhandled exceptions in threads as this debuggers + couldn't identify the cause of unhandled exceptions in threads. An + unhandled exception will still cause the application to terminate. +* [TR1](/libs/tr1/index.html): + + + Added support for the TR1 math functions and the unordered containers. +* [Type Traits](/libs/type_traits/index.html): + + + Added support for Codegear intrinsics. + + Minor tweaks to warning suppression and alignment\_of code. +* [Unordered](/libs/unordered/index.html): + + + Use [`boost::swap`](/libs/utility/swap.html). + + Use a larger prime number list for selecting the number of buckets. + + Use [aligned + storage](/libs/type_traits/doc/html/boost_typetraits/category/alignment.html) to store the types. + + Add support for C++0x initializer lists where they're available. + + For more detail, see the [library + changelog](/doc/html/unordered/changes.html#unordered.changes.boost_1_38_0). +* [Xpressive](/libs/xpressive/index.html): + + + `basic\_regex` gets + nested `syntax\_option\_flags` + and `value\_type` typedef, + for compatibility with `std::basic\_regex` + + Ported to Proto v4; Proto v2 at boost/xpressive/proto + has been removed. + + `regex\_error` inherits + from `boost::exception` + +### Other Changes + + +* Experimental support for building Boost with [CMake](http://www.cmake.org/) + has been introduced in this version. For more details see the [wiki](https://svn.boost.org/trac/boost/wiki/CMake), + Discussion is taking place on the [Boost-cmake + mailing list](https://lists.boost.org/mailman/listinfo.cgi/boost-cmake). +* Fixed subversion properties for several files. Most notably, unix shell + scripts should always have unix line endings, even in the windows packages. + +### Compilers Tested + Boost's primary test compilers are: + + + +* OS X: + + + GCC 4.0.1 on Intel OS X 10.4.10, 10.5.2 + + GCC 4.0.1 on PowerPC OS X 10.4.9 +* Linux: + + + GCC 4.3.2 on Ubuntu Linux. + + GCC 4.3.3 on Debian "unstable". +* HP-UX: + + + GCC 4.2.1 on HP-UX 64-bit. + + HP C/aC++ B3910B A.06.17 on HP-UX 64-bit. +* Windows: + + + Visual C++ 7.1 SP1, 8.0 SP1 and 9.0 SP1 on Windows XP. + Boost's additional test compilers include: + + + +* Linux: + + + GCC 4.1.1, 4.2.1 on 64-bit Red Hat Enterprise Linux + + GCC 4.1.2 on 64-bit Redhat Server 5.1 + + GCC 3.4.3, GCC 4.0.1, GCC 4.2.4 and GCC 4.3.2 on Red Hat Enterprise + Linux + + GCC 4.3.2 with C++0x extensions + + GCC 4.2.1 on OpenSuSE Linux + + pgCC 8.0-0a 64-bit target on Red Hat Enterprise Linux + + QLogic PathScale(TM) Compiler Suite: Version 3.1 on Red Hat Enterprise + Linux +* OS X: + + + Intel 9.1, 10.0 on OS X 10.4.10 + + Intel 10.1, 11.0 on OS X 10.5.2 +* Windows: + + + Visual C++ 9.0 on Vista EE 64-bit. + + Visual C++ 9.0 express on Vista 32-bit. + + Visual C++ 9.0 on XP 32-bit. + + Visual C++ 8.0, using STLport, on XP and Windows Mobile 5.0 + + Visual C++ 7.1, using STLport, on XP + + Borland 5.9.3 + + Borland 6.1.0 + + Intel C++ 11.0, with a Visual C++ 9.0 backend, on XP 32-bit. + + Intel C++ 11.0, with a Visual C++ 9.0 backend, on Vista 64-bit. + + Comeau 4.3.10.1 beta 2, with a Visual C++ 9.0 backend. + + GCC 3.4.4, on Cygwin +* AIX: + + + IBM XL C/C++ Enterprise Edition for AIX, V10.1.0.0, on AIX Version + 5.3.0.40 +* FreeBSD: + + + GCC 4.2.1 on FreeBSD 7. +* NetBSD: + + + GCC 4.1.2 on NetBSD 4.0/i386 and NetBSD 4.0/amd64. +* QNX: + + + QNX Software Development Platform 6.4.0 x86 +* Solaris: + + + Sun C++ 5.7, 5.8, 5.9 on Solaris 5.10 + + GCC 3.4.6 on Solaris 5.10 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), and Daniel + James managed this release. Thanks to Vicente Botet for helping compile these + release notes. + + + + + + + + + + + + diff --git a/users/history/version_1_39_0.html b/users/history/version_1_39_0.html new file mode 100644 index 0000000..2e96deb --- /dev/null +++ b/users/history/version_1_39_0.html @@ -0,0 +1,268 @@ +--- +title: Version 1.39.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.39.0 + +/\*\*/ + + + + + + + +Version 1.39.0 +============== + +Version 1.39.0 +-------------- + + +May 2nd, 2009 12:00 GMT + + +[Documentation](/doc/libs/1_39_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_39\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.39.0/boost_1_39_0.tar.bz2) | +| [boost\_1\_39\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.39.0/boost_1_39_0.tar.gz) | +| windows | [boost\_1\_39\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.39.0/boost_1_39_0.7z) | +| [boost\_1\_39\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.39.0/boost_1_39_0.zip) | + + +### New Libraries + + +* [Signals2](/libs/signals2/index.html): Managed + signals & slots callback implementation (thread-safe version 2), from + Frank Mori Hess. + +### Updated Libraries + + +* [Asio](/libs/asio/index.html): + + + Implement automatic resizing of the bucket array in the internal + hash maps. This is to improve performance for very large numbers + of asynchronous operations and also to reduce memory usage for very + small numbers. A new macro `BOOST\_ASIO\_HASH\_MAP\_BUCKETS` + may be used to tweak the sizes used for the bucket arrays. + + Add performance optimisation for the Windows IOCP backend for when + no timers are used. + + Prevent locale settings from affecting formatting of TCP and UDP + endpoints ([#2682](https://svn.boost.org/trac/boost/ticket/2682)). + + Fix a memory leak that occurred when an asynchronous SSL operation's + completion handler threw an exception ([#2910](https://svn.boost.org/trac/boost/ticket/2910)). + + Fix the implementation of `io\_control()` so that it adheres to the documented + type requirements for IoControlCommand ([#2820](https://svn.boost.org/trac/boost/ticket/2820)). + + Fix incompatibility between Asio and ncurses.h ([#2156](https://svn.boost.org/trac/boost/ticket/2156)). + + On Windows, specifically handle the case when an overlapped `ReadFile` call fails with `ERROR\_MORE\_DATA`. This enables a + hack where a `windows::stream\_handle` + can be used with a message-oriented named pipe ([#2936](https://svn.boost.org/trac/boost/ticket/2936)). + + Fix system call wrappers to always clear the error on success, as + POSIX allows successful system calls to modify errno ([#2953](https://svn.boost.org/trac/boost/ticket/2953)). + + Don't include termios.h if `BOOST\_ASIO\_DISABLE\_SERIAL\_PORT` + is defined ([#2917](https://svn.boost.org/trac/boost/ticket/2917)). + + Cleaned up some more MSVC level 4 warnings ([#2828](https://svn.boost.org/trac/boost/ticket/2828)). + + Various documentation fixes ([#2871](https://svn.boost.org/trac/boost/ticket/2871)). +* [Flyweight](/libs/flyweight/index.html): + + + The [refcounted](/libs/flyweight/doc/tutorial/configuration.html#refcounted) + component was not thread-safe due to an incorrect implementation + and could deadlock under heavy usage conditions. This problem has + been corrected. +* [Foreach](/libs/foreach/index.html): + + + Eliminate shadow warnings on gcc for nested `FOREACH` + loops + + Portability fix for Intel-Win toolset +* [Hash](/libs/functional/hash/index.html): + + + Remove deprecated headers for hashing containers. Everything that + was in them is included in `` + ([#2412](https://svn.boost.org/trac/boost/ticket/2412)). + + Other minor changes, full details in the library [change + log](/doc/html/hash/changes.html#hash.changes.boost_1_39_0). +* [Interprocess](/libs/interprocess/index.html): + + + Increased portability and bug fixes. Full details in the library + [change + log](/doc/html/interprocess/acknowledgements_notes.html#interprocess.acknowledgements_notes.release_notes.release_notes_boost_1_39_00). +* [Intrusive](/libs/intrusive/index.html): + + + Optimizations and bug fixes. Full details in the library [change + log](/doc/html/intrusive/release_notes.html#intrusive.release_notes.release_notes_boost_1_39_00). +* [Program.Options](/libs/program_options/index.html): + + + Multitoken options fixed ([#469](https://svn.boost.org/trac/boost/ticket/469)). +* [Proto](/libs/proto/index.html): + + + Work around incompatibility with standard Linux header. + + Add `proto::noinvoke<>` + to block metafunction invocation in object transforms. +* [PtrContainer](/libs/ptr_container/index.html): + + + Bug fixes from Trac applied. +* [Range](/libs/range/index.html): + + + Bug fixes from Trac applied. +* [Unordered](/libs/unordered/index.html): + + + Fixed regression in 1.38 that prevented unordered from using more + than about 1.5 million buckets ([#2975](https://svn.boost.org/trac/boost/ticket/2975)). + + Minor implementation changes, including [#2756](https://svn.boost.org/trac/boost/ticket/2756). + Full details in the library [change + log](/doc/html/unordered/changes.html#unordered.changes.boost_1_39_0). +* [Xpressive](/libs/xpressive/index.html): + + + Work around for gcc optimization problem resulting in pure virtual + function call runtime error ([#2655](https://svn.boost.org/trac/boost/ticket/2655)). + +### Updated Tools + + +* [Boostbook](/tools/boostbook/index.html): + + + Improved PDF generation. + + Preliminary HTMLHelp support. + + Add default path for callout images. + + Include data members' `` + in the class synopsis. + + Fix bug where a function's `` + wasn't displayed if it was just plain text. + + Support the alt tag in `` + and ``. Use this if the header or macro + name is different to the contents of the tag ([#1977](https://svn.boost.org/trac/boost/ticket/1977)). + + Support links relative to the boost root in `` + tags, using a custom url, see the [linking + documentation](/doc/html/boostbook/together.html#boostbook.linking) for details ([#1166](https://svn.boost.org/trac/boost/ticket/1166)). + + Avoid generating filenames that only differ in case for function, + method and macro documentation. + + Run the docbook chunker quietly, unless boostbook.verbose is set. + This parameter might be used in other places in future releases. + + Make the 1.1 DTD available. + + Fill in some missing reference documentation (partially fixes [#2153](https://svn.boost.org/trac/boost/ticket/2153)). + + Changes to doxygen integration: + + - Support `\throw`. + - Support global variables and enums. + - Better support for documentation written in function and method + bodies. + - Workaround a problem with doxygen 1.5.8's xml output ([#2937](https://svn.boost.org/trac/boost/ticket/2937)). +* [Quickbook](/tools/quickbook/index.html): + + + Return an error code and error count if there are any errors ([#1399](https://svn.boost.org/trac/boost/ticket/1399)). + + Support both windows and cygwin paths at the compile line when compiled + with cygwin. + + Fix some issues with C++ and Python code: + + - Fail gracefully for a mismatched `''`. + - Warn if any unexpected character are encountered and write + them out properly ([#1170](https://svn.boost.org/trac/boost/ticket/1170)). + - Fix a bug for hex encoded characters in strings ([#2860](https://svn.boost.org/trac/boost/ticket/2860)). + + Improved testing, including tests for expected failures. + + Generate valid document info for document types other than `library` ([#2711](https://svn.boost.org/trac/boost/ticket/2711)): + + - Remove library specific attributes. + - Put title before info block. + + Fix a bug when calling templates. + + Less warnings when built using gcc. + + Small documentation improvements ([#1213](https://svn.boost.org/trac/boost/ticket/1213), + [#2701](https://svn.boost.org/trac/boost/ticket/2701)). + + Fix a bug with xinclude pages when outdir is the current directory + ([#2921](https://svn.boost.org/trac/boost/ticket/2921)). + +### Compilers Tested + Boost's primary test compilers are: + + + +* OS X: + + + GCC 4.0.1 on Intel Tiger and Leopard + + GCC 4.0.1 on PowerPC Tiger +* Linux: + + + GCC 4.3.2 on Ubuntu Linux. + + GCC 4.3.3 on Debian "unstable". +* Windows: + + + Visual C++ 7.1 SP1, 8.0 SP1 and 9.0 SP1 on Windows XP. + Boost's additional test compilers include: + + + +* Linux: + + + Intel 9.0 on Red Hat Enterprise Linux + + Intel 10.0 on Red Hat Enterprise Linux + + Intel 10.1 on 64-bit Linux Redhat 5.1 Server. + + Intel 10.1 on Suse Linux on 64 bit Itanium + + Intel 11.0 on Red Hat Enterprise Linux + + GCC 4.1.1, 4.2.1 on 64-bit Red Hat Enterprise Linux + + GCC 4.1.2 on 64-bit Redhat Server 5.1 + + GCC 4.1.2 on Suse Linux on 64 bit Itanium + + GCC 3.4.3, GCC 4.0.1, GCC 4.2.4 and GCC 4.3.2 on Red Hat Enterprise + Linux + + GCC 4.3.2 with C++0x extensions on Red Hat Enterprise Linux + + GCC 4.2.1 on OpenSuSE Linux + + QLogic PathScale(TM) Compiler Suite: Version 3.1 on Red Hat Enterprise + Linux + + GNU gcc version 4.2.0 (PathScale 3.2 driver) on 64-bit Red Hat Enterprise + Linux + + Sun 5.9 on Red Hat Enterprise Linux +* OS X: + + + Intel 9.1, 10.1 on Tiger + + Intel 10.1, 11.0 on Leopard + + GCC 4.2.1 on Leopard +* Windows: + + + Visual C++ 9.0 on Vista. + + Visual C++ 9.0, using STLport 5.2, on XP and Windows Mobile 5.0. + + Borland 5.9.3 + + Borland 6.1.0 + + Intel C++ 11.0, with a Visual C++ 9.0 backend, on XP 32-bit. + + Intel C++ 11.0, with a Visual C++ 9.0 backend, on Vista 64-bit. (TODO: + not recently) + + GCC 4.3.3, on Mingw +* AIX: + + + IBM XL C/C++ Enterprise Edition for AIX, V10.1.0.0, on AIX Version + 5.3.0.40 +* NetBSD: + + + GCC 4.1.2 on NetBSD 4.0/i386 and NetBSD 4.0/amd64. +* Solaris: + + + Sun C++ 5.7, 5.8, 5.9 on Solaris 5.10 + + GCC 3.4.6 on Solaris 5.10 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), and Daniel + James managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_40_0.html b/users/history/version_1_40_0.html new file mode 100644 index 0000000..ef22923 --- /dev/null +++ b/users/history/version_1_40_0.html @@ -0,0 +1,314 @@ +--- +title: Version 1.40.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.40.0 + +/\*\*/ + + + + + + + +Version 1.40.0 +============== + +Version 1.40.0 +-------------- + + +August 27th, 2009 17:00 GMT + + +[Documentation](/doc/libs/1_40_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_40\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.40.0/boost_1_40_0.tar.bz2) | +| [boost\_1\_40\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.40.0/boost_1_40_0.tar.gz) | +| windows | [boost\_1\_40\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.40.0/boost_1_40_0.7z) | +| [boost\_1\_40\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.40.0/boost_1_40_0.zip) | + + +### Update + Added missing notes for Graph and Property Map. + + +### Boost.CMake + Boost.CMake is **now distributed separately**. + The cmake build for boost is **BROKEN** in the + tarballs above. See the [Boost.CMake + wiki page](https://svn.boost.org/trac/boost/wiki/CMake) for pointers to working versions. + + +### Updated Libraries + + +* [Accumulators](/libs/accumulators/index.html): + + + Works on GCC 4.4. +* [Asio](/libs/asio/index.html): + + + Added a new ping example to illustrate the use of ICMP sockets. + + Changed the `buffered\*\_stream<>` templates to treat 0-byte + reads and writes as no-ops, to comply with the documented type requirements + for `SyncReadStream`, + `AsyncReadStream`, + `SyncWriteStream` and + `AsyncWriteStream`. + + Changed some instances of the `throw` + keyword to `boost::throw\_exception()` to allow Asio to be used when exception + support is disabled. Note that the SSL wrappers still require exception + support ([#2754](https://svn.boost.org/trac/boost/ticket/2754)). + + Made Asio compatible with the OpenSSL 1.0 beta ([#3256](https://svn.boost.org/trac/boost/ticket/3256)). + + Eliminated a redundant system call in the Solaris /dev/poll + backend. + + Fixed a bug in resizing of the bucket array in the internal hash + maps ([#3095](https://svn.boost.org/trac/boost/ticket/3095)). + + Ensured correct propagation of the error code when a synchronous + accept fails ([#3216](https://svn.boost.org/trac/boost/ticket/3216)). + + Ensured correct propagation of the error code when a synchronous + read or write on a Windows HANDLE fails. + + Fixed failures reported when `\_GLIBCXX\_DEBUG` + is defined ([#3098](https://svn.boost.org/trac/boost/ticket/3098)). + + Fixed custom memory allocation support for timers ([#3107](https://svn.boost.org/trac/boost/ticket/3107)). + + Tidied up various warnings reported by g++ ([#1341](https://svn.boost.org/trac/boost/ticket/1341), + [#2618](https://svn.boost.org/trac/boost/ticket/2618)). + + Various documentation improvements, including more obvious hyperlinks + to function overloads, header file information, examples for the + handler type requirements, and adding enum values to the index ([#3157](https://svn.boost.org/trac/boost/ticket/3157), + [#2620](https://svn.boost.org/trac/boost/ticket/2620)). +* [Circular Buffer](/libs/circular_buffer/index.html): + + + Fixed bugs [#2785](https://svn.boost.org/trac/boost/ticket/2785), + [#3285](https://svn.boost.org/trac/boost/ticket/3285). +* [Foreach](/libs/foreach/index.html): + + + Workaround for conflict with Python headers ([#3000](https://svn.boost.org/trac/boost/ticket/3000)). +* [Function](/libs/function/index.html): + + + Optimize the use of small target objects. + + Make Boost.Function compile under BOOST\_NO\_EXCEPTIONS ([#2499](https://svn.boost.org/trac/boost/ticket/2499), + [#2494](https://svn.boost.org/trac/boost/ticket/2494), + [#2469](https://svn.boost.org/trac/boost/ticket/2469), + [#2466](https://svn.boost.org/trac/boost/ticket/2466), + [#2900](https://svn.boost.org/trac/boost/ticket/2900)) + + Various minor fixes ([#2642](https://svn.boost.org/trac/boost/ticket/2642), + [#2847](https://svn.boost.org/trac/boost/ticket/2847), + [#2929](https://svn.boost.org/trac/boost/ticket/2929) + [#3012](https://svn.boost.org/trac/boost/ticket/3012)) +* [Fusion](/libs/fusion/index.html): + + + Improved compile times for `fusion::vector`. +* [Graph](/libs/graph/index.html): + + + Merged in the [Parallel + Boost Graph Library](/libs/graph_parallel/doc/html/index.html), giving a full suite of graph algorithms + and data structures for distributed-memory computers (such as clusters). + + Updates to the interface of the compressed sparse row graph, including + constructors from unsorted edge lists. + + An implicit grid graph, saving memory over using the former generator. + + New algorithms: Dijkstra's single-source shortest path algorithm + without a separate color map and an algorithm to find maximal common + subgraphs between two graphs. + + Assorted bug fixes. +* [Hash](/libs/functional/hash/index.html): + + + Automatically configure the float functions using template metaprogramming + instead of trying to configure every possibility manually. +* [Interprocess](/libs/interprocess/index.html): + + + Windows shared memory is created in Shared Documents folder so that + it can be shared between services and processes + + Fixed bugs [#2967](https://svn.boost.org/trac/boost/ticket/2967), + [#2973](https://svn.boost.org/trac/boost/ticket/2973), + [#2992](https://svn.boost.org/trac/boost/ticket/2992), + [#3138](https://svn.boost.org/trac/boost/ticket/3138), + [#3166](https://svn.boost.org/trac/boost/ticket/3166), + [#3205](https://svn.boost.org/trac/boost/ticket/3205). +* [Intrusive](/libs/intrusive/index.html): + + + Code cleanup in tree\_algorithms.hpp and avl\_tree\_algorithms.hpp + + Fixed bug [#3164](https://svn.boost.org/trac/boost/ticket/3164). +* [MPL](/libs/mpl/index.html): + + + Added `mpl::char\_` and `mpl::string` + for compile-time string manipulation, based on multichar literals + ([#2905](https://svn.boost.org/trac/boost/ticket/2905)). + + Updated [MPL Reference Manual](/libs/mpl/doc/refmanual.html). + + Bug fixes. +* [Program.Options](/libs/program_options/index.html): + + + Support for building with disabled exceptions ([#2096](https://svn.boost.org/trac/boost/ticket/2096)). + + Unicode parser no longer drops original tokens ([#2425](https://svn.boost.org/trac/boost/ticket/2425)). + + Fixed crash on user-inserted items in `variables\_map` + ([#2782](https://svn.boost.org/trac/boost/ticket/2782)). +* [Property Map](/libs/property_map/index.html): + + + Moved property map code into a separate directory, `boost/property\_map/`. + The old files exist and forward to the new ones; the previous files + directly in `boost/` will be removed in Boost 1.42.0. + + Moved distributed property maps to `boost::graph::parallel` + namespace. + + Added a property map based on a `boost::shared\_array`, + providing a simpler interface. +* [Proto](/libs/proto/index.html): + + + PrimitiveTransforms have stricter conformance to ResultOf protocol. + (Warning: some invalid code may break.) + + Add a sensible default for `proto::\_default`'s + template parameter. + + Improved default evaluation strategy for pointers to members. + + GCC 3.4 portability fixes ([#3021](https://svn.boost.org/trac/boost/ticket/3021)). + + Work around Visual C++'s non-std-compliant ciso646 macros. +* [Random](/libs/random/index.html): + + + Made the constructors of all the generators call the copy constructor + when passed a non-const reference. + + Changed seeding functions to accept any arithmetic type. As a side-effect, + the exact signature of seed changed for some classes. + + Major bug fixes in uniform\_int. +* [Serialization](/libs/serialization/index.html): + + + Removed deprecated headers: `boost/static\_warning.hpp`, + `boost/state\_saver.hpp`, `boost/smart\_cast.hpp`, + `boost/pfto.hpp`. Use the the equivalent headers + in the `boost/serialization/` + directory instead ([#3062](https://svn.boost.org/trac/boost/ticket/3062)). + + `detail::archive\_serializer\_map` should now + be used instead of `detail::archive\_pointer\_iserializer`. + For more details see [the + library release notes](/doc/libs/1_40_0/libs/serialization/doc/release.html). +* [Unordered](/libs/unordered/index.html): + + + Implement `emplace` + for all compilers, not just ones with rvalue references and variadic + templates ([#1978](https://svn.boost.org/trac/boost/ticket/1978)). + + Create less buckets by default. + + Some minor tweaks for better compiler support ([#2908](https://svn.boost.org/trac/boost/ticket/2908), + [#3096](https://svn.boost.org/trac/boost/ticket/3096), + [#3082](https://svn.boost.org/trac/boost/ticket/3082)). +* [Xpressive](/libs/xpressive/index.html): + + + Works on Visual C++ 10.0 ([#3124](https://svn.boost.org/trac/boost/ticket/3124)). + +### Build System + The default naming of libraries in Unix-like environment now matches system + conventions, and does not include various decorations. Naming of libraries + on Cygwin was also fixed. Support for beta versions of Microsoft Visual Studio + 10 was added. With gcc, 64-bit compilation no longer requires that target architecture + be specified. + + +### Updated Tools + + +* [Boostbook](/tools/boostbook/index.html): + + + Hide `INTERNAL ONLY` + enums in doxygen documentation ([#3242](https://svn.boost.org/trac/boost/ticket/3242)). + + Tweaked appearance of member classes/structs/unions in a class synopsis. +* [Quickbook](/tools/quickbook/index.html): + + + Support python code snippets ([#3029](https://svn.boost.org/trac/boost/ticket/3029)). + + Add `teletype` source + mode ([#1202](https://svn.boost.org/trac/boost/ticket/1202)) + +### Compilers Tested + Boost's primary test compilers are: + + + +* OS X: + + + GCC 4.0.1 on Intel Tiger and Leopard + + GCC 4.0.1 on PowerPC Tiger +* Linux: + + + GCC 4.3.3 on Ubuntu Linux. +* Windows: + + + Visual C++ 7.1 SP1, 8.0 SP1 and 9.0 SP1 on Windows XP. + Boost's additional test compilers include: + + + +* Linux: + + + Intel 9.0 on Red Hat Enterprise Linux. + + Intel 10.0 on Red Hat Enterprise Linux. + + Intel 10.1 on 64-bit Linux Redhat 5.1 Server. + + Intel 10.1 on Suse Linux on 64 bit Itanium. + + Intel 11.0 on Red Hat Enterprise Linux. + + Intel 11.1 on Red Hat Enterprise Linux. + + GCC 3.4.3, GCC 4.0.1, GCC 4.2.4, GCC 4.3.3 and GCC 4.4.0 on Red Hat + Enterprise Linux. + + GCC 4.3.3 and GCC 4.4.0 with C++0x extensions on Red Hat Enterprise + Linux. + + GCC 4.1.1, 4.2.1 on 64-bit Red Hat Enterprise Linux. + + GCC 4.1.2 on Suse Linux on 64 bit Itanium. + + GCC 4.1.2 on 64-bit Redhat Server 5.1. + + GCC Open64 4.2.2 on Red Hat Enterprise Linux. + + GCC 4.3.4 on Debian unstable. + + QLogic PathScale(TM) Compiler Suite: Version 3.1 on Red Hat Enterprise + Linux. + + GCC version 4.2.0 (PathScale 3.2 driver) on 64-bit Red Hat Enterprise + Linux. + + Sun 5.9 on Red Hat Enterprise Linux. +* OS X: + + + Intel 10.1, 11.0 on Intel Leopard. + + Intel 10.1, 11.0 on Intel Tiger. + + GCC 4.0.1, 4.2.1 on Intel Leopard. + + GCC 4.0.1 on Intel Tiger. + + GCC 4.0.1 on PowerPC Tiger. +* Windows: + + + Visual C++ 7.1 on XP. + + Visual C++ 9.0 on XP. + + Visual C++ 9.0 on Vista. + + Visual C++ 9.0 on Vista 64-bit. + + Visual C++ 9.0, using STLport 5.2, on XP and Windows Mobile 5.0. + + Visual C++ 10.0 beta. + + Borland 5.9.3, 6.1.0, 6.1.3. + + Borland C++ Builder 2007 and 2009. + + Intel C++ 11.1, with a Visual C++ 9.0 backend, on Vista 32-bit. + + Intel C++ 11.1, with a Visual C++ 9.0 backend, on Vista 64-bit. + + GCC 4.3.3 and 4.4.0, on Mingw with C++0x features. +* AIX: + + + IBM XL C/C++ Enterprise Edition for AIX, V10.1.0.0, on AIX Version + 5.3.0.40. +* Solaris: + + + Sun C++ 5.7, 5.8, 5.9 on Solaris 5.10. + + GCC 3.4.6 on Solaris 5.10. + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), and Daniel + James managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_41_0.html b/users/history/version_1_41_0.html new file mode 100644 index 0000000..19b1697 --- /dev/null +++ b/users/history/version_1_41_0.html @@ -0,0 +1,260 @@ +--- +title: Version 1.41.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.41.0 + +/\*\*/ + + + + + + + +Version 1.41.0 +============== + +Version 1.41.0 +-------------- + + +November 17th, 2009 17:00 GMT + + +[Documentation](/doc/libs/1_41_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_41\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.41.0/boost_1_41_0.tar.bz2) | +| [boost\_1\_41\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.41.0/boost_1_41_0.tar.gz) | +| windows | [boost\_1\_41\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.41.0/boost_1_41_0.7z) | +| [boost\_1\_41\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.41.0/boost_1_41_0.zip) | + + +### New Libraries + + +* [Property Tree](/libs/property_tree/index.html): A + tree data structure especially suited to storing configuration data, from + Marcin Kalicinski and Sebastian Redl. + +### Updated Libraries + + +* [DateTime](/libs/date_time/index.html): + + + The default format for time durations is now "`%-%O:%M:%S%F`" + instead of "`%-%H:%M:%S%F`" that was used previously. + In order to retain the old behavior, the format string has to be + specified explicitly during the time IO facet construction ([#1861](https://svn.boost.org/trac/boost/ticket/1861)). + + Gregorian dates now use 32-bit integer type internally on 64-bit + platforms ([#3308](https://svn.boost.org/trac/boost/ticket/3308)). + + See the [full + changelog](/doc/html/date_time/details.html#date_time.changes) for more detail. +* [Filesystem](/libs/filesystem/index.html): + + + Bug fixes: ([#3385](https://svn.boost.org/trac/boost/ticket/3385)). + ([#3528](https://svn.boost.org/trac/boost/ticket/3528)). + ([#3509](https://svn.boost.org/trac/boost/ticket/3509)). +* [Iostreams](/libs/iostreams/index.html): + Some old + unreleased developments. There are still several open issues that should + be fixed in the next version. + + + Add a grep filter ([#1627](https://svn.boost.org/trac/boost/ticket/1627)). + + Support archives with multiple members ([#1896](https://svn.boost.org/trac/boost/ticket/1896)). + + Make `tee` work with + input streams ([#791](https://svn.boost.org/trac/boost/ticket/791)). + + Improved filesystem interoperability. + + Several warnings fixed or suppressed (including [#1618](https://svn.boost.org/trac/boost/ticket/1618), + [#1875](https://svn.boost.org/trac/boost/ticket/1875), + [#2779](https://svn.boost.org/trac/boost/ticket/2779)). + + Various other fixes (including [#1580](https://svn.boost.org/trac/boost/ticket/1580), + [#1671](https://svn.boost.org/trac/boost/ticket/1671)). +* [Math](/libs/math/index.html): + Substantially improved + the performance of the incomplete gamma function and it's inverse: this + enhances the performance of the gamma, poisson, chi-squared and non-central + chi-squared distributions. +* [Multi-index Containers](/libs/multi_index/doc/index.html): + Maintenance + fixes. Consult the library [release + notes](/libs/multi_index/doc/release_notes.html#boost_1_41) for further information. +* [Proto](/libs/proto/index.html): + + + Clean up some MSVC warnings and errors in /Za (disable Microsoft + extensions) mode. + + Fixes for c++0x mode on various compilers. +* [Python](/libs/python/index.html): + Boost.Python + now supports Python 3 (Haoyu Bai's Google Summer of Code project, mentored + by Stefan Seefeld). +* [Regex](/libs/regex/index.html): + Added support + for many Perl 5.10 syntax elements including named sub-expressions, branch + resets and recursive regular expressions. +* [Spirit](/libs/spirit/index.html): This is the + initial official release of the new Spirit V2.1, a completely new library + for parsing, lexing, and output generation. Note: this release is not backwards + compatible with earlier versions. Known issue: `qi::symbol::find` + will match a symbol that starts with the string you're searching for. This + will be fixed in the next version. +* [System](/libs/system/index.html): + + + Bug fix: ([#3559](https://svn.boost.org/trac/boost/ticket/3559)). +* [Thread](/libs/thread/index.html): + + + Support for futures, promises and packaged tasks added + + `boost::thread\_specific\_ptr` is now faster + when there are lots of thread-specific objects + + Some Boost.Thread facilities are now header-only +* [Unordered](/libs/unordered/index.html): + Major + update: + + + Replaced a lot of the macro based implementation with a cleaner template + based implementation. + + Reduced memory use. + + Full details in [the + changelog](/doc/html/unordered/changes.html#unordered.changes.boost_1_41_1). +* [Utility](/libs/utility/index.html): + A "const" + issue of `value\_initialized` + is fixed: Its `data()` + member function and its conversion operator are replaced by overloads for + const and non-const access ([#2548](https://svn.boost.org/trac/boost/ticket/2548)). +* [Wave](/libs/wave/index.html): + See the [changelog](/libs/wave/ChangeLog) + for details. +* [Xpressive](/libs/xpressive/index.html): + + + Fix infinite loop with some uses of \Q...\E quotemeta + ([#3586](https://svn.boost.org/trac/boost/ticket/3586)). + + Eliminate unreachable code warnings on MSVC + + Clean up some MSVC warnings and errors in /Za ("disable Microsoft + extensions") mode. + + Fixes for c++0x mode on various compilers. + +### Build System + A bug preventing "fat" 32-bit + 64-bit builds on OSX has been fixed. + + +### Boost.CMake moved + The cmake version of boost has moved; the Boost.CMmake release will be separate + and will lag the main release slightly, but will also be capable of producing + patch releases as necessary. + + More information on the [Boost + CMake wiki page](https:://svn.boost.org/trac/boost/wiki/CMake). + + +### Updated Tools + + +* [Quickbook 1.5](/tools/quickbook/index.html): + These + changes require your document to use the `[quickbook 1.5]` tag: + + + More intuitive syntax and variable lookup for template calls ([#1174](https://svn.boost.org/trac/boost/ticket/1174), + [#2034](https://svn.boost.org/trac/boost/ticket/2034), + [#2036](https://svn.boost.org/trac/boost/ticket/2036)). + + Image attributes ([#1157](https://svn.boost.org/trac/boost/ticket/1157)) + + Table Ids ([#1194](https://svn.boost.org/trac/boost/ticket/1194)) + + Better handling of whitespace in `section` + syntax. ([#2712](https://svn.boost.org/trac/boost/ticket/2712)) + +### Compilers Tested + Boost's primary test compilers are: + + + +* OS X: + + + GCC 4.0.1 on Intel Tiger and Leopard. + + GCC 4.0.1 on PowerPC Tiger. +* Linux: + + + GCC 4.4.1 on Ubuntu Linux. + + GCC 4.4 on Debian +* Windows: + + + Visual C++ 7.1 SP1, 8.0 SP1 and 9.0 SP1 on Windows XP. + Boost's additional test compilers include: + + + +* Linux: + + + Intel 10.1 on Red Hat Enterprise Linux. + + Intel 10.1 on 64-bit Red Hat Enterprise Linux. + + Intel 10.1 on Suse Linux on 64 bit Itanium. + + Intel 11.0 on 32 bit Red Hat Enterprise Linux. + + Intel 11.0 on 64 bit Red Hat Enterprise Linux. + + Intel 11.1 on 64 bit Red Hat Enterprise Linux. + + Intel 11.1 on 64 bit Linux Redhat 5.1 Server. + + GCC 3.4.3, GCC 4.2.4, GCC 4.3.3 and GCC 4.4.1 on Red Hat Enterprise + Linux. + + GCC 4.3.3 and GCC 4.4.1 with C++0x extensions on Red Hat Enterprise + Linux. + + GCC 4.3.3 on 64-bit Redhat Server 5.1. + + GCC 4.3.3 on 64 bit Linux. + + GCC 4.3.4 on Debian unstable. + + GCC 4.3.2 on 64 bit Gentoo. + + QLogic PathScale(TM) Compiler Suite: Version 3.2 on Red Hat Enterprise + Linux. + + Sun 5.9 on Red Hat Enterprise Linux. +* OS X: + + + Intel C++ Compiler 11.1 on Leopard. + + Intel C++ Compiler 10.1, 11.0. + + GCC 4.0.1 on Intel Tiger. + + GCC 4.0.1 on PowerPC Tiger. +* Windows: + + + Visual C++ 7.1, 8,0, 9,0 on XP. + + Visual C++ 9.0 on 32-bit Vista. + + Visual C++ 9.0 on AMD 64-bit Vista. + + Visual C++ 9.0 using STLport 5.2 on XP and Windows Mobile 5.0. + + Visual C++ 10.0 beta 1 with [a + patch for the program options lib](http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=457199). + + Borland/Codegear C++ 5.9.3, 6.1.3 (2009), 6.2.0 (2010). + + Intel C++ 11.1, with a Visual C++ 9.0 backend, on Vista 32-bit. + + GCC 4.4.1 on Mingw, with and without C++0x extensions. +* AIX: + + + IBM XL C/C++ Enterprise Edition for AIX, V10.1.0.0, on AIX Version + 5.3.0.40. +* FreeBSD: + + + GCC 4.2.1 on FreeBSD 7.0. +* Solaris: + + + Sun C++ 5.10 on Solaris 5.10. + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), and Daniel + James managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_42_0.html b/users/history/version_1_42_0.html new file mode 100644 index 0000000..cf010c0 --- /dev/null +++ b/users/history/version_1_42_0.html @@ -0,0 +1,292 @@ +--- +title: Version 1.42.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.42.0 + +/\*\*/ + + + + + + + +Version 1.42.0 +============== + +Version 1.42.0 +-------------- + + +February 2nd, 2010 14:00 GMT + + +[Documentation](/doc/libs/1_42_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_42\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.42.0/boost_1_42_0.tar.bz2) | +| [boost\_1\_42\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.42.0/boost_1_42_0.tar.gz) | +| windows | [boost\_1\_42\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.42.0/boost_1_42_0.7z) | +| [boost\_1\_42\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.42.0/boost_1_42_0.zip) | + + +### New Libraries + + +* [Uuid](/libs/uuid/index.html): + A universally unique + identifier, from Andy Tompkins. + +### Updated Libraries + + +* [Asio](/libs/asio/index.html): + + + Added a new HTTP Server 4 example illustrating the use of stackless + coroutines with Asio. + + Changed handler allocation and invocation to use `boost::addressof` + to get the address of handler objects, rather than applying `operator&` + directly ([#2977](https://svn.boost.org/trac/boost/ticket/2977)). + + Restricted MSVC buffer debugging workaround to 2008, as it causes + a crash with 2010 beta 2 ([#3796](https://svn.boost.org/trac/boost/ticket/3796), + [#3822](https://svn.boost.org/trac/boost/ticket/3822)). + + Fixed a problem with the lifetime of handler memory, where Windows + needs the `OVERLAPPED` + structure to be valid until both the initiating function call has + returned and the completion packet has been delivered. + + Don't block signals while performing system calls, but instead restart + the calls if they are interrupted. + + Documented the guarantee made by strand objects with respect to order + of handler invocation. + + Changed strands to use a pool of implementations, to make copying + of strands cheaper. + + Ensured that kqueue support is enabled for BSD platforms ([#3626](https://svn.boost.org/trac/boost/ticket/3626)). + + Added a `boost\_` prefix + to the `extern "C"` + thread entry point function ([#3809](https://svn.boost.org/trac/boost/ticket/3809)). + + In `getaddrinfo` emulation, + only check the socket type (`SOCK\_STREAM` + or `SOCK\_DGRAM`) if + a service name has been specified. This should allow the emulation + to work with raw sockets. + + Added a workaround for some broken Windows firewalls that make a + socket appear bound to 0.0.0.0 when it is in fact bound to 127.0.0.1. + + Applied a fix for reported excessive CPU usage under Solaris ([#3670](https://svn.boost.org/trac/boost/ticket/3670)). + + Added some support for platforms that use older compilers such as + g++ 2.95 ([#3743](https://svn.boost.org/trac/boost/ticket/3743)). +* [Circular Buffer](/libs/circular_buffer/index.html): + + + Added methods erase\_begin(size\_type) and erase\_end(size\_type) with + constant complexity for such types of stored elements which do not + need an explicit destruction e.g. int or double. + + Similarly changed implementation of the clear() method and the destructor + so their complexity is now constant for such types of stored elements + which do not require an explicit destruction (the complexity for + other types remains linear). +* [Fusion](/libs/fusion/index.html): + + + The accumulator is the first argument to the functor of `fusion::fold` and `fusion::accumulate` + ([#2355](https://svn.boost.org/trac/boost/ticket/2355)). + + Added support for associative iterators and views ([#3473](https://svn.boost.org/trac/boost/ticket/3473)). +* [Graph](/libs/graph/index.html): + + + Removed old interface to `compressed\_sparse\_row\_graph`, + making new interface the default. +* [Integer](/libs/integer/index.html): + + + Reverted Trunk to release branch state (i.e. a "known good state"). + + Fixed issues: [653](https://svn.boost.org/trac/boost/ticket/653), + [3084](https://svn.boost.org/trac/boost/ticket/3084), + [3177](https://svn.boost.org/trac/boost/ticket/3177), + [3180](https://svn.boost.org/trac/boost/ticket/3180), + [3568](https://svn.boost.org/trac/boost/ticket/3548), + [3657](https://svn.boost.org/trac/boost/ticket/3657), + [2134](https://svn.boost.org/trac/boost/ticket/2134). + + Added long long support to boost::static\_log2, + boost::static\_signed\_min, boost::static\_signed\_max, + boost::static\_unsigned\_minboost::static\_unsigned\_max, + when available. + + The argument type and the result type of boost::static\_signed\_min + etc are now typedef'd. Formerly, they were hardcoded as unsigned + long and int respectively. Please, use + the provided typedefs in new code (and update old code as soon as + possible). +* [Iostreams](/libs/iostreams/index.html): + + + Fixed many outstanding issues. Thanks to Richard Smith for his work + on this. ([#3612](https://svn.boost.org/trac/boost/ticket/3612), + [#3311](https://svn.boost.org/trac/boost/ticket/3311), + [#2094](https://svn.boost.org/trac/boost/ticket/2094), + [#3010](https://svn.boost.org/trac/boost/ticket/3010), + [#2894](https://svn.boost.org/trac/boost/ticket/2894), + [#3011](https://svn.boost.org/trac/boost/ticket/3011), + [#3352](https://svn.boost.org/trac/boost/ticket/3352), + [#3505](https://svn.boost.org/trac/boost/ticket/3505)). + + For more information see the [library + release notes](/libs/iostreams/doc/release_notes.html). +* [Program.Options](/libs/program_options/index.html): + + + Information about option name added to a few exception classes and + various clean ups in exception classes ([#3423](https://svn.boost.org/trac/boost/ticket/3423)). + + Description wordwrapping in presense of default parameters fixed + ([#2613](https://svn.boost.org/trac/boost/ticket/2613)). + + Empty value in configuration file is now permitted ([#1537](https://svn.boost.org/trac/boost/ticket/1537)). + + Quotes are no longer stripped from string values ([#850](https://svn.boost.org/trac/boost/ticket/850)). + + Fix endless loop in case of long default arguments ([#689](https://svn.boost.org/trac/boost/ticket/689)). + + Fix compile warning caused by usage of boost::any ([#2562](https://svn.boost.org/trac/boost/ticket/2562)). + + Fix memory bug in example/response\_file.cpp ([#3525](https://svn.boost.org/trac/boost/ticket/3525)). + + Most compilation warnings were fixed ([#3608](https://svn.boost.org/trac/boost/ticket/3608)). + + Make column width for description text configurable. ([#3703](https://svn.boost.org/trac/boost/ticket/3703)). + + Add general split function: split\_unix() ([#2561](https://svn.boost.org/trac/boost/ticket/2561)). + + Enable open config files from given file name ([#3264](https://svn.boost.org/trac/boost/ticket/3264)). + + Additional flag for required options ([#2982](https://svn.boost.org/trac/boost/ticket/2982)). + + Enable case insensitive style for command line ([#3498](https://svn.boost.org/trac/boost/ticket/3498)). +* [PropertyMap](/libs/property_map/index.html): + + + Removed old header files (directly in the `boost/` directory); they were deprecated + since 1.40, replaced by headers in `boost/property\_map/`. +* [Proto](/libs/proto/index.html): + + + Fix const correctness issues with `proto::flatten` + and friends ([#3364](https://svn.boost.org/trac/boost/ticket/3364)). + + Accomodate recent change to `fusion::fold`, + remove old support for Doxygen and pre-1.35 Fusion ([#3553](https://svn.boost.org/trac/boost/ticket/3553)). + + In binary operations, when one operand has a user-specified domain + and the other has the default domain, the user-specified domain trumps. + + Fix `BOOST\_PROTO\_EXTENDS` + to work with elaborated types. + + Work around EDG compiler bug with function types and cv-qualification. +* [Regex](/libs/regex/index.html): + + + Added support for Functors rather than strings as format expressions. + + Improved error reporting when throwing exceptions to include better + more relevant information. + + Improved performance and reduced stack usage of recursive expressions. + + Fixed tickets [#2802](https://svn.boost.org/trac/boost/ticket/2802), + [#3425](https://svn.boost.org/trac/boost/ticket/3425), + [#3507](https://svn.boost.org/trac/boost/ticket/3507), + [#3546](https://svn.boost.org/trac/boost/ticket/3546), + [#3631](https://svn.boost.org/trac/boost/ticket/3631), + [#3632](https://svn.boost.org/trac/boost/ticket/3632), + [#3715](https://svn.boost.org/trac/boost/ticket/3715), + [#3718](https://svn.boost.org/trac/boost/ticket/3718), + [#3763](https://svn.boost.org/trac/boost/ticket/3763), + [#3764](https://svn.boost.org/trac/boost/ticket/3764) +* [Spirit](/libs/spirit/index.html): + Spirit V2.2, + see the '[What's + New](/doc/libs/1_42_0/libs/spirit/doc/html/spirit/what_s_new.html)' section for details. +* [Unordered](/libs/unordered/index.html): + + + Support instantiating the containers with incomplete value types. + + Add `erase\_return\_void` + as a temporary workaround for the current `erase` + which can be inefficient because it has to find the next element + to return an iterator ([#3693](http://svn.boost.org/trac/boost/ticket/3693)). + + Add templated find overload for compatible keys. + + Improved codegear compatibility. + + Other minor changes, full details in [the + changelog](/doc/html/unordered/changes.html#unordered.changes.boost_1_42_0). +* [Xpressive](/libs/xpressive/index.html): + + + `match\_results` no + longer relies on undefined behavior in `std::list` + ([#3278](https://svn.boost.org/trac/boost/ticket/3278)). + + Do NOT copy singular iterators ([#3538](https://svn.boost.org/trac/boost/ticket/3538)). + + Eliminate gcc and darwin warnings ([#3734](https://svn.boost.org/trac/boost/ticket/3734)). + +### Compilers Tested + Boost's primary test compilers are: + + + +* OS X: + + + GCC 4.0.1 on Intel Leopard. + + GCC 4.0.1 on PowerPC Tiger. +* Linux: + + + GCC 4.4.1 on Ubuntu Linux. + + GCC 4.4 on Debian. +* Windows: + + + Visual C++ 7.1 SP1, 8.0 SP1 and 9.0 SP1 on Windows XP. + + Visual C++ 9.0 on Windows 2008, 64 bit. + + GCC 4.3.3, using Mingw +* FreeBSD: + + + GCC 4.2.1, 32 and 64 bit. + Boost's additional test compilers include: + + + +* Linux: + + + Intel 10.1 on Red Hat Enterprise Linux. + + Intel 10.1 on 64 bit Red Hat Enterprise Linux. + + Intel 11.0 on 32 bit Red Hat Enterprise Linux. + + Intel 11.0 on 64 bit Red Hat Enterprise Linux. + + Intel 11.1 on 64 bit Red Hat Enterprise Linux. + + Intel 11.1 on 64 bit Linux Redhat 5.1 Server. + + Intel 11.1 on Suse Linux 64 bit. + + GCC 3.4.6, GCC 4.2.4, GCC 4.3.4 and GCC 4.4.2 on Red Hat Enterprise + Linux. + + GCC 4.3.4 and GCC 4.4.2 with C++0x extensions on Red Hat Enterprise + Linux. + + GCC 4.4.1 on 64 bit Linux. + + GCC 4.4.3 on Debian unstable. + + QLogic PathScale(TM) Compiler Suite: Version 3.2 on Red Hat Enterprise + Linux. +* OS X: + + + Intel C++ Compiler 10.1, 11.0, 11.1 on Leopard. + + GCC 4.0.1 on Intel Leopard. + + GCC 4.0.1 on PowerPC Tiger. +* Windows: + + + Visual C++ 7.1, 8,0, 9,0 on XP. + + Visual C++ 9.0 using STLport 5.2 on XP and Windows Mobile 5.0. + + Visual C++ 10.0 beta 2. + + Visual C++ 10.0 on 32-bit Vista. + + Borland/Codegear C++ 5.9.3, 6.1.3 (2009), 6.2.1 (2010). + + Intel C++ 11.1, with a Visual C++ 9.0 backend, on Vista 32-bit. + + GCC 4.4.1 on Mingw, with and without C++0x extensions. +* AIX: + + + IBM XL C/C++ Enterprise Edition for AIX, V10.1.0.0, on AIX Version + 5.3.0.40. +* FreeBSD: + + + GCC 4.2.1 on FreeBSD 7.0, 32 bit and 64 bit. +* Solaris: + + + Sun C++ 5.10 on Solaris 5.10. + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James + and Vladimir Prus managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_43_0.html b/users/history/version_1_43_0.html new file mode 100644 index 0000000..7fb9fc1 --- /dev/null +++ b/users/history/version_1_43_0.html @@ -0,0 +1,289 @@ +--- +title: Version 1.43.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.43.0 + +/\*\*/ + + + + + + + +Version 1.43.0 +============== + +Version 1.43.0 +-------------- + + +May 6th, 2010 12:00 GMT + + +[Documentation](/doc/libs/1_43_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_43\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.43.0/boost_1_43_0.tar.bz2) | +| [boost\_1\_43\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.43.0/boost_1_43_0.tar.gz) | +| windows | [boost\_1\_43\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.43.0/boost_1_43_0.7z) | +| [boost\_1\_43\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.43.0/boost_1_43_0.zip) | + + +### New Libraries + + +* [Functional/factory](/libs/functional/factory/index.html): + Function + objects for dynamic and by-value construction, from Tobias Schwinger. +* [Functional/forward](/libs/functional/forward/index.html): + Function + object adapters to address the forwarding problem, from Tobias Schwinger. + +### Major Updates + + +* [Range](/libs/range/index.html): + Boost.Range has + undergone extensive updates that it include all of the features from the + recently reviewed Boost.RangeEx, from Neil Groves. + + + Range-based version of the full STL iterator based algorithms. + + Range adaptors which can be combined with range-based algorithms + for unprecedented expressiveness and efficiency. + + New functions: irange, istream\_range, join, combine. + +### Updated Libraries + + +* [Accumulators](/libs/accumulators/index.html): + + + Avoid premature template evaluation in operator overload return types. +* [Array](/libs/array/index.html): + + + Added support for SunCC compiler. + + Added 'fill' member function. + + Changed exception code to use boost::throw\_exception. +* [Asio](/libs/asio/index.html): + + + Improved performance. + + Reduced compile times. + + Reduced the size of generated code. + + Extended the guarantee that background threads don't call user code + to all asynchronous operations ([#3923](https://svn.boost.org/trac/boost/ticket/3923)). + + Changed to use edge-triggered epoll on Linux. + + Changed to use `timerfd` + for dispatching timers on Linux, when available. + + Changed to use one-shot notifications with kqueue on Mac OS X and + BSD platforms. + + Added a bitmask type `ip::resolver\_query\_base::flags` + as per the TR2 proposal. This type prevents implicit conversion from + `int` to `flags`, allowing the compiler to + catch cases where users incorrectly pass a numeric port number as + the service name. + + Added `#define NOMINMAX` for all Windows compilers. + Users can define `BOOST\_ASIO\_NO\_NOMINMAX` + to suppress this definition ([#3901](https://svn.boost.org/trac/boost/ticket/3901)). + + Fixed a bug where 0-byte asynchronous reads were incorrectly passing + an `error::eof` result to the completion handler + ([#4023](https://svn.boost.org/trac/boost/ticket/4023)). + + Changed the `io\_control()` member functions to always call + `ioctl` on the underlying + descriptor when modifying blocking mode ([#3307](https://svn.boost.org/trac/boost/ticket/3307)). + + Changed the resolver implementation to longer require the typedefs + `InternetProtocol::resolver\_query` + and `InternetProtocol::resolver\_iterator`, + as neither typedef is part of the documented `InternetProtocol` + requirements. The corresponding typedefs in the `ip::tcp`, + `ip::udp` and `ip::icmp` + classes have been deprecated. + + Fixed out-of-band handling for reactors not based on `select()`. + + Added new `BOOST\_ASIO\_DISABLE\_THREADS` + macro that allows Asio's threading support to be independently disabled. + + Minor documentation improvements. +* [Fusion](/libs/fusion/index.html): + + + Added new macros for adapting or defining custom types. See the + [Changelog](/libs/fusion/doc/html/fusion/change_log.html) + for details. +* [Iostreams](/libs/iostreams/index.html): + + + Minor fixes ([#2505](https://svn.boost.org/trac/boost/ticket/2505), + [#3839](https://svn.boost.org/trac/boost/ticket/3839), + [#3953](https://svn.boost.org/trac/boost/ticket/3953), + [#3723](https://svn.boost.org/trac/boost/ticket/3723), + [#3969](https://svn.boost.org/trac/boost/ticket/3969), + [#4135](https://svn.boost.org/trac/boost/ticket/4135)). +* [Multi-index Containers](/libs/multi_index/doc/index.html): + + + [Serialization + of non default constructible values](/libs/serialization/doc/serialization.html#constructors) is now properly supported + through user-provided facilities `save\_construct\_data` + and `load\_construct\_data`. + `multi\_index\_container` + serialization [class + version](/libs/serialization/doc/tutorial.html#versioning) has been bumped from 1 to 2. +* [Proto](/libs/proto/index.html): + + + Minor change in behavior: non-const expression self-assignment creates + an assign node. See Proto's [Release + Notes](/doc/html/proto/appendices.html#boost_proto.appendices.release_notes.boost_1_43) for details. + + Minor change to recommended expression extension mechanism: use + `BOOST\_PROTO\_EXTENDS\_USING\_ASSIGN()`. See Proto's [Release + Notes](/doc/html/proto/appendices.html#boost_proto.appendices.release_notes.boost_1_43) for details. + + Fix error in invocation of callable monomorphic function objects + in Proto transforms. + + Fix misc const correctness issues, work around fusion bug. + + Add non-const function call overloads to proto terminals. + + Add a default constructor to `proto::literal<>`. + + Do not use deprecated config macros. + + Add `proto::assert\_matches()` + function and friends to . + + `functional::make\_expr<>` + and `functional::unpack\_expr<>` + return const-qualified rvalues. + + Add documentation for Expr and Domain concepts. +* [Random](/libs/random/index.html): + + + Put the implementation of random\_device in a compiled lib, and added + Windows support. + + Rewrote the documentation using Quickbook/Doxygen/Boostbook and brought + it up to date. +* [Spirit](/libs/spirit/index.html): + Spirit V2.3, + see the '[What's + New](/doc/libs/1_43_0/libs/spirit/doc/html/spirit/what_s_new/spirit_2_3.html)' section for details. +* [Thread](/libs/thread/index.html): + + + Uses `boost::throw\_exception` for all exceptions + except `thread\_interrupted` + + Added fix for issue 2742 + + Optimizations to mutex locks and `call\_once` +* [Unordered](/libs/unordered/index.html): + + + `erase\_return\_void` + is now `quick\_erase` + ([#3966](http://svn.boost.org/trac/boost/ticket/3966)). +* [Uuid](/libs/uuid/index.html): + + + Split generators into separate files. + + Fixed bug in basic\_random\_generator ([#3971](https://svn.boost.org/trac/boost/ticket/3971)). + + Updated documentation. +* [Wave](/libs/wave/index.html): + See the [Changelog](/libs/wave/ChangeLog) + for details. +* [Xpressive](/libs/xpressive/index.html): + + + Add missing include to . + +### Build System + + +* When cross-compiling to GNU targets, static libraries are properly created. + Previously, using such libraries resulted in Archive has no index + error. +* The naming of DLL and import libraries with gcc compiler on Windows, both + mingw and cygwin, now matches default conventions of those environments. + Previously, the naming scheme was the same as for other Windows compilers. + +### Updated Tools + + +* [Quickbook](/tools/quickbook/index.html): + + + Unicode escape characters. + + Support the UTF-8 byte order mark. + + Disallow `[` in simple + markup. Fixes some errors with mismatched punctuation. + + Add a command line flag (`-D`) to define macros at the command + line. + + Improved post-processor output. + + Check that `[section]` and `[endsect]` + tags are balanced in templates. + +### Compilers Tested + Boost's primary test compilers are: + + + +* OS X: + + + GCC 4.0.1 on Intel Leopard. +* Linux: + + + GCC 4.4.1 on Ubuntu Linux. + + GCC 4.4 on 64-bit Suse. +* Windows: + + + Visual C++ 8.0 SP1 and 9.0 SP1 on Windows XP. + + GCC 4.3.3, using Mingw +* FreeBSD: + + + GCC 4.2.1, 32 and 64 bit. + Boost's additional test compilers include: + + + +* Linux: + + + Intel 10.1, 11.1 on 32 bit Red Hat Enterprise Linux. + + Intel 10.1, 11.0, 11.1 on 64 bit Red Hat Enterprise Linux. + + GCC 3.4.6, 4.2.4, 4.3.4, 4.4.3 on Red Hat Enterprise Linux. + + GCC 4.3.4, 4.4.3 with C++0x extensions on Red Hat Enterprise Linux. + + QLogic PathScale(TM) Compiler Suite: Version 3.2 on Red Hat Enterprise + Linux. +* OS X: + + + Intel C++ Compiler 10.1, 11.0, 11.1 on Leopard. + + GCC 4.0.1 on Intel Leopard. + + Clang from subversion. +* Windows: + + + Visual C++ 8,0, 9,0 on 32-bit XP. + + Visual C++ 9.0 using STLport 5.2 on XP and Windows Mobile 5.0. + + Visual C++ 10.0 on XP. + + Visual C++ 10.0 on 64-bit Windows 7. + + Borland/Codegear C++ 5.9.3, 6.1.3 (2009), 6.2.1 (2010). + + Intel C++ 11.1, with a Visual C++ 9.0 backend, on Vista 32-bit. + + GCC 4.3.3 on Mingw. + + GCC 4.4.3 on Mingw, with and without C++0x extensions. + + GCC 4.5 on Mingw. +* AIX: + + + IBM XL C/C++ Enterprise Edition, V10.1.0.0, on AIX Version 5.3.0.40. +* FreeBSD: + + + GCC 4.2.1 on FreeBSD 7.2, 64 bit. + + GCC 4.2.1 on FreeBSD 8.0, 32 bit. +* Solaris: + + + Sun C++ 5.10 on Solaris 5.10. + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James + and Vladimir Prus managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_44_0.html b/users/history/version_1_44_0.html new file mode 100644 index 0000000..7bbeca3 --- /dev/null +++ b/users/history/version_1_44_0.html @@ -0,0 +1,425 @@ +--- +title: Version 1.44.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.44.0 + +/\*\*/ + + + + + + + +Version 1.44.0 +============== + +Version 1.44.0 +-------------- + + +August 13th, 2010 17:00 GMT + + +[Documentation](/doc/libs/1_44_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_44\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.44.0/boost_1_44_0.tar.bz2) | +| [boost\_1\_44\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.44.0/boost_1_44_0.tar.gz) | +| windows | [boost\_1\_44\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.44.0/boost_1_44_0.7z) | +| [boost\_1\_44\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.44.0/boost_1_44_0.zip) | + + +### New Libraries + + +* [Meta State Machine](/libs/msm/index.html): + High-performance + expressive UML2 finite state machines, from Christophe Henry +* [Polygon](/libs/polygon/index.html): + Booleans/clipping, + resizing/offsetting and more for planar polygons with integral coordinates, + from Lucanus Simonson. + +### Updated Libraries + + +* [Accumulators](/libs/accumulators/index.html): + + + Correct miscellaneous documentation inaccuracies +* [Asio](/libs/asio/index.html): + + + Reduced compile times. (Note that some programs may need to add additional + `#include`s, e.g. + if the program uses `boost::array` + but does not explicitly include ``.) + + Reduced the size of generated code. + + Refactored `deadline\_timer` + implementation to improve performance. + + Improved multiprocessor scalability on Windows by using a dedicated + hidden thread to wait for timers. + + Improved performance of `asio::streambuf` + with `async\_read()` + and `async\_read\_until()`. These read operations now use + the existing capacity of the `streambuf` + when reading, rather than limiting the read to 512 bytes. + + Added optional separate compilation. To enable, add `#include ` + to one source file in a program, then build the program with `BOOST\_ASIO\_SEPARATE\_COMPILATION` + defined in the project/compiler settings. Alternatively, `BOOST\_ASIO\_DYN\_LINK` may be defined + to build a separately-compiled Asio as part of a shared library. + + Added new macro `BOOST\_ASIO\_DISABLE\_FENCED\_BLOCK` + to permit the disabling of memory fences around completion handlers, + even if thread support is enabled. + + Reworked timeout examples to better illustrate typical use cases. + + Ensured that handler arguments are passed as `const` + types. + + Fixed incorrect parameter order in `null\_buffers` + variant of `async\_send\_to` + ([#4170](https://svn.boost.org/trac/boost/ticket/4170)). + + Ensured `unsigned char` + is used with `isdigit` + in `getaddrinfo` emulation + ([#4201](https://svn.boost.org/trac/boost/ticket/4201)). + + Fixed handling of very small but non-zero timeouts ([#4205](https://svn.boost.org/trac/boost/ticket/4205)). + + Fixed crash that occurred when an empty buffer sequence was passed + to a composed read or write operation. + + Added missing `operator+` overload in `buffers\_iterator` + ([#4382](https://svn.boost.org/trac/boost/ticket/4382)). + + Implemented cancellation of `null\_buffers` + operations on Windows. +* [Config](/libs/config/index.html): + + + Added new defect macro, `BOOST\_NO\_COMPLETE\_VALUE\_INITIALIZATION`. + + Added new defect macro `BOOST\_NO\_0X\_HDR\_TYPEINDEX`, + fixes issue [#4274](https://svn.boost.org/trac/boost/ticket/4274). + + Added support for code visibility in GCC. + + Fixed issues [#4385](https://svn.boost.org/trac/boost/ticket/4385), + [#4324](https://svn.boost.org/trac/boost/ticket/4324), + [#4221](https://svn.boost.org/trac/boost/ticket/4221), + [#4182](https://svn.boost.org/trac/boost/ticket/4182), + [#4178](https://svn.boost.org/trac/boost/ticket/4178), + [#4152](https://svn.boost.org/trac/boost/ticket/4152), + [#4115](https://svn.boost.org/trac/boost/ticket/4182). + [#4112](https://svn.boost.org/trac/boost/ticket/4112), + [#4059](https://svn.boost.org/trac/boost/ticket/4059), + [#4041](https://svn.boost.org/trac/boost/ticket/4041), + [#4012](https://svn.boost.org/trac/boost/ticket/4012). +* [Filesystem](/libs/filesystem/index.html): + + + This release contains both version 2 and version 3 of the library. + Version 3 is a major upgrade that will break some existing user code, + so version 2 is the default. Users are encouraged to migrate to version + 3. See '[Version 2](/libs/filesystem/v2/doc/index.htm)' + and '[Version 3](/libs/filesystem/v3/doc/index.htm)' + for more information. + + Fix problems with symbol visibility for shared libraries. + + Fix various minor problems. + + Fixed issues: [#3863](https://svn.boost.org/trac/boost/ticket/3863), + [#4248](https://svn.boost.org/trac/boost/ticket/4248). +* [Foreach](/libs/foreach/index.html): + + + Add `boost/foreach\_fwd.hpp` for forward declarations of + foreach's customization points, fixes [#3998](https://svn.boost.org/trac/boost/ticket/3998). + + Remove out-of-date work-arounds for sun compilers, fixes [#4306](https://svn.boost.org/trac/boost/ticket/4306). +* [Fusion](/libs/fusion/index.html): + + + Added `fusion::reverse\_fold`, `fusion::iter\_fold` + and `fusion::reverse\_iter\_fold` ([#1623](https://svn.boost.org/trac/boost/ticket/1623)). +* [Hash](/libs/functional/hash/index.html): + + + Option to prevent implicit casts when calling the hash function by + defining the macro `BOOST\_HASH\_NO\_IMPLICIT\_CASTS`, + which can avoid some subtle problems. This might be activated by + default in a future version. +* [Iostreams](/libs/iostreams/index.html): + + + Several fixes for file descriptors class, including a breaking change + to the constructors and `open` + methods for `file\_descriptor`, + `file\_descriptor\_source` + and `file\_descriptor\_sink`. + See [the + documentation](/libs/iostreams/doc/classes/file_descriptor.html) for details. The old methods are still available + if you define `BOOST\_IOSTREAMS\_USE\_DEPRECATED` + ([#3323](https://svn.boost.org/trac/boost/ticket/3323), + [#3517](https://svn.boost.org/trac/boost/ticket/3517), + [#4335](https://svn.boost.org/trac/boost/ticket/4335)). + + Fix several issues with compression and decompression ([#2318](https://svn.boost.org/trac/boost/ticket/2318), + [#4091](https://svn.boost.org/trac/boost/ticket/4091), + [#3348](https://svn.boost.org/trac/boost/ticket/3348), + [#2783](https://svn.boost.org/trac/boost/ticket/2783), + [#1579](https://svn.boost.org/trac/boost/ticket/1579), + [#3853](https://svn.boost.org/trac/boost/ticket/3853)). + + And a load more miscellaneous fixes ([#3851](https://svn.boost.org/trac/boost/ticket/3851), + [#3279](https://svn.boost.org/trac/boost/ticket/3279), + [#3689](https://svn.boost.org/trac/boost/ticket/3689), + [#2356](https://svn.boost.org/trac/boost/ticket/2356), + [#2996](https://svn.boost.org/trac/boost/ticket/2996), + [#4102](https://svn.boost.org/trac/boost/ticket/4102), + [#2998](https://svn.boost.org/trac/boost/ticket/2998), + [#1612](https://svn.boost.org/trac/boost/ticket/1612), + [#2325](https://svn.boost.org/trac/boost/ticket/2325)). + + Thanks to Steven Watanabe for almost all these fixes. For more detail + see the [release + notes](/libs/iostreams/doc/release_notes.html). +* [Math](/libs/math/index.html): + + + Fixed incorrect range and support for Rayleigh distribution. +* [MPL](/libs/mpl/index.html): + + + Make `mpl::string` work with `mpl::transform`. +* [Multi-index Containers](/libs/multi_index/doc/index.html): + + + Fixed a bug preventing the use of `modify\_key` + with rollback in [ordered](/libs/multi_index/doc/reference/ord_indices.html#modify_key) + and [hashed](/libs/multi_index/doc/reference/hash_indices.html#modify_key) + indices when `Modifier` + and `Rollback` are + different types (ticket [#4130](https://svn.boost.org/trac/boost/ticket/4130)). +* [Proto](/libs/proto/index.html): + + + **Minor change in behavior:** when using + `proto::and\_` as a transform, apply *all* + transforms but only return the result of applying the last. See Proto's + [Release + Notes](/doc/html/proto/appendices.html#boost_proto.appendices.release_notes.boost_1_44) for details. + + **Minor change in behavior:** `proto::as\_expr` and `proto::as\_child` + no longer run objects that are already proto expressions through + the expression domain's generator. See Proto's [Release + Notes](/doc/html/proto/appendices.html#boost_proto.appendices.release_notes.boost_1_44) for details. + + **Minor change in behavior:** Proto + uses `proto::basic\_expr` instead of `proto::expr` when possible for better compile + times. See Proto's [Release + Notes](/doc/html/proto/appendices.html#boost_proto.appendices.release_notes.boost_1_44) for details. + + Add support for sub-domains. + + Introduce per-domain `as\_expr` + and `as\_child` customization + points to allow for domain-specific customization of variable capture + behavior. + + The `proto::\_default` transform is also a grammar + that matches the expressions the transform knows how to handle. + + Add `proto::\_void`, a no-op primitive transform + that does nothing and returns `void`. + + The `proto::pass\_through` transform doesn't + strip expression wrappers, fixes [#4175](https://svn.boost.org/trac/boost/ticket/4175). + + Const-correctness fixes when invoking proto domains. +* [Regex](/libs/regex/index.html): + + + Fixed issues: [#4309](https://svn.boost.org/trac/boost/ticket/4309), + [#4215](https://svn.boost.org/trac/boost/ticket/4215), + [#4212](https://svn.boost.org/trac/boost/ticket/4212), + [#4191](https://svn.boost.org/trac/boost/ticket/4191), + [#4132](https://svn.boost.org/trac/boost/ticket/4132), + [#4123](https://svn.boost.org/trac/boost/ticket/4123), + [#4114](https://svn.boost.org/trac/boost/ticket/4114), + [#4036](https://svn.boost.org/trac/boost/ticket/4036), + [#4020](https://svn.boost.org/trac/boost/ticket/4020), + [#3941](https://svn.boost.org/trac/boost/ticket/3941), + [#3902](https://svn.boost.org/trac/boost/ticket/3902), + [#3890](https://svn.boost.org/trac/boost/ticket/3890). +* [Spirit](/libs/spirit/index.html): + Spirit V2.4, + see the '[What's + New](/doc/libs/1_44_0/libs/spirit/doc/html/spirit/what_s_new/spirit_2_4.html)' section for details. +* [System](/libs/system/index.html): + + + Change system\_category and generic\_category to functions, to conform + to the C++0x FCD. This change may cause compile errors some user + code; the fix is add "()" to references to system\_category + and generic\_category, so that they become function calls. + + Fix problems with symbol visibility for shared libraries. + + Fixed issues: [#4254](https://svn.boost.org/trac/boost/ticket/4254), + [#3994](https://svn.boost.org/trac/boost/ticket/3994), + [#3474](https://svn.boost.org/trac/boost/ticket/3474). +* [Thread](/libs/thread/index.html): + + + Fixes for miscellaneous trac issues ([#2501](https://svn.boost.org/trac/boost/ticket/2501), + [#4341](https://svn.boost.org/trac/boost/ticket/4341), + [#4363](https://svn.boost.org/trac/boost/ticket/4363), + [#3760](https://svn.boost.org/trac/boost/ticket/3760), + [#3761](https://svn.boost.org/trac/boost/ticket/3761), + [#3611](https://svn.boost.org/trac/boost/ticket/3611), + [#2955](https://svn.boost.org/trac/boost/ticket/2955), + [#4071](https://svn.boost.org/trac/boost/ticket/4071), + [#3195](https://svn.boost.org/trac/boost/ticket/3195), + [#3097](https://svn.boost.org/trac/boost/ticket/3097), + [#2874](https://svn.boost.org/trac/boost/ticket/2874), + [#4316](https://svn.boost.org/trac/boost/ticket/4316), + [#4317](https://svn.boost.org/trac/boost/ticket/4317), + [#4322](https://svn.boost.org/trac/boost/ticket/4322), + [#3244](https://svn.boost.org/trac/boost/ticket/3244), + [#2747](https://svn.boost.org/trac/boost/ticket/2747), + [#4305](https://svn.boost.org/trac/boost/ticket/4305), + [#3195](https://svn.boost.org/trac/boost/ticket/3195), + [#2704](https://svn.boost.org/trac/boost/ticket/2704), + [#2293](https://svn.boost.org/trac/boost/ticket/2293), + [#868](https://svn.boost.org/trac/boost/ticket/868), + [#2918](https://svn.boost.org/trac/boost/ticket/2918), + [#4238](https://svn.boost.org/trac/boost/ticket/4238), + [#3269](https://svn.boost.org/trac/boost/ticket/3269), + [#3178](https://svn.boost.org/trac/boost/ticket/3178), + [#3195](https://svn.boost.org/trac/boost/ticket/3195)). + + Fixes for other miscellaneous issues (remove warnings, support newer + compilers, etc.) +* [TR1](/libs/tr1/index.html): + + + Fixed VC10 support. + + `std::tr1::result\_of` always uses the TR1 ResultOf + protocol, even on compilers that support the C++0x `decltype`-based implementation. +* [Type Traits](/libs/type_traits/index.html): + + + Added support for rvalue references throughout the library, plus + two new traits classes is\_rvalue\_reference and is\_lvalue\_reference. + Fixes [#4407](https://svn.boost.org/trac/boost/ticket/4407) + and [#3804](https://svn.boost.org/trac/boost/ticket/3804). + + Fixed ticket [#3621](https://svn.boost.org/trac/boost/ticket/3621). +* [uBLAS](/libs/numeric/ublas/index.html): + + + New assignment operators to feed in vectors and matrices in many + nice ways ([#4034](http://svn.boost.org/trac/boost/ticket/4034)). + Thank you Nasos + + New doxygen-based [documentation](/libs/numeric/ublas/doc/html/index.html) + + Enable arithmetic operators (+,-,\*,/) to work between ublas containers + of std::complex and integral types ([#3649](http://svn/boost/org/trac/boost/ticket/3649)). + Thank you Neal + + Removed unused variables in functional.hpp ([#4377](http://svn.boost.org/trac/boost/ticket/4377)). + Thank you Marco + + New matrix\_indirect and vector\_indirect views to access elements + with a matrix or vector of indices +* [Utility](/libs/utility/index.html): + + + Added a new template class, [`boost::initialized`](/libs/utility/value_init.htm#initialized), + in order to fix [#3472](https://svn.boost.org/trac/boost/ticket/3472). + + New version of `value\_initialized` no longer calls `memset` when the compiler has implemented + value-initialization completely ([#3869](https://svn.boost.org/trac/boost/ticket/3869)). + + New template `boost::tr1\_result\_of` + that implements the TR1 ResultOf protocol even if `boost::result\_of` + uses the C++0x `decltype`-based + implementation. +* [Uuid](/libs/uuid/index.html): + + + Define `BOOST\_UUID\_NO\_TYPE\_TRAITS` + to remove the dependency on Boost.TypeTraits. + + Stream `operator<<` + handles left, internal, and right manipulators. + + Added `to\_string`, + `to\_wstring` to convert + a uuid to a string. + + Fixed minor bugs in documentation. +* [Wave](/libs/wave/index.html): + See the [Changelog](/libs/wave/ChangeLog) + for details. +* [Xpressive](/libs/xpressive/index.html): + + + Replace non-portable `using` + declarations with `typedef`s + in `nested\_results`. + + Support user-defined assertions with placeholders for non-local variables. + +### Updated tools + + +* [Boostbook](/tools/boostbook/index.html): + + + Significantly faster. + + Improved syntax highlighter. +* [Quickbook](/tools/quickbook/index.html): + + + Use the cygwin 1.7 API for better path handling. + + Improved boostbook generation. + + Tweak the grammar to clean up some edge cases. + + For more detail see the [change + log](/doc/libs/1_44_0/doc/html/quickbook/change_log.html#quickbook.change_log.version_1_5_2___boost_1_44_0). + +### Compilers Tested + Boost's primary test compilers are: + + + +* OS X: + + + GCC 4.0.1 on Intel Leopard. +* Linux: + + + GCC 4.4 on 64-bit Suse. +* Windows: + + + Visual C++ 7.1 SP1, 8.0 SP1, 9.0 SP1 and 10.0. + + GCC 4.3.3, using Mingw. +* FreeBSD: + + + GCC 4.2.1, 32 and 64 bit. + Boost's additional test compilers include: + + + +* Linux: + + + Intel 10.1 on 32 bit Red Hat Enterprise Linux. + + Intel 10.1, 11.0, 11.1 on 64 bit Red Hat Enterprise Linux. + + GCC 3.4.6, 4.2.4, 4.3.4, 4.4.3, 4.5 on Red Hat Enterprise Linux. + + GCC, with C++0x extensions, 4.3.4, 4.4.3, 4.5 on Red Hat Enterprise + Linux. + + GCC 4.4 on 64 bit Suse. + + QLogic PathScale(TM) Compiler Suite: Version 3.2 on Red Hat Enterprise + Linux. + + Clang from subversion (will be released with LLVM 2.8). +* OS X: + + + Intel C++ Compiler 10.1, 11.0, 11.1 on Leopard. + + GCC 4.0.1, 4.2.1 (Apple build). + + GCC 4.4 + + GCC, with C++0x extensions, 4.4 + + Clang from subversion (will be released with LLVM 2.8). +* Windows: + + + Visual C++ 7.1 SP, 8.0, 9.0 on 32-bit XP. + + Visual C++ 9.0 using STLport 5.2 on XP and Windows Mobile 5.0. + + Visual C++ 10.0 on XP. + + Visual C++ 10.0 on 64-bit Windows 7. + + Borland/Codegear C++ 5.9.3, 6.1.3 (2009), 6.2.1 (2010). + + Intel C++ 11.1, with a Visual C++ 9.0 backend, on Vista 32-bit. + + GCC 4.3.3, 4.5 on Mingw. + + GCC, with C++0x extensions, 4.5 on Mingw. +* AIX: + + + IBM XL C/C++ Enterprise Edition, V11.1.0.0, on AIX Version 5.3.0.40. +* FreeBSD: + + + GCC 4.2.1 on FreeBSD 7.2, 64 bit. + + GCC 4.2.1 on FreeBSD 8.0, 32 bit. +* Solaris: + + + Sun C++ 5.10 on Solaris 5.10. + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James + and Vladimir Prus managed this release. + + Thanks to Marshall Clow for organizing the bug sprint and to everyone who took + part. + + + + + + + + + + + + diff --git a/users/history/version_1_45_0.html b/users/history/version_1_45_0.html new file mode 100644 index 0000000..efbecdb --- /dev/null +++ b/users/history/version_1_45_0.html @@ -0,0 +1,322 @@ +--- +title: Version 1.45.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.45.0 + +/\*\*/ + + + + + + + +Version 1.45.0 +============== + +Version 1.45.0 +-------------- + + +November 19th, 2010 16:00 GMT + + +[Documentation](/doc/libs/1_45_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_45\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.45.0/boost_1_45_0.tar.bz2) | +| [boost\_1\_45\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.45.0/boost_1_45_0.tar.gz) | +| windows | [boost\_1\_45\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.45.0/boost_1_45_0.7z) | +| [boost\_1\_45\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.45.0/boost_1_45_0.zip) | + + +### Updated Libraries + + +* [Asio](/libs/asio/index.html): + + + Fixed a problem on kqueue-based platforms where a `deadline\_timer` + may never fire if the `io\_service` + is running in a background thread ([#4568](https://svn.boost.org/trac/boost/ticket/4568)). + + Fixed a const-correctness issue that prevented valid uses of `has\_service<>` + from compiling ([#4638](https://svn.boost.org/trac/boost/ticket/4638)). + + Fixed MinGW cross-compilation ([#4491](https://svn.boost.org/trac/boost/ticket/4491)). + + Removed dependency on deprecated Boost.System functions ([#4672](https://svn.boost.org/trac/boost/ticket/4672)). + + Ensured `close()`/`closesocket()` + failures are correctly propagated ([#4573](https://svn.boost.org/trac/boost/ticket/4573)). + + Added a check for errors returned by `InitializeCriticalSectionAndSpinCount` + ([#4574](https://svn.boost.org/trac/boost/ticket/4574)). + + Added support for hardware flow control on QNX ([#4625](https://svn.boost.org/trac/boost/ticket/4625)). + + Always use `pselect()` on HP-UX, if it is available ([#4578](https://svn.boost.org/trac/boost/ticket/4578)). + + Ensured handler arguments are passed as lvalues ([#4744](https://svn.boost.org/trac/boost/ticket/4744)). + + Fixed Windows build when thread support is disabled ([#4680](https://svn.boost.org/trac/boost/ticket/4680)). + + Fixed a Windows-specific problem where `deadline\_timer` + objects with expiry times set more than 5 minutes in the future may + never expire ([#4745](https://svn.boost.org/trac/boost/ticket/4745)). + + Fixed the `resolver` + backend on BSD platforms so that an empty service name resolves to + port number `0`, as per + the documentation ([#4690](https://svn.boost.org/trac/boost/ticket/4690)). + + Fixed read operations so that they do not accept buffer sequences + of type `const\_buffers\_1` + ([#4746](https://svn.boost.org/trac/boost/ticket/4746)). + + Redefined `Protocol` + and `id` to avoid clashing + with Objective-C++ keywords ([#4191](https://svn.boost.org/trac/boost/ticket/4191)). + + Fixed a `vector` reallocation + performance issue that can occur when there are many active `deadline\_timer` objects ([#4780](https://svn.boost.org/trac/boost/ticket/4780)). + + Fixed the kqueue backend so that it compiles on NetBSD ([#4662](https://svn.boost.org/trac/boost/ticket/4662)). + + Fixed the socket `io\_control()` implementation on 64-bit Mac OS + X and BSD platforms ([#4782](https://svn.boost.org/trac/boost/ticket/4782)). + + Fixed a Windows-specific problem where failures from `accept()` + are incorrectly treated as successes ([#4859](https://svn.boost.org/trac/boost/ticket/4859)). + + Deprecated the separate compilation header `` + in favour of `` ([#4560](https://svn.boost.org/trac/boost/ticket/4560)). +* [Config](/libs/config/index.html): + + + Added new defect macros, `BOOST\_NO\_VARIADIC\_MACROS` + and `BOOST\_NO\_NUMERIC\_LIMITS\_LOWEST`. + + Minor fixes ([#4670](https://svn.boost.org/trac/boost/ticket/4670), + [#4563](https://svn.boost.org/trac/boost/ticket/4563), + [#4474](https://svn.boost.org/trac/boost/ticket/4474), + [#4508](https://svn.boost.org/trac/boost/ticket/4508)). +* [Flyweight](/libs/flyweight/index.html): + + + Fixed a hanging problem with [`intermodule\_holder`](/libs/flyweight/doc/tutorial/configuration.html#intermodule_holder) in Win32 + platforms related to a Boost.Interprocess issue described at ticket + [#4606](https://svn.boost.org/trac/boost/ticket/4606). + + Removed an internal assertion incompatible with program termination + via `std::exit`. +* [Foreach](/libs/foreach/index.html): + + + Fix ambiguitiy by making `auto\_any` + constructor explicit. +* [Fusion](/libs/fusion/index.html): + + + Added `BOOST\_FUSION\_ADAPT\_ADT`, + `BOOST\_FUSION\_ADAPT\_TPL\_ADT`, + `BOOST\_FUSION\_ADAPT\_ASSOC\_ADT` + and `BOOST\_FUSION\_ADAPT\_ASSOC\_TPL\_ADT`. +* [Graph](/libs/graph/index.html): + + + Added Stoer-Wagner min-cut algorithm contributed by Daniel Trebbien. + + Added implicit graph (implicit\_graph) and A\* (astar\_maze) examples + contributed by W. P. McNeill. + + Added bundled property support for graph properties. + + Fixed bugs [#4556](https://svn.boost.org/trac/boost/ticket/4556), + [#4622](https://svn.boost.org/trac/boost/ticket/4622), + [#4631](https://svn.boost.org/trac/boost/ticket/4631), + [#4715](https://svn.boost.org/trac/boost/ticket/4715), + [#4753](https://svn.boost.org/trac/boost/ticket/4753), + [#4758](https://svn.boost.org/trac/boost/ticket/4758) + and [#4793](https://svn.boost.org/trac/boost/ticket/4793) + plus others not in Trac. + + Fixed documentation bugs [#4731](https://svn.boost.org/trac/boost/ticket/4731) + and [#4737](https://svn.boost.org/trac/boost/ticket/4737). +* [Interprocess](/libs/interprocess/index.html): + + + Fixed bugs [#1080](https://svn.boost.org/trac/boost/ticket/1080), + [#3284](https://svn.boost.org/trac/boost/ticket/3284), + [#3439](https://svn.boost.org/trac/boost/ticket/3439), + [#3448](https://svn.boost.org/trac/boost/ticket/3448), + [#3582](https://svn.boost.org/trac/boost/ticket/3582), + [#3682](https://svn.boost.org/trac/boost/ticket/3682), + [#3829](https://svn.boost.org/trac/boost/ticket/3829), + [#3846](https://svn.boost.org/trac/boost/ticket/3846), + [#3914](https://svn.boost.org/trac/boost/ticket/3914), + [#3947](https://svn.boost.org/trac/boost/ticket/3947), + [#3950](https://svn.boost.org/trac/boost/ticket/3950), + [#3951](https://svn.boost.org/trac/boost/ticket/3951), + [#3985](https://svn.boost.org/trac/boost/ticket/3985), + [#4010](https://svn.boost.org/trac/boost/ticket/4010), + [#4417](https://svn.boost.org/trac/boost/ticket/4417), + [#4019](https://svn.boost.org/trac/boost/ticket/4019), + [#4039](https://svn.boost.org/trac/boost/ticket/4039), + [#4218](https://svn.boost.org/trac/boost/ticket/4218), + [#4230](https://svn.boost.org/trac/boost/ticket/4230), + [#4250](https://svn.boost.org/trac/boost/ticket/4250), + [#4297](https://svn.boost.org/trac/boost/ticket/4297), + [#4350](https://svn.boost.org/trac/boost/ticket/4350), + [#4352](https://svn.boost.org/trac/boost/ticket/4352), + [#4426](https://svn.boost.org/trac/boost/ticket/4426), + [#4516](https://svn.boost.org/trac/boost/ticket/4516), + [#4524](https://svn.boost.org/trac/boost/ticket/4524), + [#4557](https://svn.boost.org/trac/boost/ticket/4557), + [#4606](https://svn.boost.org/trac/boost/ticket/4606), + [#4685](https://svn.boost.org/trac/boost/ticket/4685), + [#4694](https://svn.boost.org/trac/boost/ticket/4694). + + Added support for standard rvalue reference move semantics (tested + on GCC 4.5 and VC10). + + Permissions can be detailed for interprocess named resources. + + `mapped\_region::flush` initiates disk flushing but + does not guarantee it's completed when returns, since it is not portable. + + FreeBSD and MacOS now use posix semaphores to implement named semaphores + and mutex. +* [Math](/libs/math/index.html): + + + Added inverse gamma distribution and inverse chi\_square and scaled + inverse chi\_square. + + Added warnings about potential ambiguity with std random library + in distribution and function names. + + Editorial revision of documentation, and added FAQ. +* [Meta State Machine](/libs/msm/index.html): + + + [Support + for serialization](/doc/libs/1_45_0/libs/msm/doc/HTML/ch08.html#d0e2995). + + [Possibility + to use normal](/doc/libs/1_45_0/libs/msm/doc/HTML/ch03s04.html#eUML-reuse-functor) functors (from functor front-end) in eUML. + + [New + constructors where substates / submachines can be taken as arguments](/doc/libs/1_45_0/libs/msm/doc/HTML/ch03s05.html#backend-fsm-constructor-args). + This allows passing arguments to the constructor of a submachine. + + Bugfixes (anonymous transitions) +* [MultiArray](/libs/multi_array/index.html): + + + Fixes for bugs [#3581](https://svn.boost.org/trac/boost/ticket/3581), + [#3820](https://svn.boost.org/trac/boost/ticket/3820), + [#3989](https://svn.boost.org/trac/boost/ticket/3989), + [#4032](https://svn.boost.org/trac/boost/ticket/4032), + plus other bugs not in Trac. + + Added new examples and test cases. +* [Proto](/libs/proto/index.html): + + + Knock down value of `proto::N`, + fixes bug [#4602](https://svn.boost.org/trac/boost/ticket/4602), + + Support non-rtti compilers + + Fix bug with `proto::matches`, + array types and the wildcard pattern. + + Make Proto work on MSVC with the /clr option + + Add const-qualified overloads of `proto::eval` +* [Spirit](/libs/spirit/index.html): + Spirit V2.4.1, + see the '[What's + New](/doc/libs/1_45_0/libs/spirit/doc/html/spirit/what_s_new/spirit_2_4_1.html)' section for details. +* [TypeTraits](/libs/type_traits/index.html): + + + Added new traits add\_rvalue\_reference, add\_lvalue\_reference and common\_type. + + Minor fixes to is\_signed, is\_unsigned and is\_virtual\_base\_of. +* [uBLAS](/libs/numeric/ublas/index.html): + + + Tickets closed: + + - [#4410](https://svn.boost.org/trac/boost/ticket/4410), + - [#3397](https://svn.boost.org/trac/boost/ticket/3397), + - [#795](https://svn.boost.org/trac/boost/ticket/795), + - [#3514](https://svn.boost.org/trac/boost/ticket/3514), + + Mixed types operation are possible and new tests added (like matrix+matrix), + + New features: + + - a new size<> operator is available. For example size<1>(A+B) + give the number of rows of the sum of matrices A and B, +* [Unordered](/libs/unordered/index.html): + + + Fix inserting from iterators which return by copy from `operator\*` + in `boost::unordered\_map` and `boost::unordered\_set`. +* [Wave](/libs/wave/index.html): + + + See the [Changelog](/libs/wave/ChangeLog) for details. +* [Xpressive](/libs/xpressive/index.html): + + + `xpressive::as` handles wide-char `sub\_match` objects, fixes bug [#4496](https://svn.boost.org/trac/boost/ticket/4496) + +### Updated Tools + + +* [Boostbook](/tools/boostbook/index.html): + + + Fix syntax highlighter for comments at the end of code blocks. +* [Quickbook](/tools/quickbook/index.html): + + + Fix command line macros. + + Nested code snippets. + + Nested documentation info comments. + + Revert xml escaping document info, it broke some documentation files + (will now be in 1.6). + + Some other small tweaks. See [the + change log](/doc/html/quickbook/change_log.html#quickbook.change_log.releases.version_1_5_3___boost_1_45_0) for more info. + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + GCC: 3.4.6, 4.2.4, 4.3.4, 4.4.3, 4.4.5, 4.5.1. + + GCC, C++0x mode: 4.3.4, 4.4.3, 4.5.0. + + Intel: 10.1, 11.0, 11.1 + + Pathscale: 3.2. +* OS X: + + + GCC: 4.0.1, 4.2.1, 4.4 + + GCC, C++0x mode: 4.4. + + Intel: 11.1 +* Windows: + + + Visual C++: 7.1, 8.0, 9.0 and 10.0. + + GCC, mingw: 4.3.3. +* FreeBSD: + + + GCC: 4.2.1, 32 bit. + + GCC: 4.2.1, 64 bit. + Boost's additional test compilers include: + + + +* Linux: + + + GCC: 3.4.6, 4.2.4, 4.3.4, 4.4.3, 4.4.5, 4.5.0, 4.6.0 (dev version). + + GCC, C++0x mode: 4.3.4, 4.4.3, 4.5.0. + + Intel: 10.1, 11.0, 11.1. + + pgCC 10.1. + + PathScale: 3.2. + + Clang from subversion. +* OS X: + + + Intel C++ Compiler: 10.1, 11.0, 11.1. + + GCC: 4.0.1, 4.2.1, 4.4.4 + + GCC, C++0x mode: 4.4.4 + + Clang from subversion. +* Windows: + + + Borland: 5.9.3, 6.1.3 (2009), 6.2.1 (2010), 6.3.0 + + GCC, mingw: 4.3.3, 4.4.5, 4.5.1 + + GCC, mingw, C++0x mode: 4.5.1 + + Visual C++: 7.1, 8.0, 9.0, 10.0 +* AIX: + + + IBM XL C/C++ Enterprise Edition, V11.1.0.0. +* FreeBSD: + + + GCC 4.2.1, 64 bit. +* Solaris: + + + Sun C++: 5.10. + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James + and Vladimir Prus managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_46_0.html b/users/history/version_1_46_0.html new file mode 100644 index 0000000..4b9d606 --- /dev/null +++ b/users/history/version_1_46_0.html @@ -0,0 +1,320 @@ +--- +title: Version 1.46.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.46.0 + +/\*\*/ + + + + + + + +Version 1.46.0 +============== + +Version 1.46.0 +-------------- + + +February 21st, 2011 20:36 GMT + + +[Documentation](/doc/libs/1_46_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_46\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.46.0/boost_1_46_0.tar.bz2) | +| [boost\_1\_46\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.46.0/boost_1_46_0.tar.gz) | +| windows | [boost\_1\_46\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.46.0/boost_1_46_0.7z) | +| [boost\_1\_46\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.46.0/boost_1_46_0.zip) | + + +### New Libraries + + +* [Icl](/libs/icl/index.html): + Interval Container + Library, interval sets and maps and aggregation of associated values, from + Joachim Faulhaber. + +### Updated Libraries + + +* [Array](/libs/array/index.html): + + + Added support for cbegin/cend ([#4761](https://svn.boost.org/trac/boost/ticket/4761)) + + Fixed a problem with the Sun compiler ([#4757](https://svn.boost.org/trac/boost/ticket/4757)) +* [Asio](/libs/asio/index.html): + + + Fixed an integer overflow problem that occurs when `ip::address\_v4::broadcast()` + is used on 64-bit platforms. + + Fixed a problem on older Linux kernels (where epoll is used without + timerfd support) that prevents timely delivery of deadline\_timer + handlers, after the program has been running for some time ([#5045](https://svn.boost.org/trac/boost/ticket/5045)). +* [Bind](/libs/bind/index.html): + + + `make\_adaptable` now + documented ([#4532](https://svn.boost.org/trac/boost/ticket/4532)) +* [Concept Check](/libs/concept_check/index.html): + + + fixed warnings with self-assignment ([#4918](https://svn.boost.org/trac/boost/ticket/4918)) +* [Filesystem](/libs/filesystem/index.html): + + + Version 3 of the library is now the default. + + IBM vacpp: Workaround for compiler bug affecting `iterator\_facade`. + ([#4912](https://svn.boost.org/trac/boost/ticket/4912)) + + Verify, clarify, document that `` + can be used to specify `BOOST\_FILESYSTEM\_VERSION`. + ([#4891](https://svn.boost.org/trac/boost/ticket/4891)) + + Replaced C-style `assert` + with `BOOST\_ASSERT`. + + Undeprecated `unique\_path()`. Instead, add a note mentioning + the workaround for lack of thread safety and possible change to cwd. + `unique\_path()` + is just too convenient to deprecate! + + Cleared several GCC warnings. + + Changed V2 code to use `BOOST\_THROW\_EXCEPTION`. + + Windows: Fix `status()` to report non-symlink reparse point + correctly. + + Add `symlink\_option` + to `recursive\_directory\_iterator`, + allowing control over recursion into directory symlinks. Note that + the default is changed to not recurse into directory symlinks. + + Reference documentation cleanup, including fixing missing and broken + links, and adding missing functions. + + Miscellaneous implementation code cleanup. +* [Fusion](/libs/fusion/index.html): + + + vector copy constructor now copies sequence members in the same order + on different platforms ([#2823](https://svn.boost.org/trac/boost/ticket/2823)) +* [Graph](/libs/graph/index.html): + + + Fixed Graphviz output to work on Visual C++ 7.1. + + Replaced assert with `BOOST\_ASSERT`. + + Changed to Boost.Filesystem v3. + + Fixed the following bugs from Trac: [#1021](https://svn.boost.org/trac/boost/ticket/1021), + [#4556](https://svn.boost.org/trac/boost/ticket/4556), + [#4631](https://svn.boost.org/trac/boost/ticket/4631), + [#4642](https://svn.boost.org/trac/boost/ticket/4642), + [#4715](https://svn.boost.org/trac/boost/ticket/4715), + [#4731](https://svn.boost.org/trac/boost/ticket/4731), + [#4737](https://svn.boost.org/trac/boost/ticket/4737), + [#4753](https://svn.boost.org/trac/boost/ticket/4753), + [#4758](https://svn.boost.org/trac/boost/ticket/4758), + [#4793](https://svn.boost.org/trac/boost/ticket/4793), + [#4843](https://svn.boost.org/trac/boost/ticket/4843), + [#4851](https://svn.boost.org/trac/boost/ticket/4851), + [#4852](https://svn.boost.org/trac/boost/ticket/4852), + [#4887](https://svn.boost.org/trac/boost/ticket/4887), + [#4914](https://svn.boost.org/trac/boost/ticket/4914), + [#4966](https://svn.boost.org/trac/boost/ticket/4966). + + Fixed various bugs not in Trac. +* [Hash](/libs/functional/hash/index.html): + + + Support for `std::type\_index` ([#4756](https://svn.boost.org/trac/boost/ticket/4756)). + + Avoid `-Wconversion` + warnings. +* [Iostreams](/libs/iostreams/index.html): + + + Use `BOOST\_ASSERT` + instead of `assert`. + + Fixed flush regression ([#4590](https://svn.boost.org/trac/boost/ticket/4590)). +* [Iterator](/libs/iterator/index.html): + + + fixed problem with `implicit\_cast` + ([#3645](https://svn.boost.org/trac/boost/ticket/3645)) +* [Math](/libs/math/doc/sf_and_dist/html/index.html): + + + Added Wald, Inverse Gaussian and geometric distributions. + + Added information about configuration macros. + + Added support for mpreal as a real-numered type. +* [Meta State Machine](/libs/msm/index.html): + + + [Compile-time + state machine analysis](/doc/libs/1_46_0/libs/msm/doc/HTML/ch03s05.html#backend-compile-time-analysis). + + [Boost.Parameter + interface definition for `msm::back::state\_machine<>` template arguments](/doc/libs/1_46_0/libs/msm/doc/HTML/ch03s05.html#backend-boost-parameter). + + [Possibility + to provide a container for the event and deferred event queues](/doc/libs/1_46_0/libs/msm/doc/HTML/ch03s05.html#backend-queues). + A policy implementation based on a more efficient Boost.CircularBuffer + is provided. + + `msm::back::state\_machine<>::is\_flag\_active` method made const. + + [Added + possibility to enqueue events for delayed processing](/doc/libs/1_46_0/libs/msm/doc/HTML/ch03s05.html#backend-enqueueing). + + Bugfixes + + - [#4926](https://svn.boost.org/trac/boost/ticket/4926). + - stack overflow using the Defer functor + - anonymous transition of a submachine not called for the initial + state +* [Optional](/libs/optional/index.html): + + + Updated test results with information about expected failures ([#2294](https://svn.boost.org/trac/boost/ticket/2294)) +* [Pool](/libs/pool/index.html): + + + Now can set a max\_size for pool ([#2696](https://svn.boost.org/trac/boost/ticket/2696)) + + `boost/pool/pool.hpp` uses `reinterpret\_cast` + instead of `static\_cast` + ([#2941](https://svn.boost.org/trac/boost/ticket/2941)) + + `boost::pool\_allocator` now works with vector + of vectors ([#386](https://svn.boost.org/trac/boost/ticket/386)) + + Boost pool is now compatible with Microsoft memory leak detection + ([#4346](https://svn.boost.org/trac/boost/ticket/4346)) +* [Program Options](/libs/program_options/index.html): + + + Fixed errors in examples in docs ([#3992](https://svn.boost.org/trac/boost/ticket/3992), + [#4858](https://svn.boost.org/trac/boost/ticket/4858)) + + Now takes `argv` as + const ([#3909](https://svn.boost.org/trac/boost/ticket/3909)) +* [Proto](/libs/proto/index.html): + + + **Breaking change**: `boost/proto/core.hpp` + no longer defines `functional::pop\_front` + and `functional::reverse`, which have moved to their + own headers under `boost/proto/functional` + + Add callable wrappers for more Fusion algorithms (including `fusion::at`); and callable wrappers for + some std utilities like `make\_pair`, + `first` and `second`, all under the new `boost/proto/functional` directory + + Allow transforms to be specified separately from a grammar + + `proto::matches` preserves domain-specific + expression wrappers + + Fix ADL issue with `operator,` in `proto::and\_` + transform + + Fix handling of grammar checking in expressions involving multiple + domains ([#4675](https://svn.boost.org/trac/boost/ticket/4675)) + + Fix ambiguous `operator<<` in `proto::display\_expr` + ([#4910](https://svn.boost.org/trac/boost/ticket/4910)) + + `fusion::is\_sequence` answers true for Proto + expressions ([#5006](https://svn.boost.org/trac/boost/ticket/5006)) + + Eliminate `-Wundef` + GCC warning in `boost/proto/fusion.hpp` + ([#5075](https://svn.boost.org/trac/boost/ticket/5075)) +* [Signals](/libs/signals/index.html): + + + gcc warning cleanup ([#4365](https://svn.boost.org/trac/boost/ticket/4365)) +* [Spirit](/libs/spirit/index.html): + + + Spirit V2.4.2, see the '[What's + New](/doc/libs/1_46_0/libs/spirit/doc/html/spirit/what_s_new/spirit_2_4_2.html)' section for details. +* [Tokenizer](/libs/tokenizer/index.html): + + + `isspace`/`ispunct` was called with wrong character + type ([#4791](https://svn.boost.org/trac/boost/ticket/4791)) +* [Unordered](/libs/unordered/index.html): + + + Avoid using `operator&` with the value type. + + Avoid `-Wconversion` + warnings. +* [Wave](/libs/wave/index.html): + + + See the [Changelog](/libs/wave/ChangeLog) for details. + +### Updated Tools + + +* [Boostbook](/tools/boostbook/index.html): + + + Better support for attributes on root elements - including `lang`. +* [Inspect](/tools/inspect/index.html): + + + Check that Boost headers do not use C's `assert` + macro. +* [Quickbook](/tools/quickbook/index.html): + + + Add support for `lang` + attribute in documentation info. + + Improved anchors. + + Support `import`, + `include` and `xinclude` in conditional phrases. + + Uses Filesystem 3. + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + GCC: 3.4.6, 4.2.4, 4.3.4, 4.4.3, 4.4.5, 4.5.2, + + GCC, C++0x mode: 4.3.4, 4.4.3, 4.5.0, 4.5.2 + + Intel: 10.1, 11.0, 11.1 + + Clang: 2.8 + + Pathscale: 3.2. +* OS X: + + + GCC: 4.0.1, 4.2.1, 4.4 + + GCC, C++0x mode: 4.4. + + Intel: 11.1 +* Windows: + + + Visual C++: 7.1, 8.0, 9.0 and 10.0. + + GCC, mingw: 4.4.0. +* FreeBSD: + + + GCC: 4.2.1, 64 bit. + Boost's additional test compilers include: + + + +* Linux: + + + GCC: 3.4.6, 4.2.4, 4.3.4, 4.3.5, 4.4.3, 4.4.5, 4.5.0, 4.5.2 + + GCC, C++0x mode: 4.3.4, 4.4.3, 4.5.0, 4.5.2 + + pgCC 11.1 + + Intel: 10.1, 11.0, 11.1 + + PathScale: 3.2, 4.0 + + Visual Age C++ 10.1 + + Clang from subversion +* OS X: + + + Intel C++ Compiler: 10.1, 11.0, 11.1 + + GCC: 4.0.1, 4.2.1, 4.4.4 + + GCC, C++0x mode: 4.4.4 + + Clang from subversion +* Windows: + + + Visual C++: 7.1, 8.0, 9.0, 10.0 + + Visual C++ with STLport: 9.0 + + Visual C++, Windows Mobile 5, with STLport: 9.0 + + GCC, mingw: 4.4.0, 4.5.1, 4.6.0 + + GCC, mingw, C++0x mode: 4.5.1 + + Borland: 6.1.3 (2009), 6.2.1 (2010) +* AIX: + + + IBM XL C/C++ Enterprise Edition, V11.1.0.0 +* FreeBSD: + + + GCC 4.2.1, 64 bit +* Solaris: + + + Sun C++: 5.10 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James + and Vladimir Prus managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_46_1.html b/users/history/version_1_46_1.html new file mode 100644 index 0000000..9ec3a3c --- /dev/null +++ b/users/history/version_1_46_1.html @@ -0,0 +1,190 @@ +--- +title: Version 1.46.1 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.46.1 + +/\*\*/ + + + + + + + +Version 1.46.1 +============== + +Version 1.46.1 +-------------- + + +March 12th, 2011 15:45 GMT + + +[Documentation](/doc/libs/1_46_1/) + + +Downloads| Platform | File | +| unix | [boost\_1\_46\_1.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.46.1/boost_1_46_1.tar.bz2) | +| [boost\_1\_46\_1.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.46.1/boost_1_46_1.tar.gz) | +| windows | [boost\_1\_46\_1.7z](http://sourceforge.net/projects/boost/files/boost/1.46.1/boost_1_46_1.7z) | +| [boost\_1\_46\_1.zip](http://sourceforge.net/projects/boost/files/boost/1.46.1/boost_1_46_1.zip) | + + +### Updated Libraries + + +* [Asio](/libs/asio/): + + + `EV\_ONESHOT` seems + to cause problems on some versions of Mac OS X, with the `io\_service` destructor getting stuck + inside the `close()` system call. Changed the kqueue + backend to use `EV\_CLEAR` + instead ([#5021](https://svn.boost.org/trac/boost/ticket/5021)). + + Fixed compile failures with some versions of g++ + due to the use of anonymous enums ([#4883](https://svn.boost.org/trac/boost/ticket/4883)). + + Fixed a bug on kqueue-based platforms, where some system calls that + repeatedly fail with `EWOULDBLOCK` + are not correctly re-registered with kqueue. + + Changed `asio::streambuf` to ensure that its internal + pointers are updated correctly after the data has been modified using + `std::streambuf` member functions. + + Fixed a bug that prevented the linger socket option from working + on platforms other than Windows. +* [Fusion](/libs/fusion/): + + + Fix `disable\_if` for + Visual C++ 7.1/8.0 +* [Filesystem](/libs/filesystem/): + + + Fix for STLPort ([#5217](https://svn.boost.org/trac/boost/ticket/5217)). + + PGI large file support +* [Graph](/libs/graph/): + + + Bug fixes, including fixes for: [#5181](https://svn.boost.org/trac/boost/ticket/5181), + [#5180](https://svn.boost.org/trac/boost/ticket/5180), + [#5199](https://svn.boost.org/trac/boost/ticket/5199) + and [#5175](https://svn.boost.org/trac/boost/ticket/5175). +* [Icl](/libs/icl/): + + + Intersects for interval\_maps and segment\_type/element\_type ([#5207](https://svn.boost.org/trac/boost/ticket/5207)). + + Fixed some ambiguous calls to functions in boost and std namespaces. + + Other bug fixes, and documentation fixes. +* [Math](/libs/math/): + + + Several minor bug fixes. +* [Polygon](/libs/polygon/): + + + Disabled 45-degree booleans optimization. +* [Proto](/libs/proto/): + + + Make `display\_expr` + copyable ([#5096](https://svn.boost.org/trac/boost/ticket/5096)). + + Fix const correctness problem in `pass\_through`. +* [Property Tree](/libs/property_tree/): + + + Fix compile error in JSON parser. +* [Signals2](/libs/signals2/): + + + Fix unused parameter warning. +* [TR1](/libs/tr1/): + + + Allow specialization of `std::tr1::hash`. + + Improved support for Pathscale and Sun compilers. +* [Unordered](/libs/unordered/): + + + Add missing copy constructors and assignment operators when using + rvalue references ([#5119](https://svn.boost.org/trac/boost/ticket/5119)). + +### Other changes + + +* Update getting started guide to reflect changes to boost build. +* In quickbook, workaround optimization bug in g++ 4.4. + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + GCC: 3.4.6, 4.2.4, 4.3.4, 4.4.1, 4.4.3, 4.4.5, 4.5.2 + + GCC, C++0x mode: 4.3.4, 4.4.3, 4.5.2 + + Intel: 10.1, 11.0, 11.1 + + Clang: 2.8 + + Pathscale: 3.2 +* OS X: + + + GCC: 4.0.1, 4.2.1, 4.4 + + GCC, C++0x mode: 4.4. + + Intel: 11.1 +* Windows: + + + Visual C++: 7.1, 8.0, 9.0 and 10.0. + + GCC, mingw: 4.4.0. +* FreeBSD: + + + GCC: 4.2.1, 64 bit. + Boost's additional test compilers include: + + + +* Linux: + + + GCC: 3.4.6, 4.2.4, 4.3.4, 4.4.3, 4.4.4, 4.4.5, 4.5.2 + + GCC, C++0x mode: 4.3.4, 4.4.3, 4.5.2 + + pgCC: 11.2 + + Intel: 10.1, 11.0, 11.1 + + PathScale: 3.2, 4.0.8 + + Visual Age C++: 10.1 + + Clang from subversion +* OS X: + + + Intel C++ Compiler: 10.1, 11.0, 11.1 + + GCC: 4.0.1, 4.2.1, 4.4.4 + + GCC, C++0x mode: 4.4.4 + + Clang from subversion, with GNU libstdc++, libc++ and libc++ in C++0x + mode. +* Windows: + + + Visual C++: 7.1, 9.0, 10.0 + + Visual C++ with STLport: 9.0 + + Visual C++, Windows Mobile 5, with STLport: 9.0 + + GCC, mingw: 4.5.1 + + GCC, mingw, C++0x mode: 4.5.1 + + Borland: 6.1.3 (2009), 6.2.1 (2010) +* AIX: + + + IBM XL C/C++ Enterprise Edition, V11.1.0.0 +* Solaris: + + + Sun C++: 5.10 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James + and Vladimir Prus managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_47_0.html b/users/history/version_1_47_0.html new file mode 100644 index 0000000..4f34888 --- /dev/null +++ b/users/history/version_1_47_0.html @@ -0,0 +1,453 @@ +--- +title: Version 1.47.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.47.0 + +/\*\*/ + + + + + + + +Version 1.47.0 +============== + +Version 1.47.0 +-------------- + + +July 11th, 2011 22:19 GMT + + +[Documentation](/doc/libs/1_47_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_47\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.47.0/boost_1_47_0.tar.bz2) | +| [boost\_1\_47\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.47.0/boost_1_47_0.tar.gz) | +| windows | [boost\_1\_47\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.47.0/boost_1_47_0.7z) | +| [boost\_1\_47\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.47.0/boost_1_47_0.zip) | + + +### New Libraries + + +* [Chrono](/libs/chrono/index.html): + Useful time + utilities, from Vicente J. Botet Escribá. +* [Geometry](/libs/geometry/index.html): + Geometry + Library, from Barend Gehrels, Bruno Lalande and Mateusz Loskot. +* [Phoenix](/libs/phoenix/index.html): + Define small + unnamed function objects at the actual call site, and more, from Joel de + Guzman, Dan Marsden and Thomas Heller. +* [Ratio](/libs/ratio/index.html): + Compile time rational + arithmetic, from Vicente J. Botet Escribá. + +### Updated Libraries + + +* [Accumulators](/libs/accumulators/index.html): + + + New statistical accumulators: `sum\_kahan`, + `sum\_of\_weights\_kahan`, + `sum\_of\_variates\_kahan`. +* [Asio](/libs/asio/index.html): + + + Many new features and improvements: + + - Signal handling. + - A debugging aid for asynchronous programs. + - Timeouts on socket iostreams. + - Composed connect operations. + - Rewritten SSL implementation. + - C++0x move support. + - Compatibility with POSIX `fork()`. + - ... and much more. See the [Revision + History](/doc/libs/1_47_0/doc/html/boost_asio/history.html) in the Boost.Asio documentation for more details. + + Tickets addressed: [#2879](https://svn.boost.org/trac/boost/ticket/2879), + [#3238](https://svn.boost.org/trac/boost/ticket/3238), + [#3297](https://svn.boost.org/trac/boost/ticket/3297), + [#3307](https://svn.boost.org/trac/boost/ticket/3307), + [#3702](https://svn.boost.org/trac/boost/ticket/3702), + [#3741](https://svn.boost.org/trac/boost/ticket/3741), + [#3900](https://svn.boost.org/trac/boost/ticket/3900), + [#3905](https://svn.boost.org/trac/boost/ticket/3905), + [#3939](https://svn.boost.org/trac/boost/ticket/3939), + [#3958](https://svn.boost.org/trac/boost/ticket/3958), + [#4162](https://svn.boost.org/trac/boost/ticket/4162), + [#4971](https://svn.boost.org/trac/boost/ticket/4971), + [#5124](https://svn.boost.org/trac/boost/ticket/5124), + [#5128](https://svn.boost.org/trac/boost/ticket/5128), + [#5418](https://svn.boost.org/trac/boost/ticket/5418), + [#5453](https://svn.boost.org/trac/boost/ticket/5453). +* [Config](/libs/config/index.html): + + + Fixed bug [#1988](https://svn.boost.org/trac/boost/ticket/1988) +* [DateTime](/libs/date_time/index.html): + + + Fixed bugs [#4920](https://svn.boost.org/trac/boost/ticket/4920), + [#3651](https://svn.boost.org/trac/boost/ticket/3651), + [#4845](https://svn.boost.org/trac/boost/ticket/4845), + [#4475](https://svn.boost.org/trac/boost/ticket/4475), + [#4952](https://svn.boost.org/trac/boost/ticket/4952), + [#5345](https://svn.boost.org/trac/boost/ticket/5345), + [#5250](https://svn.boost.org/trac/boost/ticket/5250), + [#4798](https://svn.boost.org/trac/boost/ticket/4798), + [#4754](https://svn.boost.org/trac/boost/ticket/4754), + [#4411](https://svn.boost.org/trac/boost/ticket/4411), + [#5126](https://svn.boost.org/trac/boost/ticket/5126), + [#4780](https://svn.boost.org/trac/boost/ticket/4780), + [#2475](https://svn.boost.org/trac/boost/ticket/2475), + [#1674](https://svn.boost.org/trac/boost/ticket/1674). +* [Dynamic Bitset](/libs/dynamic_bitset/index.html): + + + Fixed bug [#5439](https://svn.boost.org/trac/boost/ticket/5439) +* [Foreach](/libs/foreach/index.html): + + + Use rvalue refs on supporting compilers for const rvalue detection. +* [Function](/libs/function/index.html): + + + Bug fixes: [#3410](https://svn.boost.org/trac/boost/ticket/3410), + [#3618](https://svn.boost.org/trac/boost/ticket/3618), + [#3912](https://svn.boost.org/trac/boost/ticket/3912), + [#4073](https://svn.boost.org/trac/boost/ticket/4073), + [#4325](https://svn.boost.org/trac/boost/ticket/4325), + [#4717](https://svn.boost.org/trac/boost/ticket/4717), + [#4765](https://svn.boost.org/trac/boost/ticket/4765). +* [Function Types](/libs/function_types/index.html): + + + Bug fixes: [#1653](https://svn.boost.org/trac/boost/ticket/1653), + [#3162](https://svn.boost.org/trac/boost/ticket/3162). +* [Graph](/libs/graph/index.html): + + + Bug fixes. + + Remove deprecated function `kolmogorov\_max\_flow`, + use `boykov\_kolmogorov\_max\_flow` + instead. + + Removed `` header since its functionality + is in Boost.Type\_Traits. +* [Iostreams](/libs/iostreams/index.html): + + + Support filesystem v3 paths ([#4485](https://svn.boost.org/trac/boost/ticket/4485)). + + Fix a memory leak in `chain` + ([#4922](https://svn.boost.org/trac/boost/ticket/4922)). +* [Iterator](/libs/iterator/index.html): + + + Add `function\_input\_iterator` + ([#2893](https://svn.boost.org/trac/boost/ticket/2893)). + + Bug fixes: [#1427](https://svn.boost.org/trac/boost/ticket/1427), + [#1517](https://svn.boost.org/trac/boost/ticket/1517), + [#3434](https://svn.boost.org/trac/boost/ticket/3434). +* [Lexical cast](/libs/conversion/lexical_cast.htm): + + + Better performance and less memory usage for many combinations of + Source and Target types ([#5564](https://svn.boost.org/trac/boost/ticket/5564), + [#5417](https://svn.boost.org/trac/boost/ticket/5417), + [#4397](https://svn.boost.org/trac/boost/ticket/4397), + [#5350](https://svn.boost.org/trac/boost/ticket/5350), + [#5576](https://svn.boost.org/trac/boost/ticket/5576)). + + Documentation updated ([#5576](https://svn.boost.org/trac/boost/ticket/5576), + [#5494](https://svn.boost.org/trac/boost/ticket/5494)). +* [Logic](/libs/logic/index.html): + + + Bug fixes: [#3093](https://svn.boost.org/trac/boost/ticket/3093), + [#3600](https://svn.boost.org/trac/boost/ticket/3600). +* [Math](/libs/math/index.html): + + + Added changesign function to sign.hpp to facilitate addition of nonfinite + facets. + + Addition of nonfinite facets from Johan Rade, with tests, examples + of use for C99 format infinity and NaN, and documentation. + + Added tests and documentation of changesign from Johan Rade. +* [Meta State Machine](/libs/msm/index.html): + + + Added a [`stop()`](/doc/libs/1_47_0/libs/msm/doc/HTML/ch03s05.html#backend-start) + method in the back-end. + + Added partial support for [Boost.Phoenix + functors in eUML](/doc/libs/1_47_0/libs/msm/doc/HTML/ch03s04.html#eUML-phoenix). + + Added the possibility to [choose + when state switching occurs](/doc/libs/1_47_0/libs/msm/doc/HTML/ch03s05.html#backend-state-switch). + + Bugfixes: + + - [#5117](https://svn.boost.org/trac/boost/ticket/5117), + [#5253](https://svn.boost.org/trac/boost/ticket/5253), + [#5533](https://svn.boost.org/trac/boost/ticket/5533), + [#5573](https://svn.boost.org/trac/boost/ticket/5573). + - gcc warnings about unused variables. + - better implementation of `favor\_compile\_time` + back-end policy. + - bug with eUML and state construction. + - incorrect eUML event and state macros. + - incorrect event type passed to a direct entry state's on\_entry + action. + - more examples. +* [MultiIndex](/libs/multi_index/index.html): + + + Fixed an ADL problem in `composite\_key\_compare` + related with Boost.Ref. + + Maintenance fixes. +* [Proto](/libs/proto/index.html): + + + Pre-preprocessed for better compile times. + + Default preprocessor limits raised: + + - Max expression arity (`BOOST\_PROTO\_MAX\_ARITY`) + bumped from 5 to 10. + - Max function call arity (`BOOST\_PROTO\_MAX\_FUNCTION\_CALL\_ARITY`) + bumped from 5 to 10. + - Max logical operator arity (`BOOST\_PROTO\_MAX\_LOGICAL\_ARITY`) + bumped from 8 to 10. + + Better integration of `proto::basic\_expr` + to avoid accidental needless instantiations of `proto::expr`. +* [Random](/libs/random/index.html): + + + Synchronized with the new standard. + + - Many new distributions added: `chi\_squared\_distribution`, + `negative\_binomial\_distribution`, + `fisher\_f\_distribution`, + `student\_t\_distribution`, + `weibull\_distribution`, + `extreme\_value\_distribution`, + `discrete\_distribution`, + `piecewise\_constant\_distribution`, + `piecewise\_liear\_distribution` + - Renamed `uniform\_int` + and `uniform\_real` + to `uniform\_int\_distribution` + and `uniform\_real\_distribution`. + - Added members to all distributions: `param\_type`, + `param`, stream + operators, comparison operators, `min` + and `max`. + - Allow distributions to be used directly with generators without + use of `variate\_generator`. + - Changed the meaning of the parameters of `geometric\_distribution` + and `lognormal\_distribution`. + - Added a second parameter to `gamma\_distribution`. + - Added `seed\_seq` + and added the corresponding constructors and `seed` overloads the generators. + - Added `generate\_canonical`. + - Renamed the engine tempates. e.g. `mersenne\_twister` + becomes `mersenne\_twister\_engine`. + - New engine adapter `independent\_bits\_engine`. + - Added new predefined engine typedefs: `mt19937\_64`, + `ranlux[24|48][\_base]`, + `knuth\_b`. + - Updated seeding algorithms. + - Added `discard` + - Use unsigned types instead of signed types in all the predefined + engines. + + Bug fixes: + + - `linear\_congruential\_engine` + could assert because the modular arithmetic was not implemented + in all cases. `shuffle\_output`, + now called `shuffle\_order\_engine`, + could cause integer overflow. These cases were not triggered + by any predefined engines. + - `uniform\_small\_int` + now actually behaves as documented. + + New efficient algorithms for `binomial\_distribution` + and `poisson\_distribution`. + + Moved all features into `namespace + boost::random` + + Backwards compatibility issues: + + - The seeding algorithms have changed. This was unavoidable for + compatibility with the standard. Not to mention that some of + the existing algorithms were weird and inconsistent. + + * Seeding with an integer: The behaviour should be unchanged + for most generators except `lagged\_fibonacci` + and `subtract\_with\_carry` + (and thus `ranlux`). + * Seeding a generator with another generator: This has + been enabled by making all all generators models of + `SeedSeq`. + Therefore, if you seed a Boost.Random generator with + a non Boost.Random generator, your code will no longer + compile. The algorithm has changed, so code using this + seeding method will yield different values. + * Seeding a generator from a pair of iterators: This implicitly + assumed that the elements were 32-bit integers in some + places, but not everywhere. I've added this requirement + everywhere and updated the algorithms accordingly. The + behaviour of generators with a `value\_type` + no more than 32 bits should be unchanged. + - Renaming: + + * Whenever a class was renamed, there is a wrapper with + the old name. There are also using declarations in namespace + boost for everything that was moved. + * The names of a few accessors in the distributions changed. + Both the old and the new names are allowed. + - `geometric\_distribution` + and `lognormal\_distribution`: + The behaviour is different at runtime. `boost::geometric\_distribution` + and `boost::lognormal\_distribution` provide + the old behaviour, `boost::random::geometric\_distribution` + and `boost::random::lognormal\_distribution` provide + the new behaviour. + - Streaming: gamma\_distribution has a new parameter, thus text + saved with the old version will not readable by the new version. + - `variate\_generator` + is now a simple pass through wrapper. Code that assumes that + it will adjust the generator's result type to match the distribution + will no longer work. This is not an issue with any of the distributions + provided by Boost.Random. + - Return types: The `result\_types` + of some generators have changed slightly. Some signed types + have changed to unsigned to match the standard. + - `has\_fixed\_range`: + This is now always false, as it doesn't appear to be very useful + and is excessively cumbersome. Anything that was accessing + `const\_min` and + `const\_max` without + first checking `has\_fixed\_range` + was incorrect to begin with. +* [Range](/libs/range/index.html): + + + Fixed the end position `irange` + when step size is greater than 1 ([#5544](https://svn.boost.org/trac/boost/ticket/5544)). +* [Spirit](/libs/spirit/index.html): + + + Spirit V2.5, see the '[What's + New](/doc/libs/1_47_0/libs/spirit/doc/html/spirit/what_s_new/spirit_2_5.html)' section for details. +* [Tokenizer](/libs/tokenizer/index.html): + + + Fixed bug [#4649](https://svn.boost.org/trac/boost/ticket/4649). +* [Utility](/libs/utility/index.html): + + + Bug fixes: [#4432](https://svn.boost.org/trac/boost/ticket/4432). +* [Uuid](/libs/utility/index.html): + + + Fixed tickets: ([#5570](https://svn.boost.org/trac/boost/ticket/5570), + [#4601](https://svn.boost.org/trac/boost/ticket/4601), + [#4991](https://svn.boost.org/trac/boost/ticket/4991), + [#5145](https://svn.boost.org/trac/boost/ticket/5145), + [#5235](https://svn.boost.org/trac/boost/ticket/5235)). +* [Wave](/libs/wave/index.html): + + + Wave V2.3.0, see the [Changelog](/libs/wave/ChangeLog) + for details. + +### Build System + + +* The official name of Boost.Build executable was changed to `b2`. The bootstrap scripts create a copy + with the old name `bjam` + to prevent third-party build scripts from failing. + +### Updated Tools + + +* [BoostBook](/tools/boostbook/index.html): + + + Handle doxygen tags: `\see`, `tparam`, + `ref` (for classes + only). + + Support note for classes as well as functions. +* [Quickbook](/tools/quickbook/index.html): + + + Generate consistent ids for headings. + + Improved unicode support for windows. + + Warn about windows paths, as they aren't portable. + + Reverse deprecation of `[br]`. + + Support date ranges and comma seperated clauses in copyright attributes. + + Improved delimeter checking for simple markup (e.g. `\*bold\*`). + + Pass-thru comments in code snippets. + + `__FILENAME__` macro now generates relative paths. + + Allow quickbook escapes inside comments in syntax highlighted code. + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + LLVM Clang 2.8 + + GCC: 3.4.6, 4.2.4, 4.3.4, 4.3.5, 4.4.1, 4.4.3, 4.4.5, 4.5.1, 4.5.2, + 4.6.0, 4.6.1 + + GCC, C++0x mode: 4.3.4, 4.4.3, 4.5.2 + + Intel 12.0 +* OS X: + + + Apple Clang 2.1 + + Intel 11.1 + + GCC: 4.2.1, 4.4.4 + + GCC, C++0x mode: 4.4.4 +* Windows: + + + Visual C++ 7.1, 9.0, 10.0 + + GCC, mingw: 4.4.0 +* FreeBSD: + + + GCC 4.2.1, 64 bit +* QNX: + + + QCC + Boost's additional test compilers include: + + + +* Linux: + + + Clang from subversion, with GNU libstdc++. + + LLVM Clang 2.8 + + GCC: 3.4.6, 4.2.4, 4.3.4, 4.3.5, 4.4.3, 4.4.5, 4.5.1, 4.5.2, 4.6.0, + 4.6.1 + + GCC, C++0x mode: 4.3.4, 4.4.3, 4.5.2 + + pgCC: 11.2 + + Intel: 10.1, 11.0, 11.1, 12.0 + + PathScale: 3.2 +* OS X: + + + Clang from subversion, with GNU libstdc++. + + Intel 11.1 + + GCC: 4.4.4 + + GCC, C++0x mode: 4.4.4 +* Windows: + + + Visual C++ 7.1, 9.0, 10.0 + + Visual C++ with STLport: 9.0 + + Visual C++, Windows Mobile 5, with STLport: 9.0 + + GCC, mingw: 4.5.2 + + GCC, C++0x mode, mingw: 4.5.2 +* AIX: + + + IBM XL C/C++ Enterprise Edition, V11.1.0.0 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James + and Vladimir Prus managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_48_0.html b/users/history/version_1_48_0.html new file mode 100644 index 0000000..f6451d3 --- /dev/null +++ b/users/history/version_1_48_0.html @@ -0,0 +1,400 @@ +--- +title: Version 1.48.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.48.0 + +/\*\*/ + + + + + + + +Version 1.48.0 +============== + +Version 1.48.0 +-------------- + + +November 15th, 2011 15:47 GMT + + +[Documentation](/doc/libs/1_48_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_48\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.48.0/boost_1_48_0.tar.bz2) | +| [boost\_1\_48\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.48.0/boost_1_48_0.tar.gz) | +| windows | [boost\_1\_48\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.48.0/boost_1_48_0.7z) | +| [boost\_1\_48\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.48.0/boost_1_48_0.zip) | + + +### Patches + + +* [Locale + Patch](http://cppcms.com/files/locale/boost_locale_utf.patch) - Fixes a bug which causes `boost::locale::utf::utf\_traits` + to accept some invalid UTF-8 sequences, which is a possible security flaw. + +### New Libraries + + +* [Container](/libs/container/index.html): + Standard + library containers and extensions, from Ion Gaztañaga. +* [Locale](/libs/locale/index.html): + Provide localization + and Unicode handling tools for C++, from Artyom Beilis. +* [Move](/doc/html/move.html): + Portable move semantics + for C++03 and C++11 compilers, from Ion Gaztañaga. + +### Updated Libraries + + +* [Asio](/libs/asio/index.html): + + + Implemented various performance improvements, including: + + - Using thread-local operation queues in single-threaded use + cases (i.e. when `concurrency\_hint` + is 1) to eliminate a lock/unlock pair. + - Allowing some `epoll\_reactor` + speculative operations to be performed without holding the + lock. + - Improving locality of reference by performing an `epoll\_reactor`'s I/O operation + immediately before the corresponding handler is called. Also + improves scalability across CPUs. + - Specialising asynchronous read and write operations for buffer + sequences that are arrays (`boost::array` + or `std::array`) of exactly two buffers. + + Fixed compile error in regex overload of `async\_read\_until` + ([#5688](https://svn.boost.org/trac/boost/ticket/5688)). + + Fixed Windows-specific compile error by explicitly specifying the + `signal()` + function from the global namespace ([#5722](https://svn.boost.org/trac/boost/ticket/5722)). + + Changed `deadline\_timer` + implementation to not read clock unless the timer heap is non-empty. + + Changed SSL buffer sizes to be large enough to hold a complete TLS + record ([#5854](https://svn.boost.org/trac/boost/ticket/5854)). + + Fixed synchronous `null\_buffers` + operations so that they obey the user's non-blocking setting ([#5756](https://svn.boost.org/trac/boost/ticket/5756)). + + Changed to set `fd\_set` + size at runtime when using Windows. + + Disabled MSVC warning due to const qualifier being applied to function + type. + + Fixed crash that occurs when using Intel C++ compiler ([#5763](https://svn.boost.org/trac/boost/ticket/5763)). + + Changed OpenSSL initialisation to support all available algorithms. + + Fixed SSL error mapping when session is gracefully shut down. + + Added some latency test programs. + + Clarified that a read operation ends when the buffer is full ([#5999](https://svn.boost.org/trac/boost/ticket/5999)). + + Fixed exception safety issue in `epoll\_reactor` + initialisation ([#6006](https://svn.boost.org/trac/boost/ticket/6006)). + + Made number of strand implementations configurable via `BOOST\_ASIO\_STRAND\_IMPLEMENTATIONS` + macro. + + Added support for `BOOST\_ASIO\_ENABLE\_SEQUENTIAL\_STRAND\_ALLOCATION` + flag which switches strand allocation to use a round-robin approach + rather than hashing. + + Fixed potential strand starvation issue that can occur when `strand.post()` + is used. +* [Chrono](/libs/chrono/index.html): + + + [#5979](http://svn.boost.org/trac/boost/ticket/5979) + Added chrono rounding utilities as defined by Howard Hinnant [here](http://home.roadrunner.com/~hinnant/duration_io/chrono_util.html). + + [#5978](http://svn.boost.org/trac/boost/ticket/5978) + Add BOOST\_CHRONO\_HAS\_PROCESS\_CLOCKS to know if process clocks are + available. + + [#5998](http://svn.boost.org/trac/boost/ticket/5998) + Make possible to disable hybrid error handling. + + [#5906](http://svn.boost.org/trac/boost/ticket/5906) + Take in account the constexpr as defined in the standard. + + [#5907](http://svn.boost.org/trac/boost/ticket/5907) + Take in account noexcept for compilers supporting it. + + Fixed some bugs. + + See the [History](/doc/html/chrono/appendices.html#chrono.appendices.history) + for more details. +* [Config](/libs/config/index.html): + + + Add `BOOST\_NO\_DECLTYPE\_N3276` + config macro. (See [N3276](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3276.pdf).) +* [Fusion](/libs/fusion/index.html): + + + Make `single\_view` + a random access fusion sequence. + + Remove bogus compile-time asserts from `fusion::distance`. + + Cleaner implementation of segmented Fusion. +* [Geometry](/libs/geometry): + + + Bugfixes: + + - Robustness issue, in some circumstances the union failed to + output. Fixed. + - Robustness issue, in some circumstances the calculated intersection + point was outside the segment. Fixed. + - Concept issue, cartesian intersect didn't understand segments + other than the provided one. Fixed. + - Sometimes self-intersections in linestrings were missed. Fixed. + - The fusion coordinate system was not registered correctly. + Fixed. + + Solved tickets: + + - [#5726](https://svn.boost.org/trac/boost/ticket/5726) + (Segment intersection algorithm still assumes 'first', 'second' + members) + - [#5744](https://svn.boost.org/trac/boost/ticket/5744) + (mistake fusion adapt example) + - [#5748](https://svn.boost.org/trac/boost/ticket/5748) + (need include ) + - [#5954](https://svn.boost.org/trac/boost/ticket/5954) + (distance\_pythagoras skips sqrt() step) + + Improvements on algorithms: + + - Checking self-intersections is now not done automatically, + this can blast performance. + - Besides that, checking self-intersections is made faster. + - Intersections now avoid outputting duplicate points. So they + output the minimal set. + + Additional algorithms: + + - covered\_by: within is defined as "within, not on boundary". + covered\_by is "within or on boundary" + + Additional functionality: + + - within: strategies can now be specified for within and within + - convert: a much broader range of conversions is supported + - assign: idem, (currently partly) synonym for convert (but reversed + arguments) + + Additional coordinate types: + + - Basic support for Boost.Rational +* [Graph](/libs/graph/): + + + Fixed bugs [#5185](https://svn.boost.org/trac/boost/ticket/5185), + [#5506](https://svn.boost.org/trac/boost/ticket/5506), + [#5813](https://svn.boost.org/trac/boost/ticket/5813) + and [#5919](https://svn.boost.org/trac/boost/ticket/5919). + + Various other bug fixes not in Trac. + + Changed edge\_descriptor type for reverse\_graph to a new data type + to avoid ambiguities with the edge\_descriptor of the underlying graph. +* [Interprocess](/libs/interprocess/index.html): + + + Fixed bugs [#2796](https://svn.boost.org/trac/boost/ticket/2796), + [#4031](https://svn.boost.org/trac/boost/ticket/4031), + [#4251](https://svn.boost.org/trac/boost/ticket/4251), + [#4452](https://svn.boost.org/trac/boost/ticket/4452), + [#4895](https://svn.boost.org/trac/boost/ticket/4895), + [#5077](https://svn.boost.org/trac/boost/ticket/5077), + [#5120](https://svn.boost.org/trac/boost/ticket/5120), + [#5123](https://svn.boost.org/trac/boost/ticket/5123), + [#5230](https://svn.boost.org/trac/boost/ticket/5230), + [#5197](https://svn.boost.org/trac/boost/ticket/5197), + [#5287](https://svn.boost.org/trac/boost/ticket/5287), + [#5294](https://svn.boost.org/trac/boost/ticket/5294), + [#5306](https://svn.boost.org/trac/boost/ticket/5306), + [#5308](https://svn.boost.org/trac/boost/ticket/5308), + [#5392](https://svn.boost.org/trac/boost/ticket/5392), + [#5409](https://svn.boost.org/trac/boost/ticket/5409), + + Added support to customize offset\_ptr and allow creating custom managed + segments that might be shared between 32 and 64 bit processes. + + Shared memory in windows has again filesystem lifetime: kernel bootstamp + and WMI use to get a reliable timestamp was causing a lot of trouble. +* [Intrusive](/libs/intrusive/index.html): + + + Fixed bugs [#4797](https://svn.boost.org/trac/boost/ticket/4797), + [#5165](https://svn.boost.org/trac/boost/ticket/5165), + [#5183](https://svn.boost.org/trac/boost/ticket/5183), + [#5191](https://svn.boost.org/trac/boost/ticket/5191). +* [Lexical cast](/libs/conversion/lexical_cast.htm): + + + Added code to work with Inf and NaN values on any platform ([#5689](https://svn.boost.org/trac/boost/ticket/5689)). + + New Quickbook documentation ([#5723](https://svn.boost.org/trac/boost/ticket/5723)). + + Better performance and less memory usage for many combinations of + Source and Target types. + + Better performance for C locale. +* [Math](/libs/math/index.html): + + + Added new series evaluation methods to the cyclic Bessel I, J, K + and Y functions. Also taken great care to avoid spurious over and + underflow of these functions. Fixes issue [#5560](https://svn.boost.org/trac/boost/ticket/5560). + + Added an example of using Inverse Chi-Squared distribution for Bayesian + statistics, provided by Thomas Mang. + + Added tests to use improved version of lexical\_cast which handles + C99 nonfinites without using global facets. + + Corrected wrong out-of-bound uniform distribution CDF complement + values [#5733](https://svn.boost.org/trac/boost/ticket/5733). + + Enabled long double support on OpenBSD (issue [#6014](https://svn.boost.org/trac/boost/ticket/6014)). + + Changed nextafter and related functions to behave in the same way + as other implementations - so that nextafter(+INF, 0) is a finite + value (issue [#5832](https://svn.boost.org/trac/boost/ticket/5832)). + + Changed tuple include configuration to fix issue when using in conjunction + with Boost.Tr1 (issue [#5934](https://svn.boost.org/trac/boost/ticket/5934)). + + Changed class eps\_tolerance to behave correctly when both ends of + the range are zero (issue [#6001](https://svn.boost.org/trac/boost/ticket/6001)). + + Fixed missing include guards on prime.hpp (issue [#5927](https://svn.boost.org/trac/boost/ticket/5927)). + + Removed unused/undocumented constants from constants.hpp (issue + [#5982](https://svn.boost.org/trac/boost/ticket/5982)). + + Fixed missing std:: prefix in nonfinite\_num\_facets.hpp (issue [#5914](https://svn.boost.org/trac/boost/ticket/5914)). + + Minor patches for Cray compiler compatibility. +* [MSM](/libs/msm/): + + + eUML: added easier event reprocessing: process(event\_) and reprocess() + + Rewrite of internal transition tables. There were a few bugs (failing + recursivity in internal transition tables of sub-sub machines) and + a missing feature (unused internal transition table of the main state + machine). + + Bugfixes + + - Reverted favor\_compile\_time policy to Boost 1.46 state + - none event now is convertible from any other event + - eUML and pseudo exit states + - Fixed not working Flag\_AND + - Fixed rare bugs causing multiple processing of the same event + in a submachine whose transition table contains this event + and a base event of it. + - gcc warnings about unused variables + + Breaking change: the new internal transition table feature causes + a minor breaking change. In a submachine, the "Fsm" template + parameter for guards / actions of an internal table declared using + internal\_transition\_table now is the submachine, not the higher-level + state machine. Internal transitions declared using internal rows + in the higher-level state machine keep their behavior (the "Fsm" + parameter is the higher-level state machine). To sum up, the internal + transition "Fsm" parameter is the closest state machine + containing this transition. +* [Numeric.Conversion](/libs/numeric/conversion/index.html): + + + Added numeric\_cast\_traits; see '[numeric\_cast\_traits](/doc/libs/1_48_0/libs/numeric/conversion/doc/html/boost_numericconversion/type_requirements_and_user_defined_types_support.html#boost_numericconversion.type_requirements_and_user_defined_types_support.udts_with_numeric_cast)' + for details. +* [Proto](/libs/proto/index.html): + + + **Breaking Change:** Reduce numbers + of operator overloads by using rvalue references on compilers that + support them. Any user code that defines additional operator overloads + on Proto expressions could potentially be rendered ambiguous by this + change. The solution is to use a grammar to disable Proto's operators + that are made ambiguous by any user-defined operators. + + Move definitions of Proto tag types into an ADL-blocking namespace. + + Add second template parameter to `proto::siwtch\_` + to control dispatching to cases. + + Allow dependent domains to be specified with `BOOST\_PROTO\_EXTENDS` + and `BOOST\_PROTO\_BASIC\_EXTENDS`. +* [Regex](/libs/regex/): + + + Fixed issues: [#698](https://svn.boost.org/trac/boost/ticket/698), + [#5835](https://svn.boost.org/trac/boost/ticket/5835), + [#5958](https://svn.boost.org/trac/boost/ticket/5958), + [#5736](https://svn.boost.org/trac/boost/ticket/5736). +* [Spirit](/libs/spirit/index.html): + + + Spirit V2.5.1, see the '[What's + New](/doc/libs/1_48_0/libs/spirit/doc/html/spirit/what_s_new/spirit_2_5_1.html)' section for details. +* [TypeTraits](/libs/type_traits/): + + + Extension to support [operator + detection](/libs/type_traits/doc/html/boost_typetraits/category/value_traits/operators.html). +* [Unordered](/libs/unordered/): + + + Improved support for the C++11 standard - breaking change to equality + and emplace. + + Use Boost.Move to implement move semantics. + + See the [change + log](/doc/html/unordered/changes.html#unordered.changes.boost_1_48_0___major_update) for full details. +* [Wave](/libs/wave/index.html): + + + See the [Changelog](/libs/wave/ChangeLog) for details. + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + LLVM Clang 2.8 + + GCC: 3.4.6, 4.2.4, 4.3.4, 4.4.3, 4.5.1, 4.5.2, 4.6 + + GCC, C++0x mode: 4.3.4, 4.4.3, 4.5.2 + + Intel 11.1 +* OS X: + + + Intel 11.1 + + GCC: 4.2.1, 4.4.4 + + GCC, C++0x mode: 4.4.4 +* Windows: + + + Visual C++ 8.0, 9.0, 10.0 + + GCC, mingw: 4.4.0, 4.4.7, 4.5.4, 4.6.1 +* FreeBSD: + + + GCC 4.2.1, 32 and 64 bit. +* QNX: + + + QCC 4.4.2 + + QCC, C++0x mode: 4.4.2, 4.6.1 + Boost's additional test compilers include: + + + +* Linux: + + + Clang from subversion, with libc++ and GNU libstdc++ + + LLVM Clang 2.8 x + + GCC: 3.4.6, 4.2.4, 4.3.4, 4.4.4, 4.5.2, 4.5.4, 4.6.1, 4.6.2 + + GCC, C++0x mode: 4.3.4, 4.4.3, 4.4.4, 4.5.2 + + pgCC: 11.2 x + + Intel: 10.1, 11.1, 12.0 + + PathScale: 4.0.8 + + Visual Age 10.1 +* OS X: + + + Clang from subversion, with libc++ and GNU libstdc++. + + Intel 11.1. + + GCC: 4.2.1, 4.4.4. + + GCC, C++0x mode: 4.4.4. +* Windows: + + + Visual C++ 8.0, 9.0, 10.0 + + Visual C++ with STLport: 9.0 + + Visual C++, Windows Mobile 5, with STLport: 9.0 + + GCC, mingw: 4.4.0, 4.4.7, 4.5.2, 4.5.4, 4.6.1 + + GCC, C++0x mode, mingw: 4.5.2 + + GCC, mingw 64-bit: 4.7.0 +* AIX: + + + IBM XL C/C++ Enterprise Edition, V11.1.0.0 +* FreeBSD: + + + GCC 4.2.1, 32 and 64 bit. +* Solaris: + + + Sun 5.10 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James + and Vladimir Prus managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_49_0.html b/users/history/version_1_49_0.html new file mode 100644 index 0000000..be6747e --- /dev/null +++ b/users/history/version_1_49_0.html @@ -0,0 +1,447 @@ +--- +title: Version 1.49.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.49.0 + +/\*\*/ + + + + + + + +Version 1.49.0 +============== + +Version 1.49.0 +-------------- + + +February 24th, 2012 21:20 GMT + + +[Documentation](/doc/libs/1_49_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_49\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.49.0/boost_1_49_0.tar.bz2) | +| [boost\_1\_49\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.49.0/boost_1_49_0.tar.gz) | +| windows | [boost\_1\_49\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.49.0/boost_1_49_0.7z) | +| [boost\_1\_49\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.49.0/boost_1_49_0.zip) | + + +### Patches + + +* [Locale + Patch](http://cppcms.com/files/locale/boost_locale_utf.patch) - Fixes a bug which causes `boost::locale::utf::utf\_traits` + to accept some invalid UTF-8 sequences, which is a possible security flaw. + +### New Libraries + + +* [Heap](/libs/heap/index.html): + Priority queue data + structures, from Tim Blechmann. + +### Updated Libraries + + +* [Asio](/libs/asio): + + + Added a new class template `basic\_waitable\_timer` + based around the C++11 clock type requirements. It may be used with + the clocks from the C++11 `` + library facility or, if those are not available, Boost.Chrono. The + typedefs `high\_resolution\_timer`, + `steady\_timer` and + `system\_timer` may + be used to create timer objects for the standard clock types. + + Added a new `windows::object\_handle` + class for performing waits on Windows kernel objects. Thanks go to + Boris Schaeling for contributing substantially to the development + of this feature. + + On Linux, `connect()` can return EAGAIN in certain circumstances. + Remapped this to another error so that it doesn't look like a non-blocking + operation ([#6048](https://svn.boost.org/trac/boost/ticket/6048)). + + Fixed a compile error on NetBSD ([#6098](https://svn.boost.org/trac/boost/ticket/6098)). + + Fixed deadlock on Mac OS X ([#6275](https://svn.boost.org/trac/boost/ticket/6275)). + + Fixed a regression in `buffered\_write\_stream` + ([#6310](https://svn.boost.org/trac/boost/ticket/6310)). + + Fixed a non-paged pool "leak" on Windows when an `io\_service` is repeatedly run without + anything to do ([#6321](https://svn.boost.org/trac/boost/ticket/6321)). + + Reverted earlier change to allow some speculative operations to be + performed without holding the lock, as it introduced a race condition + in some multithreaded scenarios. + + Fixed a bug where the second buffer in an array of two buffers may + be ignored if the first buffer is empty. +* [Chrono](/libs/chrono): + + + Bug Fixes: + + - [#6092](http://svn.boost.org/trac/boost/ticket/6092) + Input from non integral durations makes the compiler fail. + - [#6093](http://svn.boost.org/trac/boost/ticket/6093) + [1/3]second fails as valid duration input. + - [#6113](http://svn.boost.org/trac/boost/ticket/6113) + duplicate symbol when BOOST\_CHRONO\_HEADER\_ONLY is defined. + - [#6243](http://svn.boost.org/trac/boost/ticket/6243) + Sandia-pgi-11.9: more than one instance of overloaded function + "min" matches. + - [#6257](http://svn.boost.org/trac/boost/ticket/6257) + process\_cpu\_clock::now() on linux gives time\_points 1/1000 + times. +* [Container](/libs/container/): + + + Fixed bugs [#6499](https://svn.boost.org/trac/boost/ticket/6499), + [#6336](https://svn.boost.org/trac/boost/ticket/6336), + [#6335](https://svn.boost.org/trac/boost/ticket/6335), + [#6287](https://svn.boost.org/trac/boost/ticket/6287), + [#6205](https://svn.boost.org/trac/boost/ticket/6205), + [#4383](https://svn.boost.org/trac/boost/ticket/4383). + + Added `allocator\_traits` + support for both C++11 and C++03 compilers through an internal `allocator\_traits` clone. +* [Filesystem](/libs/filesystem/): + + + Fix [#3714](https://svn.boost.org/trac/boost/ticket/3714), + Added test cases and fixes for class path errors when assignment + or append used self or portion of self as source. + + Fix [#4889](https://svn.boost.org/trac/boost/ticket/4889), + [#6320](https://svn.boost.org/trac/boost/ticket/6320), + Locale codecvt\_facet not thread safe on Windows. Move Windows, Mac + OS X, locale and codecvt facet back to namespace scope. POSIX except + OS X uses local static initialization (IE lazy) to ensure exceptions + are catchable if environmental variables are misconfigured and to + avoid use of locale("") if not actually used. + + Fix [#5652](https://svn.boost.org/trac/boost/ticket/5652), + recursive\_directory\_iterator fails on cyclic symbolic links. Thanks + to Daniel Aarno for the patch. + + Fix [#5653](https://svn.boost.org/trac/boost/ticket/5653), + recursive\_directory\_iterator(error\_code) can still throw filesystem\_error. + + Fix [#5900](https://svn.boost.org/trac/boost/ticket/5900), + directory\_iterator access violation on Windows if error is thrown. + Thanks to Andreas Eckleder for the patch. + + Fix [#5900](https://svn.boost.org/trac/boost/ticket/5900) + comment 2, a bug in director\_iterator construction with error\_code + argument that caused increment to be called without the ec argument + being passed. + + Fix [#5989](https://svn.boost.org/trac/boost/ticket/5989) + by cleaning up test suite path\_test.cpp code even though the ticket + itself was not a defect, and clarifying docs; iteration over a path + yields generic format. + + Fix [#5592](https://svn.boost.org/trac/boost/ticket/5592), + Change Windows codecvt processing from CP\_THREAD\_ACP to CP\_ACP. + + Operations function fixes for PGI compiler, thanks to Noel Belcourt. + + Relax permissions test to reflect reality, particularly on the Sandia + test platforms. +* [Foreach](/libs/foreach/): + + + Fix for [#6131](https://svn.boost.org/trac/boost/ticket/6131) +* [Geometry](/libs/geometry/): + + + Fixed bugs + + - Distance for multi-geometries ignored specified distance strategy. + - In difference for polygon/multi\_polygon (reported 2011/10/24 + on GGL-list). + - Raise exception for calculation of distances of multi-geometrie(s) + where one of them is empty + - Multi DSV did not correctly use settings. + - Self-intersections could sometimes be missed (introduced in + 1.48). + - Convex hull crashed on empty range (e.g. empty multi point). + + Solved tickets + + - [#6028](https://svn.boost.org/trac/boost/ticket/6028) + Documentation: closure. + - [#6178](https://svn.boost.org/trac/boost/ticket/6178) + Missing headerfile. + - [#6021](https://svn.boost.org/trac/boost/ticket/6021) + convex hull of multipoint. + + Additional functionality + + - Support for line/polygon intersections and differences + - Support for convert of segment/box of different point types + - Support for append for multi point + - Scalar functions (distance, area, length, perimeter) now throw + an empty\_input\_exception on empty input + + Documentation + + - Updated support status + + Internal changes + + - Updates in specializations/not\_implemented for distance/convert/assign/area + - Move of wkt/dsv to io folder, making domains redundant + - Strategy concepts assigned to zero to avoid clang warnings + (patched by Vishnu) +* [Graph](/libs/graph/): + + + Fixed bugs [#5881](https://svn.boost.org/trac/boost/ticket/5881), + [#6033](https://svn.boost.org/trac/boost/ticket/6033), + [#6061](https://svn.boost.org/trac/boost/ticket/6061), + [#6137](https://svn.boost.org/trac/boost/ticket/6137), + [#6246](https://svn.boost.org/trac/boost/ticket/6246), + [#6239](https://svn.boost.org/trac/boost/ticket/6239), + [#6293](https://svn.boost.org/trac/boost/ticket/6293), + [#6306](https://svn.boost.org/trac/boost/ticket/6306), + [#6313](https://svn.boost.org/trac/boost/ticket/6313) + and [#6371](https://svn.boost.org/trac/boost/ticket/6371), + plus others not in Trac. + + Re-enabled LEDA graph support (thanks to Jens Muller for the patch). + + Added documentation for `edge\_predecessor\_recorder`. +* [Icl](/libs/icl/): + + + Fixed tickets [#6095](https://svn.boost.org/trac/boost/ticket/6095) + and [#6210](https://svn.boost.org/trac/boost/ticket/6210). + + Added move semantics for constructors, assignment operators and binary + operators. +* [Interprocess](/libs/interprocess/): + + + Fixed bugs [#6531](https://svn.boost.org/trac/boost/ticket/6531), + [#6412](https://svn.boost.org/trac/boost/ticket/6412), + [#6398](https://svn.boost.org/trac/boost/ticket/6398), + [#6340](https://svn.boost.org/trac/boost/ticket/6340), + [#6319](https://svn.boost.org/trac/boost/ticket/6319), + [#6287](https://svn.boost.org/trac/boost/ticket/6287), + [#6265](https://svn.boost.org/trac/boost/ticket/6265), + [#6233](https://svn.boost.org/trac/boost/ticket/6233), + [#6147](https://svn.boost.org/trac/boost/ticket/6147), + [#6134](https://svn.boost.org/trac/boost/ticket/6134), + [#6058](https://svn.boost.org/trac/boost/ticket/6058), + [#6054](https://svn.boost.org/trac/boost/ticket/6054), + [#5772](https://svn.boost.org/trac/boost/ticket/5772), + [#5738](https://svn.boost.org/trac/boost/ticket/5738), + [#5622](https://svn.boost.org/trac/boost/ticket/5622), + [#5552](https://svn.boost.org/trac/boost/ticket/5552), + [#5518](https://svn.boost.org/trac/boost/ticket/5518), + [#4655](https://svn.boost.org/trac/boost/ticket/4655), + [#4452](https://svn.boost.org/trac/boost/ticket/4452), + [#4383](https://svn.boost.org/trac/boost/ticket/4383), + [#4297](https://svn.boost.org/trac/boost/ticket/4297). + + Fixed timed functions in mutex implementations to fulfill POSIX requirements: + *Under no circumstance shall the function fail with a timeout + if the mutex can be locked immediately. The validity of the abs\_timeout + parameter need not be checked if the mutex can be locked immediately.* +* [Intrusive](/libs/intrusive/): + + + Fixed bugs [#6347](https://svn.boost.org/trac/boost/ticket/6347), + [#6223](https://svn.boost.org/trac/boost/ticket/6223), + [#6153](https://svn.boost.org/trac/boost/ticket/6153). +* [Lexical cast](/libs/conversion/lexical_cast.htm): + + + Fixed bugs and warnings: [#6127](https://svn.boost.org/trac/boost/ticket/6127), + [#6132](https://svn.boost.org/trac/boost/ticket/6132), + [#6159](https://svn.boost.org/trac/boost/ticket/6159), + [#6182](https://svn.boost.org/trac/boost/ticket/6182), + [#6186](https://svn.boost.org/trac/boost/ticket/6186), + [#6193](https://svn.boost.org/trac/boost/ticket/6193), + [#6264](https://svn.boost.org/trac/boost/ticket/6264), + [#6290](https://svn.boost.org/trac/boost/ticket/6290), + [#6298](https://svn.boost.org/trac/boost/ticket/6298), + [#6400](https://svn.boost.org/trac/boost/ticket/6400). + + Better performance and less memory usage for boost::container::basic\_string + conversions. +* [Locale](/libs/locale/): + + + Fixed incorrect use of `MultiByteToWideChar` + in detection of invalid input sequences. +* [Move](/libs/move/): + + + Fixed bugs [#6417](https://svn.boost.org/trac/boost/ticket/6417), + [#6183](https://svn.boost.org/trac/boost/ticket/6183), + [#6185](https://svn.boost.org/trac/boost/ticket/6185), + [#6395](https://svn.boost.org/trac/boost/ticket/6395), + [#6396](https://svn.boost.org/trac/boost/ticket/6396), +* [PropertyTree](/libs/property_tree): + + + Fixes for bugs [#4840](https://svn.boost.org/trac/boost/ticket/4840), + [#5259](https://svn.boost.org/trac/boost/ticket/5259), + [#5281](https://svn.boost.org/trac/boost/ticket/5281), + [#5944](https://svn.boost.org/trac/boost/ticket/5944), + [#5757](https://svn.boost.org/trac/boost/ticket/5757), + [#5710](https://svn.boost.org/trac/boost/ticket/5710), + and [#5307](https://svn.boost.org/trac/boost/ticket/5307). +* [Proto](/libs/proto): + + + Force some functions to be inline, fixes [#5735](https://svn.boost.org/trac/boost/ticket/5735). + + Add user documentation for per-domain `as\_expr` + and `as\_child`; other + doc tweaks. + + Fix some buggy and over-complicated example programs. + + Add some missing copyright notices. +* [Spirit](/libs/spirit/index.html): + + + Spirit V2.5.2, see the '[What's + New](/doc/libs/1_49_0/libs/spirit/doc/html/spirit/what_s_new/spirit_2_5_2.html)' section for details. +* [Thread](/libs/thread): + + + Fixed Bugs: + + - [#2309](http://svn.boost.org/trac/boost/ticket/2309) + Lack of g++ symbol visibility support in Boost.Thread. + - [#2639](http://svn.boost.org/trac/boost/ticket/2639) + documentation should be extended(defer\_lock, try\_to\_lock, ...). + - [#3639](http://svn.boost.org/trac/boost/ticket/3639) + Boost.Thread doesn't build with Sun-5.9 on Linux. + - [#3762](http://svn.boost.org/trac/boost/ticket/3762) + Thread can't be compiled with winscw (Codewarrior by Nokia). + - [#3885](http://svn.boost.org/trac/boost/ticket/3885) + document about mix usage of boost.thread and native thread + api. + - [#3975](http://svn.boost.org/trac/boost/ticket/3975) + Incorrect precondition for promise::set\_wait\_callback(). + - [#4048](http://svn.boost.org/trac/boost/ticket/4048) + thread::id formatting involves locale + - [#4315](http://svn.boost.org/trac/boost/ticket/4315) + gcc 4.4 Warning: inline ... declared as dllimport: attribute + ignored. + - [#4480](http://svn.boost.org/trac/boost/ticket/4480) + OpenVMS patches for compiler issues workarounds. + - [#4819](http://svn.boost.org/trac/boost/ticket/4819) + boost.thread's documentation misprints. + - [#5040](http://svn.boost.org/trac/boost/ticket/5040) + future.hpp in boost::thread does not compile with /clr. + - [#5423](http://svn.boost.org/trac/boost/ticket/5423) + thread issues with C++0x. + - [#5502](http://svn.boost.org/trac/boost/ticket/5502) + race condition between shared\_mutex timed\_lock and lock\_shared. + - [#5594](http://svn.boost.org/trac/boost/ticket/5594) + boost::shared\_mutex not fully compatible with Windows CE. + - [#5617](http://svn.boost.org/trac/boost/ticket/5617) + boost::thread::id copy ctor. + - [#5739](http://svn.boost.org/trac/boost/ticket/5739) + set-but-not-used warnings with gcc-4.6. + - [#5826](http://svn.boost.org/trac/boost/ticket/5826) + threads.cpp: resource leak on threads creation failure. + - [#5839](http://svn.boost.org/trac/boost/ticket/5839) + thread.cpp: ThreadProxy leaks on exceptions. + - [#5859](http://svn.boost.org/trac/boost/ticket/5859) + win32 shared\_mutex constructor leaks on exceptions. + - [#6100](http://svn.boost.org/trac/boost/ticket/6100) + Compute hardware\_concurrency() using get\_nprocs() on GLIBC + systems. + - [#6141](http://svn.boost.org/trac/boost/ticket/6141) + Compilation error when boost.thread and boost.move are used + together. + - [#6168](http://svn.boost.org/trac/boost/ticket/6168) + recursive\_mutex is using wrong config symbol (possible typo). + - [#6175](http://svn.boost.org/trac/boost/ticket/6175) + Compile error with SunStudio. + - [#6200](http://svn.boost.org/trac/boost/ticket/6200) + patch to have condition\_variable and mutex error better handle + EINTR. + - [#6207](http://svn.boost.org/trac/boost/ticket/6207) + shared\_lock swap compiler error on clang 3.0 c++11. + - [#6208](http://svn.boost.org/trac/boost/ticket/6208) + try\_lock\_wrapper swap compiler error on clang 3.0 c++11. +* [Unordered](/libs/unordered): + + + On compilers without rvalue references, the containers are no longer + movable by default, as move emulation was causing some odd quirks + ([#6167](https://svn.boost.org/trac/boost/ticket/6167), + [#6311](https://svn.boost.org/trac/boost/ticket/6311)). + Define `BOOST\_UNORDERED\_USE\_MOVE` + to make them movable - Boost.Move is still used for elements regardless. + + Fix sequence point warning ([#6370](https://svn.boost.org/trac/boost/ticket/6370)). + + Better support for C++11 compilers using older standard libraries. +* [Uuid](/libs/uuid/): + + + fixed [#6258](https://svn.boost.org/trac/boost/ticket/6258) + + fixed [#5325](https://svn.boost.org/trac/boost/ticket/5325) + (sha1 implementation handles messages as long as the specification) + + progress on [#6118](https://svn.boost.org/trac/boost/ticket/6118) + (there are fewer warnings) +* [xpressive](/libs/xpressive/): + + + Eliminate some unused variable warnings on gcc. + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Intel: 11.1 + + LLVM Clang 2.8 + + GCC: 3.4.6, 4.2.4, 4.3.4, 4.4.3, 4.5.2, 4.6.2 + + GCC, C++0x mode: 4.3.4, 4.4.3, 4.5.2 +* OS X: + + + Intel: 11.1 + + GCC: 4.2.1, 4.4.4 + + GCC, C++0x mode: 4.4.4 +* Windows: + + + Visual C++ 8.0, 9.0, 10.0 + + GCC, mingw: 4.4.0, 4.4.7, 4.5.4, 4.6.1, 4.7.0 +* FreeBSD: + + + GCC 4.2.1, 32 and 64 bit. +* QNX: + + + QCC, C++0x mode: 4.4.2, 4.6.1, 4.6.2 + Boost's additional test compilers include: + + + +* Linux: + + + GCC: 4.2.4, 4.3.4, 4.4.4, 4.5.2, 4.6.2 + + GCC, C++0x mode: 4.3.4, 4.4.4, 4.5.2 + + pgCC: 11.9 + + Intel: 10.1, 11.1, 12.0 + + PathScale: 4.0.8 + + Visual Age 10.1 +* OS X: + + + Clang from subversion + + Intel 11.1, 12.0 + + GCC: 4.4.4 + + GCC, C++0x mode: 4.4.4 +* Windows: + + + Visual C++ 8.0, 9.0, 10.0 + + Visual C++ with STLport: 9.0 + + Visual C++, Windows Mobile 5, with STLport: 9.0 + + GCC, mingw: 4.4.0, 4.5.2 + + GCC, C++0x mode, mingw: 4.5.2 + + GCC, mingw 64-bit: 4.4.7, 4.5.4, 4.6.1 +* AIX: + + + IBM XL C/C++ Enterprise Edition, V11.1.0.0 +* FreeBSD: + + + GCC 4.2.1, 32 and 64 bit +* Solaris: + + + Sun 5.10 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James + and Vladimir Prus managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_50_0.html b/users/history/version_1_50_0.html new file mode 100644 index 0000000..c6d8fec --- /dev/null +++ b/users/history/version_1_50_0.html @@ -0,0 +1,562 @@ +--- +title: Version 1.50.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.50.0 + +/\*\*/ + + + + + + + +Version 1.50.0 +============== + +Version 1.50.0 +-------------- + + +June 28th, 2012 12:48 GMT + + +[Documentation](/doc/libs/1_50_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_50\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.50.0/boost_1_50_0.tar.bz2) | +| [boost\_1\_50\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.50.0/boost_1_50_0.tar.gz) | +| windows | [boost\_1\_50\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.50.0/boost_1_50_0.7z) | +| [boost\_1\_50\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.50.0/boost_1_50_0.zip) | + + +### Patches + + +* [Boost.Unordered patch](/patches/1_50_0/001-unordered.patch) + - Fixes a bug when compiled using a C++11 compiler, but with a C++03 allocator. + When inserting elements, `allocator\_traits` + detects that the node can be constructed using an accidental implicit conversion + which causes several problems. +* [Locale + Patch](http://cppcms.com/files/locale/boost_locale_utf.patch) - Fixes a bug which causes `boost::locale::utf::utf\_traits` + to accept some invalid UTF-8 sequences, which is a possible security flaw. + +### New Libraries + + +* [Algorithm](/libs/algorithm/): + A collection of + useful generic algorithms, from Marshall Clow. This includes several different + searching algorithms, as well as most of the new algorithms from the C++11 + standard library +* [Functional/OverloadedFunction](/libs/functional/overloaded_function/): + Overload + different functions into a single function object, from Lorenzo Caminiti. +* [LocalFunction](/libs/local_function/): + Program + functions locally, within other functions, directly within the scope where + they are needed, from Lorenzo Caminiti. +* [Utility/IdentityType](/libs/utility/identity_type/): + Wrap + types within round parenthesis so they can always be passed as macro parameters, + from Lorenzo Caminiti. + +### Updated Libraries + + +* [Accumulators](/libs/accumulators/): + + + add missing `#include + `, fixes [#6702](https://svn.boost.org/trac/boost/ticket/6702). + + work around for msvc which allows ctor templates to be copy ctors, + fixes [#6535](https://svn.boost.org/trac/boost/ticket/6535). + + shorten filenames to meet boost guidelines, fixes [#6196](https://svn.boost.org/trac/boost/ticket/6196). +* [Array](/libs/array/): + + + add support for Boost.Hash [#6791](https://svn.boost.org/trac/boost/ticket/6791). +* [Asio](/libs/asio/): + + + Changed the `epoll\_reactor` + backend to do lazy registration for `EPOLLOUT` + events. + + Fixed the `epoll\_reactor` + handling of out-of-band data, which was broken by an incomplete fix + in the last release. + + Changed Asio's SSL wrapper to respect OpenSSL's `OPENSSL\_NO\_ENGINE` + feature test `#define` + ([#6432](https://svn.boost.org/trac/boost/ticket/6432)). + + Fixed `windows::object\_handle` so that it works + with Windows compilers that support C++11 move semantics (such as + g++). + + Improved the performance of strand rescheduling. + + Added support for g++ 4.7 when compiling in C++11 + mode ([#6620](https://svn.boost.org/trac/boost/ticket/6620)). + + Fixed a problem where `signal\_set` + handlers were not being delivered when the `io\_service` + was constructed with a `concurrency\_hint` + of 1 ([#6657](https://svn.boost.org/trac/boost/ticket/6657)). +* [Bimap](/libs/bimap/): + + + Remove spurious dependency on Boost.Serialization, fixes [#3868](https://svn.boost.org/trac/boost/ticket/3868). + + Solve unused constructor parameter warning, fixes [#5749](https://svn.boost.org/trac/boost/ticket/5749). + + Add key\_type and mapped\_type (leaving data\_type for backward compatibility) + typedefs to map views, fixes [#6031](https://svn.boost.org/trac/boost/ticket/6031). +* [Chrono](/libs/chrono/): + + + Fixed Bugs: + + - [#6361](https://svn.boost.org/trac/boost/ticket/6361) + integer overflow in boost::chrono::process\_real\_cpu\_clock::now() + under Windows 32bits. + - [#6628](https://svn.boost.org/trac/boost/ticket/6628) + compiler warning in process\_cpu\_clocks.hpp. + - [#6666](https://svn.boost.org/trac/boost/ticket/6666) + thread\_clock.hpp needs pthread.h. +* [Concept Check](/libs/concept_check/): + + + Fixed: + + - [#6738](https://svn.boost.org/trac/boost/ticket/6738) + Shadowed variable warning. +* [Filesystem](/libs/filesystem/): + + + Remove Filesystem Version 2 from the distribution. Version 3 is now + the only distributed version. Those still using V2 are urged to migrate + to V3 as soon as possible. + + Add constexpr value\_type preferred\_separator to class path. + + Fix [#5118](https://svn.boost.org/trac/boost/ticket/5118), + `replace\_extension` + doesn't work as specified in documentation. The documentation, implementation, + and test cases have all had fixes applied. The documentation had + failed to mention that any existing extension is removed. The behavior + for simple cases has been reverted to the Version 2 behavior, but + with corrections so that complex replacements now work. Two test + cases from [#5118](https://svn.boost.org/trac/boost/ticket/5118) + have been added. + + Fix [#3737](https://svn.boost.org/trac/boost/ticket/3737), + Boost.Filesystem does not compile on Windows Mobile. On Windows, + `` is no longer included. + + Fix [#4065](https://svn.boost.org/trac/boost/ticket/4065), + Boost Filesystem lexicographic path comparison inconsistent. This + required multiple source code bug fixes and code cleanup, correcting + problems not related to lexicographical issues. + + Add class path member function compare for consistency with std::string. + + Tighten `BOOST\_FILESYSTEM\_DYN\_LINK` + and `BOOST\_FILESYSTEM\_STATIC\_LINK` + logic in `filesystem/config.hpp` + so that one or the other is always defined, and both being defined + is a `#error`. + + Fix [#6690](https://svn.boost.org/trac/boost/ticket/6690) + and [#6737](https://svn.boost.org/trac/boost/ticket/6737), + resolving static linking related problems with VC++ 8 through 11. + Note that this fix may reintroduce codecvt thread safety problems + [#4889](https://svn.boost.org/trac/boost/ticket/4889), + [#6320](https://svn.boost.org/trac/boost/ticket/6320), + for these compilers if static linking is used. + + Add `path::operator+=` + and concat functions to tack on things like suffixes or numbers. + Suggested by Ed Smith-Rowland and others. + + Fix [#6809](https://svn.boost.org/trac/boost/ticket/6809), + Implementation of `filesystem::rename()` method for MS Windows is wrong, + by adding `MOVEFILE\_COPY\_ALLOWED` + to deal with renames across drives, volumes, file systems. Fix has + no effect on non-Windows systems. + + Fix [#6819](https://svn.boost.org/trac/boost/ticket/6819), + A path operand with a source that was a one character array was treated + as empty, even if it wasn't empty. Such arrays can occur in unions + or in code using C variable length array idioms. + + Fix [#6932](https://svn.boost.org/trac/boost/ticket/6932), + create\_directories throws exception even if `error\_code` + is specified. +* [Foreach](/libs/foreach/): + + + Revert fix for [#6131](https://svn.boost.org/trac/boost/ticket/6131) + which caused more harm than good. +* [Geometry](/libs/geometry/): + + + Fixed Bugs: + + - the return type of comparable projected point strategy for + integer points was wrong (integer), fixed + - several robustness issues in intersection of segments and polygons, + fixed + - invalid intersection output is filtered out + - disjoint for multi\_polygon's might incorrectly return true, + fixed + + Solved tickets + + - [6585](https://svn.boost.org/trac/boost/ticket/6585) + patch for alternative syntax multipoint, applied + - [6584](https://svn.boost.org/trac/boost/ticket/6584) + patch for bug in distance, applied + - [5730](https://svn.boost.org/trac/boost/ticket/5730) + same issue as 6584, fixed + - [6166](https://svn.boost.org/trac/boost/ticket/6166) + patch for missing transformation, applied + - [6696](https://svn.boost.org/trac/boost/ticket/6696) + invalid intersection output, was (by chance) already fixed + in Trunk before reported + + Additional functionality + + - added algorithm "touches" (OGC SF compliant) for + \*polygon/\*polygon +* [Graph](/libs/graph/): + + + Fixed Bugs: + + - [#4622](https://svn.boost.org/trac/boost/ticket/4622) + clear\_vertex on a vertex with a self-loop can cause a segmentation + fault. + - [#6033](https://svn.boost.org/trac/boost/ticket/6033) + Lowpoint map calculated by biconnected\_components(...) is sometimes + wrong. + - [#6242](https://svn.boost.org/trac/boost/ticket/6242) + isomorphism doesn't reset mapping. + - [#6435](https://svn.boost.org/trac/boost/ticket/6435) + cube\_topology documentation should say 3D, not 2D. + - [#6520](https://svn.boost.org/trac/boost/ticket/6520) + small\_world\_1\_70\_6\_0p02.png is broken in documentation of graph\_parallel. + - [#6564](https://svn.boost.org/trac/boost/ticket/6564) + BGL copy constructor for subgraph does not track local vertices/edges. + - [#6573](https://svn.boost.org/trac/boost/ticket/6573) + BGL: boost::isomorphism routine fails with large graphs. + - [#6583](https://svn.boost.org/trac/boost/ticket/6583) + Dijkstra Visitor Concept docs probably show wrong type for + variable. + - [#6647](https://svn.boost.org/trac/boost/ticket/6647) + BGL strong\_components do not compile on MSVC 8. + - [#6656](https://svn.boost.org/trac/boost/ticket/6656) + Dependent type in subgraph used without typename. + - [#6707](https://svn.boost.org/trac/boost/ticket/6707) + is\_straight\_line\_drawing.hpp missing #include . + - [#6708](https://svn.boost.org/trac/boost/ticket/6708) + Make bool boost::intersects() in is\_straight\_line\_drawing.hpp + inline? + - [#6739](https://svn.boost.org/trac/boost/ticket/6739) + Cannot use write\_graphviz\_dp with a constified subgraph. + - [#6858](https://svn.boost.org/trac/boost/ticket/6858) + boost::get() calls wrongly resolved by g++. + - [#6892](https://svn.boost.org/trac/boost/ticket/6892) + VertexIndexGraph concept not required for bron\_kerbosch\_all\_cliques(). + - Other bugs and warnings not in Trac. +* [Hash](/libs/functional/hash/): + + + Support `std::array` and `std::tuple` + when available ([#6806](https://svn.boost.org/trac/boost/ticket/6806)). + + Avoid gcc's `-Wfloat-equal` + warning ([#6771](https://svn.boost.org/trac/boost/ticket/6771)). + + Add deprecation warning to the long deprecated `boost/functional/detail/container\_fwd.hpp`. +* [Iostreams](/libs/iostreams/): + + + Improved gzip support ([#5908](https://svn.boost.org/trac/boost/ticket/5908)). + + Update tests for latest Boost.Filesystem and Boost.Test. + + Fix some documentation errors ([#6530](https://svn.boost.org/trac/boost/ticket/6530), + [#6650](https://svn.boost.org/trac/boost/ticket/6650)). +* [Iterator](/libs/iterator/): + + + Fixed: + + - [#5127](https://svn.boost.org/trac/boost/ticket/5127) + Incorrect result\_of usage in transform\_iterator + - [#5697](https://svn.boost.org/trac/boost/ticket/5697) + iterator\_facade::operator-> is broken for proxy references +* [MultiArray](/libs/multi_array/): + + + Concepts bug fix and Workaround for Visual Studio 2010 ([#4874](https://svn.boost.org/trac/boost/ticket/4874)) + + Fix to assert.cpp test case ([Patch](https://svn.boost.org/trac/boost/changeset/78498)) +* [Lexical cast](/libs/conversion/lexical_cast.htm): + + + `boost::bad\_lexical\_cast` exception is now + globaly visible and can be catched even if code is compiled with + -fvisibility=hidden + + Now it is possible to compile and use library with disabled exceptions + [#5800](https://svn.boost.org/trac/boost/ticket/5800) + + Better performance, less memory usage and bugfixes for `boost::iterator\_range` + conversions + + Fixed bugs and warnings: [#6645](https://svn.boost.org/trac/boost/ticket/6645), + [#6562](https://svn.boost.org/trac/boost/ticket/6562), + [#6812](https://svn.boost.org/trac/boost/ticket/6812), + [#6852](https://svn.boost.org/trac/boost/ticket/6852), + [#6717](https://svn.boost.org/trac/boost/ticket/6717), + [#6770](https://svn.boost.org/trac/boost/ticket/6670), + [#6504](https://svn.boost.org/trac/boost/ticket/6504). +* [Locale](/libs/locale/): + + + Fixed build issues with STLPort library + + Boost.System is now required depenency + + Fixed bugs [#6635](https://svn.boost.org/trac/boost/ticket/6635), + [#6833](https://svn.boost.org/trac/boost/ticket/6833) +* [Math](/libs/math/): + + + Promoted math constants to be 1st class citizens, including convenient + access to the most widely used built-in float, double, long double + via three namespaces. + + Added the Owen's T function and Skew Normal distribution written + by Benjamin Sobotta. + + Added Hankel functions. + + Corrected issue [#6627 + nonfinite\_num\_put formatting of 0.0 is incorrect](https://svn.boost.org/trac/boost/ticket/6627) based on + a patch submitted by K R Walker. + + Changed constant initialization mechanism so that it is thread safe + even for user-defined types, also so that user defined types get + the full precision of the constant, even when `long + double` does not. So for example + 128-bit rational approximations will work with UDT's and do the right + thing, even though `long double` may be only 64 or 80 bits. + + Fixed issue in `bessel\_jy` + which causes Y[sub 8.5](4[pi]) to yield a NaN. +* [MSM](/libs/msm/): + + + eUML : better syntax for front-ends defined with eUML as transition + table only. Caution: Breaking Change! + + Bugfix: graph building was only working if initial\_state defined + as a sequence. + + Bugfix: flags defined for a Terminate or Interrupt state do not break + the blocking function of these states any more. + + Bugfix: multiple deferred events from several regions were not working + in every case. + + Bugfix: visitor was passed by value to submachines. + + Bugfix: no\_transition was not called for submachines who send an + event to themselves. + + Fixed warnings with gcc. +* [Program Options](/libs/program_options/): + + + Improved error reporting ([Patch + from Leo Goodstadt](https://svn.boost.org/trac/boost/changeset/77827)). + + Support for customizing name of option's value in help messages ([#4781](https://svn.boost.org/trac/boost/ticket/4781)) + + Fixed compilation with gcc 4.7 ([#6790](https://svn.boost.org/trac/boost/ticket/6790)). +* [PropertyMap](/libs/property_map/): + + + Fixed Bugs: + + - [#6539](https://svn.boost.org/trac/boost/ticket/6539) + the return type of get() is not documented correctly. + - [#6721](https://svn.boost.org/trac/boost/ticket/6721) + property\_map\_traits documentation does not mention reference. +* [Proto](/libs/proto/): + + + Use `decltype`-based + `result\_of` if and + only if the compiler implements N3276. + + For C++11, force parameter to `mpl::eval\_if\_c` + and `mpl::if\_c` to be `bool`. + + Disable '\_\_forceinline not inlined' warning on + msvc. +* [Ratio](/libs/ratio/): + + + Fixed Bugs: + + - [#6498](https://svn.boost.org/trac/boost/ticket/6498) + boost::ratio won't compile with default settings. +* [ScopeExit](/libs/scope_exit/): + + + New Features: + + - Use variadic macros to specify captures as commas-separated + lists (but kept preprocessor sequence syntax for backward compatibility). + - Capture the object in scope using `this\_`. + - Support empty captures using `void`. + - Implicit lambda-like captures using `BOOST\_SCOPE\_EXIT\_ALL` + on compilers that support C++11 lambda functions. +* [Thread](/libs/thread/): + + + New Features: + + - [#1850](https://svn.boost.org/trac/boost/ticket/1850) + Request for unlock\_guard to compliment lock\_guard. + - [#2637](https://svn.boost.org/trac/boost/ticket/2637) + Request for shared\_mutex duration timed\_lock and timed\_lock\_shared. + - [#2741](https://svn.boost.org/trac/boost/ticket/2741) + Proposal to manage portable and non portable thread attributes. + - [#3567](https://svn.boost.org/trac/boost/ticket/3567) + Request for shared\_lock\_guard. + - [#6194](https://svn.boost.org/trac/boost/ticket/6194) + Adapt to Boost.Move. + - [#6195](https://svn.boost.org/trac/boost/ticket/6195) + c++11 compliance: Provide the standard time related interface + using Boost.Chrono. + - [#6217](https://svn.boost.org/trac/boost/ticket/6217) + Enhance Boost.Thread shared mutex interface following Howard + Hinnant proposal. + - [#6224](https://svn.boost.org/trac/boost/ticket/6224) + c++11 compliance: Add the use of standard noexcept on compilers + supporting them. + - [#6226](https://svn.boost.org/trac/boost/ticket/6226) + c++11 compliance: Add explicit bool conversion from locks. + - [#6228](https://svn.boost.org/trac/boost/ticket/6228) + Add promise constructor with allocator following the standard + c++11. + - [#6230](https://svn.boost.org/trac/boost/ticket/6230) + c++11 compliance: Follows the exception reporting mechanism + as defined in the c++11. + - [#6266](https://svn.boost.org/trac/boost/ticket/6266) + Breaking change: thread destructor should call terminate if + joinable. + - [#6269](https://svn.boost.org/trac/boost/ticket/6269) + Breaking change: thread move assignment should call terminate + if joinable. + - [#6272](https://svn.boost.org/trac/boost/ticket/6272) + c++11 compliance: Add thread::id hash specialization. + - [#6273](https://svn.boost.org/trac/boost/ticket/6273) + c++11 compliance: Add cv\_status enum class and use it on the + conditions wait functions. + - [#6231](https://svn.boost.org/trac/boost/ticket/6231) + Add BasicLockable requirements in the documentation to follow + c++11. + - [#6342](https://svn.boost.org/trac/boost/ticket/6342) + c++11 compliance: Adapt the one\_flag to the c++11 interface. + - [#6671](https://svn.boost.org/trac/boost/ticket/6671) + upgrade\_lock: missing mutex and release functions. + - [#6672](https://svn.boost.org/trac/boost/ticket/6672) + upgrade\_lock:: missing constructors from time related types. + - [#6675](https://svn.boost.org/trac/boost/ticket/6675) + upgrade\_lock:: missing non-member swap. + - Added missing packaged\_task::result\_type and packaged\_task:: + constructor with allocator. + - Added packaged\_task::reset() + + Fixed Bugs: + + - [#2575](https://svn.boost.org/trac/boost/ticket/2575) + Bug- Boost 1.36.0 on Itanium platform. + - [#4345](https://svn.boost.org/trac/boost/ticket/4345) + thread::id and joining problem with cascade of threads. + - [#4921](https://svn.boost.org/trac/boost/ticket/4921) + BOOST\_THREAD\_USE\_DLL and BOOST\_THREAD\_USE\_LIB are crucial and + need to be documented. + - [#5013](https://svn.boost.org/trac/boost/ticket/5013) + documentation: boost::thread: pthreas\_exit causes terminate(). + - [#5173](https://svn.boost.org/trac/boost/ticket/5173) + boost::this\_thread::get\_id is very slow. + - [#5351](https://svn.boost.org/trac/boost/ticket/5351) + interrupt a future get boost::unknown\_exception. + - [#5516](https://svn.boost.org/trac/boost/ticket/5516) + Upgrade lock is not acquired when previous upgrade lock releases + if another read lock is present. + - [#5990](https://svn.boost.org/trac/boost/ticket/5990) + shared\_future::get() has wrong return type. + - [#6174](https://svn.boost.org/trac/boost/ticket/6174) + packaged\_task doesn't correctly handle moving results. + - [#6222](https://svn.boost.org/trac/boost/ticket/6222) + Compile error with SunStudio: unique\_future move. + - [#6673](https://svn.boost.org/trac/boost/ticket/6673) + shared\_lock: move assign doesn't works with c++11. + - [#6674](https://svn.boost.org/trac/boost/ticket/6674) + shared\_mutex: try\_lock\_upgrade\_until doesn't works. + - Fix issue signaled on the ML with task\_object(task\_object const&) + in presence of task\_object(task\_object&&) +* [Unordered](/libs/unordered/): + + + Fix equality for `unordered\_multiset` + and `unordered\_multimap`. + + Implement `reserve` + ([#6857](https://svn.boost.org/trac/boost/ticket/6857)). + + Avoid gcc's `-Wfloat-equal` + and `-Wshadow` + warnings ([#6190](https://svn.boost.org/trac/boost/ticket/6190), + [#6771](https://svn.boost.org/trac/boost/ticket/6771)). + + Fix namespace issue with bcp ([#6905](https://svn.boost.org/trac/boost/ticket/6905)). + + Fix Sun workarounds ([#6784](https://svn.boost.org/trac/boost/ticket/6784)). + + Some internal changes to bucket allocation. + + See the [change + log](/doc/html/unordered/changes.html#unordered.changes.boost_1_50_0) for full details. +* [Wave](/libs/wave/index.html): + + + Wave V2.3.2, see the [Changelog](/libs/wave/ChangeLog) + for details. +* [xpressive](/libs/xpressive/): + + + Remove very ugly `lexical\_cast` + hack with a slightly less ugly one. + + Replace MPL assert with static assert since it's problematic in C++11, + fixes [#6846](https://svn.boost.org/trac/boost/ticket/6846). + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Intel: 11.1 + + LLVM Clang 2.8 + + GCC: 4.2.4, 4.3.4, 4.4.3, 4.5.3, 4.6.2 + + GCC, C++0x mode: 4.3.4, 4.4.3, 4.5.3, 4.6.2 +* OS X: + + + Intel: 11.1 + + GCC: 4.4.4 + + GCC, C++0x mode: 4.4.4 +* Windows: + + + Visual C++ 8.0, 9.0, 10.0 + + GCC, mingw: 4.4.0, 4.4.7, 4.5.4, 4.6.1, 4.7.0 +* FreeBSD: + + + GCC 4.2.1, 32 and 64 bit +* QNX: + + + QCC, C++0x mode: 4.4.0, 4.4.7, 4.5.4, 4.6.3, 4.7.0 + Boost's additional test compilers include: + + + +* Linux: + + + Clang from subversion + + GCC: 4.2.4, 4.3.4, 4.4.4, 4.5.3, 4.6.2 + + GCC, C++0x mode: 4.3.4, 4.4.4, 4.5.3, 4.6.2 + + pgCC: 11.9 + + Intel: 10.1, 11.1, 12.0, 12.1 + + Visual Age 10.1 +* OS X: + + + Clang from subversion + + Intel 11.1, 12.0 + + GCC: 4.4.4 + + GCC, C++0x mode: 4.4.4 +* Windows: + + + Visual C++ 8.0, 10.0 + + Visual C++ with STLport: 9.0 + + Visual C++, Windows Mobile 5, with STLport: 9.0 + + GCC, mingw: 4.4.0, 4.4.7, 4.5.2, 4.5.4, 4.6.4, 4.7.0 + + GCC, C++0x mode, mingw: 4.5.2 +* AIX: + + + IBM XL C/C++ Enterprise Edition, V12.1.0.0 +* FreeBSD: + + + GCC 4.2.1, 32 and 64 bit +* Solaris: + + + Sun 5.10 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_51_0.html b/users/history/version_1_51_0.html new file mode 100644 index 0000000..f57caf4 --- /dev/null +++ b/users/history/version_1_51_0.html @@ -0,0 +1,299 @@ +--- +title: Version 1.51.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.51.0 + +/\*\*/ + + + + + + + +Version 1.51.0 +============== + +Version 1.51.0 +-------------- + + +August 20th, 2012 23:00 GMT + + +[Documentation](/doc/libs/1_51_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_51\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.51.0/boost_1_51_0.tar.bz2) | +| [boost\_1\_51\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.51.0/boost_1_51_0.tar.gz) | +| windows | [boost\_1\_51\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.51.0/boost_1_51_0.7z) | +| [boost\_1\_51\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.51.0/boost_1_51_0.zip) | + + +### Patches + + +* [Locale + Patch](http://cppcms.com/files/locale/boost_locale_utf.patch) - Fixes a bug which causes `boost::locale::utf::utf\_traits` + to accept some invalid UTF-8 sequences, which is a possible security flaw. + +### New Libraries + + +* [Context](/libs/context/): + Context switching library, + from Oliver Kowalke. + +### Updated Libraries + + +* [Algorithm](/libs/algorithm/): + + + Fixed `is\_sorted\_until` + ; now matches the c++11 standard behavior on ranges with duplicate + values. + + Added range support for the rest of the search algorithms. + + `unhex` now uses Boost.Exception + to signal bad input. +* [Asio](/libs/asio/): + + + Fixed an incompatibility between `ip::tcp::iostream` + and C++11 ([#7162](https://svn.boost.org/trac/boost/ticket/7162)). + + Decorated GCC attribute names with underscores to prevent interaction + with user-defined macros ([#6415](https://svn.boost.org/trac/boost/ticket/6415)). + + Added missing `#include + `, needed for some versions of + MinGW. + + Changed to use gcc's atomic builtins on ARM CPUs, + when available ([#7140](https://svn.boost.org/trac/boost/ticket/7140)). + + Changed strand destruction to be a no-op, to allow strand objects + to be destroyed after their associated `io\_service` + has been destroyed. + + Added support for some newer versions of glibc which provide the + `epoll\_create1()` + function but always fail with `ENOSYS` + ([#7012](https://svn.boost.org/trac/boost/ticket/7012)). + + Changed the SSL implementation to throw an exception if SSL engine + initialisation fails ([#6303](https://svn.boost.org/trac/boost/ticket/6303)). + + Fixed another regression in `buffered\_write\_stream` + ([#6310](https://svn.boost.org/trac/boost/ticket/6310)). + + Implemented various minor performance improvements, primarily targeted + at Linux x86 and x86-64 platforms. +* [Config](/libs/config/): + + + Deprecated a whole bunch of macros that were c++11 specific, but + not named to show that they were c++11 specific. Made new macros + with better names, and paired the old macros with the new ones. Updated + the documentation to list the deprecated macros. +* [Chrono](/libs/chrono/): + + + [#6918](https://svn.boost.org/trac/boost/ticket/6918) + Boost Chrono compilation failure on HP uX due to undefined pthread\_getcpuclockid. + + [#6241](https://svn.boost.org/trac/boost/ticket/6241) + boost::chrono compilation problems without std::wstring support. + + [#6987](https://svn.boost.org/trac/boost/ticket/6987) + Documentation & C++11. + + [#7041](https://svn.boost.org/trac/boost/ticket/7041) + time\_point.hpp depends on Boost.System. + + [#7042](https://svn.boost.org/trac/boost/ticket/7042) + Avoiding time\_point and duration dependency on time.h and CLOCK\_REALTIME. + + [#7058](https://svn.boost.org/trac/boost/ticket/7058) + Make it work when BOOST\_NO\_EXCEPTIONS is defined. + + [#7069](https://svn.boost.org/trac/boost/ticket/7069) + Misspellings in clock\_string. + + [#7081](https://svn.boost.org/trac/boost/ticket/7081) + WinError.h capitalization in boost/detail/win/basic\_types.hpp. +* [Geometry](/libs/geometry/): + + + points accessed through a pointer (e.g. in a linestring) should now + be specialized without the pointer. In previous versions a type + `my\_point` used like + `linestring` + had to be specalized like: `template<> struct + tag`. + Now the library itself removes the pointer before calling the traits + class, so now it should be like: `template<> struct + tag` + + intersection was sometimes wrong for integer points, fixed + + documentation, order of parameters in simplify was wrong, fixed + + [7030](https://svn.boost.org/trac/boost/ticket/7030) + spherical distance, fixed (by patch of Karsten Ahnert) +* [Graph](/libs/graph/): + + + Refactored support for internal and bundled properties in Boost.Graph-provided + graph types, and cleaned up named parameter functionality: + + - Enabled old-style (non-bundled) internal properties in `compressed\_sparse\_row\_graph`. + - Bundled properties should work correctly for all graph types + and adaptors. + + Bugs fixed: + + - [#6993](https://svn.boost.org/trac/boost/ticket/6993): Typo Bundled Properties document + - [#7002](https://svn.boost.org/trac/boost/ticket/7002): Problem with initialization of CSR bidirectional + graph + - [#7023](https://svn.boost.org/trac/boost/ticket/7023): Enclose internal type graphml\_reader in anonymous + namespace + - Other bugs and warnings not in Trac +* [Hash](/libs/functional/hash/): + + + Support the standard smart pointers. + + `hash\_value` now implemented + using SFINAE to avoid implicit casts to built in types when calling + it. + + Updated to use the new config macros. +* [Lexical cast](/libs/conversion/lexical_cast.htm): + + + Better performance, less memory usage for `boost::array` and `std::array` conversions. + + Fixed bug with volatile input parameter [#7157](https://svn.boost.org/trac/boost/ticket/7157). +* [Math](/libs/math/): + + + Updated to use the new config macros. +* [MSM](/libs/msm/): + + + Support for boost::any + or kleene + as acceptable events + + Bugfix: compiler error with fsm internal table and none (compound) + event. + + Bugfix: euml::defer\_ leading to stack overflow. +* [Proto](/libs/proto/): + + + Proto transforms get pseudo-parameter pack expansion support for + unpacking expressions. See the [Release + Notes](/doc/html/proto/appendices.html#boost_proto.appendices.release_notes.boost_1_51) for more information. +* [Ratio](/libs/ratio/): + + + [#7075](https://svn.boost.org/trac/boost/ticket/7075) + Workaround for error: the type of partial specialization template + parameter constant "n1" depends on another template parameter. +* [Regex](/libs/regex/): + + + Updated to use the new config macros. +* [Thread](/libs/thread/): + + + [#4258](https://svn.boost.org/trac/boost/ticket/4258) + Linking with boost thread does not work on mingw/gcc 4.5. + + [#4885](https://svn.boost.org/trac/boost/ticket/4885) + Access violation in set\_tss\_data at process exit due to invalid assumption + about TlsAlloc. + + [#6931](https://svn.boost.org/trac/boost/ticket/6931) + mutex waits forwever with Intel Compiler and /debug:parallel + + [#7044](https://svn.boost.org/trac/boost/ticket/7044) + boost 1.50.0 header missing. + + [#7052](https://svn.boost.org/trac/boost/ticket/7052) + Thread: BOOST\_THREAD\_PROVIDES\_DEPRECATED\_FEATURES\_SINCE\_V3\_0\_0 only + masks thread::operator==, thread::operator!= forward declarations, + not definitions. + + [#7066](https://svn.boost.org/trac/boost/ticket/7066) + An attempt to fix current\_thread\_tls\_key static initialization order. + + [#7074](https://svn.boost.org/trac/boost/ticket/7074) + Multiply defined symbol boost::allocator\_arg. + + [#7078](https://svn.boost.org/trac/boost/ticket/7078) + Trivial 64-bit warning fix on Windows for thread attribute stack + size + + [#7089](https://svn.boost.org/trac/boost/ticket/7089) + BOOST\_THREAD\_WAIT\_BUG limits functionality without solving anything +* [Unordered](/libs/unordered/): + + + Fix construction/destruction issue when using a C++11 compiler with + a C++03 allocator ([#7100](https://svn.boost.org/trac/boost/ticket/7100)). + + Remove a `try..catch` to support compiling without + exceptions. + + Adjust SFINAE use to try to supprt g++ 3.4 ([#7175](https://svn.boost.org/trac/boost/ticket/7175)). + + Updated to use the new config macros. +* [Wave](/libs/wave/): + + + See the [Changelog](/libs/wave/ChangeLog) for details. +* [xpressive](/libs/xpressive/): + + + Work around buggy wide ctype facet on cygwin and mingw. + + Work around absence of \_\_isctype on some glibc implementations. + + `op::as` shouldn't assume `string::iterator` != `char\*`. + + Fix assertion in `cpp\_regex\_traits` + on libc++, thanks to John Fletcher. + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + GCC: 4.2.4, 4.3.4, 4.4.3, 4.5.3, 4.6.2, 4.7 + + GCC, C++11 mode: 4.3.4, 4.4.3, 4.5.3, 4.6.2 + + Intel: 11.1, 12.0, 12.1 + + LLVM Clang 2.8 +* OS X: + + + GCC: 4.4 + + GCC, C++11 mode: 4.4 + + Intel: 11.1, 12.0 +* Windows: + + + GCC, mingw: 4.4.0, 4.4.7, 4.5.4, 4.6.3 + + Visual C++: 8.0, 9.0, 10.0 +* FreeBSD: + + + GCC: 4.2.1, 32 and 64 bit + Boost's additional test compilers include: + + + +* Linux: + + + Clang: from subversion + + LLVM Clang: 3.0 + + GCC: 4.2.4, 4.3.4, 4.4.4, 4.4.7, 4.5.3, 4.6.2, 4.6.3, 4.7.0, 4.7.1 + + GCC, C++11 mode: 4.3.4, 4.4.4, 4.5.3, 4.6.3 + + pgCC: 11.9 + + Intel: 10.1, 11.1, 12.0, 12.1 + + Visual Age: 10.1 +* OS X: + + + Clang: from subversion + + Clang, C++11 mode: from subversion + + Intel: 11.1, 12.0 + + GCC: 4.4 + + GCC, C++11 mode: 4.4 +* Windows: + + + Visual C++: 8.0, 9.0, 10.0 + + GCC, mingw: 4.4.0, 4.6.3, 4.7.0 +* AIX: + + + IBM XL C/C++ Enterprise Edition: V12.1.0.0 +* FreeBSD: + + + GCC: 4.2.1, 32 and 64 bit +* Solaris: + + + Sun: 5.10 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_52_0.html b/users/history/version_1_52_0.html new file mode 100644 index 0000000..f520146 --- /dev/null +++ b/users/history/version_1_52_0.html @@ -0,0 +1,420 @@ +--- +title: Version 1.52.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.52.0 + +/\*\*/ + + + + + + + +Version 1.52.0 +============== + +Version 1.52.0 +-------------- + + +November 5th, 2012 16:05 GMT + + +[Documentation](/doc/libs/1_52_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_52\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.52.0/boost_1_52_0.tar.bz2) | +| [boost\_1\_52\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.52.0/boost_1_52_0.tar.gz) | +| windows | [boost\_1\_52\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.52.0/boost_1_52_0.7z) | +| [boost\_1\_52\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.52.0/boost_1_52_0.zip) | + + +### Patches + + +* [Locale + Patch](http://cppcms.com/files/locale/boost_locale_utf.patch) - Fixes a bug which causes `boost::locale::utf::utf\_traits` + to accept some invalid UTF-8 sequences, which is a possible security flaw. + +### Updated Libraries + + +* [Accumulators](/libs/accumulators/): + + + Fix long-standing dependency tracking bug, [#7409](https://svn.boost.org/trac/boost/ticket/7409) +* [Config](/libs/config/): + + + Define `BOOST\_NO\_SFINAE\_EXPR` + for gcc-4.4, since the support was found to be too buggy. +* [Chrono](/libs/chrono/): + + + *New Features:* + + - [#5980](https://svn.boost.org/trac/boost/ticket/5980) Enhance chrono I/O with H. Hinnant proposal [proposal](http://home.roadrunner.com/~hinnant/bloomington/chrono_io.html) + which has the advantage to provide I/O for system clocks using + the Gregorian Calendar. + - [#5981](https://svn.boost.org/trac/boost/ticket/5981) Add i/o state savers for duration and time\_point formatting + state. + - [#7059](https://svn.boost.org/trac/boost/ticket/7059) Add low level i/o facilities. + + *Deprecated features:* + + - The chrono i/o version included in Boost.Chrono 1.2.x has been + completly refactored in version 2.0.0 + - chrono I/O: The manipulators `\_\_duration\_short`, + `\_\_duration\_long` + are depreceated. You should use the parameterized form `\_\_duration\_fmt` or the renamed + manipulators `\_\_duration\_symbol` + and `\_\_duration\_prefix` + instead. + - chrono I/O: The `\_\_duration\_punct<>` facet is deprecated. + You should use the `\_\_get\_duration\_style` + free function to get the informations and use the `\_\_duration\_units` facet for + localization purposes. + - When `BOOST\_CHRONO\_VERSION==2` + the preceding deprecated functions are not available. + + *Fixes:* + + - [#7381](https://svn.boost.org/trac/boost/ticket/7381) C++11 compliance: unresolved symbol when assigning + a constexpr duration to a non-const local variable. + - [#7479](http://svn.boost.org/trac/boost/ticket/7479) + Compile fails with compilers supporting constexpr fails if + the standard library doesn't provides the constexpr interface + + *Would not fix:* + + - [#6871](https://svn.boost.org/trac/boost/ticket/6871) chrono\_io.hpp: `operator<<(ostream& os, ...)` + modifies the state of os. The neww io interface provided in + version 2 solves this issue. You should move to the new version. +* [Container](/libs/container/): + + + Improved `stable\_vector`'s + template code bloat and type safety. + + Changed typedefs and reordered functions of sequence containers to + improve doxygen documentation. + + Fixed bugs [#6615](https://svn.boost.org/trac/boost/ticket/6615), + [#7139](https://svn.boost.org/trac/boost/ticket/7139), + [#7215](https://svn.boost.org/trac/boost/ticket/7215), + [#7232](https://svn.boost.org/trac/boost/ticket/7232), + [#7269](https://svn.boost.org/trac/boost/ticket/7269), + [#7439](https://svn.boost.org/trac/boost/ticket/7439). + + Implemented LWG Issue #149 (range insertion now returns an iterator) + & cleaned up insertion code in most containers + + Corrected aliasing errors. +* [DateTime](/libs/date_time/): + + + Document `BOOST\_DATE\_TIME\_NO\_LIB` + ([#6077](https://svn.boost.org/trac/boost/ticket/6077)). + + Fix `nth\_as\_str` ([#7022](https://svn.boost.org/trac/boost/ticket/7022)). + + Fix some warnings ([#7234](https://svn.boost.org/trac/boost/ticket/7234)). +* [Foreach](/libs/foreach/): + + + Fix alignment warning on gcc. +* [Function](/libs/function/): + + + Move constructors and move assignment operators added (only for compilers + with C++11 rvalue references support) [#7330](https://svn.boost.org/trac/boost/ticket/7330). +* [Graph](/libs/graph/): + + + Fixed bugs [#6950](https://svn.boost.org/trac/boost/ticket/6950), [#7226](https://svn.boost.org/trac/boost/ticket/7226),[#7308](https://svn.boost.org/trac/boost/ticket/7308), [#7327](https://svn.boost.org/trac/boost/ticket/7327), [#7338](https://svn.boost.org/trac/boost/ticket/7338), + [#7341](https://svn.boost.org/trac/boost/ticket/7341), [#7378](https://svn.boost.org/trac/boost/ticket/7378), [#7380](https://svn.boost.org/trac/boost/ticket/7380), [#7398](https://svn.boost.org/trac/boost/ticket/7398), and [#7428](https://svn.boost.org/trac/boost/ticket/7428), plus others + not in Trac. +* [Hash](/libs/functional/hash/): + + + Restore `enum` support, + which was accidentally removed in the last version ([#7437](https://svn.boost.org/trac/boost/ticket/7437)). + + New floating point hasher - will hash the binary representation on + more platforms, which should be faster. +* [Interprocess](/libs/interprocess/): + + + Added `shrink\_by` and + `advise` functions + in `mapped\_region`. + + *ABI breaking:* Reimplemented `message\_queue` + with a circular buffer index (the old behavior used an ordered array, + leading to excessive copies). This should greatly increase performance + but breaks ABI. Old behaviour/ABI can be used undefining macro `BOOST\_INTERPROCESS\_MSG\_QUEUE\_CIRCULAR\_INDEX` + in `boost/interprocess/detail/workaround.hpp` + + Improved `message\_queue` + insertion time avoiding priority search for common cases (both array + and circular buffer configurations). + + Implemented `interproces\_sharable\_mutex` + and `interproces\_condition\_any`. + + Improved `offset\_ptr` + performance. + + Added integer overflow checks. +* [Iterator](/libs/iterator/): + + + Fixed: + + - [#5825](https://svn.boost.org/trac/boost/ticket/5825) constructing function\_input\_iterator without consuming + an item + - [#7194](https://svn.boost.org/trac/boost/ticket/7194) Error in documentation of make\_function\_input\_iterator + + *Breaking changes:* + + - Due to the fix for [#5825](https://svn.boost.org/trac/boost/ticket/5825), a function\_input\_iterator will + no longer make unnecessary invokations to the wrapped nullary + function. For example, constructing an end iterator will now + not trigger an invokation; and dereferencing-and-incrementing + an iterator N times will trigger N invokations, not N+1 as + before. User code that relied on the old behavior will need + to be adjusted. +* [Lexical cast](/libs/conversion/lexical_cast.htm): + + + Restored compilation on MSVC-2003 (was broken in 1.51.0) [#7255](https://svn.boost.org/trac/boost/ticket/7255). + + Added `lexical\_cast(const CharType\* + chars, + std::size\_t count)` function overload. [#6663](https://svn.boost.org/trac/boost/ticket/6663). + + Fixed bug [#7228](https://svn.boost.org/trac/boost/ticket/7228). +* [Math](/libs/math/): + + + Added Airy functions and Jacobi Elliptic functions. + + In several distributions (particulary the Students T) corrected moments + for small degrees of freedom [#7177](https://svn.boost.org/trac/boost/ticket/7177) + (reported by Thomas Mang). + + Corrected failure to detect bad parameters in many distributions + [#6934](https://svn.boost.org/trac/boost/ticket/6934) + (reported by Florian Schoppmann) by adding a function `check\_out\_of\_range` to test many + possible bad parameters. This test revealed several distributions + where the checks for bad parameters were ineffective, and these have + been rectified. + + Fixed issue in Hankel functions that causes incorrect values to be + returned for *x < 0* and *ν* + odd, see [#7135](https://svn.boost.org/trac/boost/ticket/7135). + + In non-central T permitted infinite degrees of freedom [#7259](https://svn.boost.org/trac/boost/ticket/7259) + implemented using the normal distribution (requested by Thomas Mang). + Also much enhanced accuracy for large degrees of freedom and/or large + non-centrality parameters by switching to use the Students t distribution + (or Normal distribution for infinite degrees of freedom) centered + at delta, when delta / (4 \* v) < epsilon for the floating-point + type in use. See [#7259](https://svn.boost.org/trac/boost/ticket/7259). + It was also found that the incomplete beta was suffering from serious + cancellation errors when degrees of freedom was very large. (That + has now been fixed in our code, but any code based on Didonato and + Morris's original papers (probably every implementation out there + actually) will have the same issue). + + Fixed minor issues [#6517](https://svn.boost.org/trac/boost/ticket/6517), + [#6362](https://svn.boost.org/trac/boost/ticket/6362), + [#7053](https://svn.boost.org/trac/boost/ticket/7053), + [#2693](https://svn.boost.org/trac/boost/ticket/2693), + [#6937](https://svn.boost.org/trac/boost/ticket/6937), + [#7099](https://svn.boost.org/trac/boost/ticket/7099). +* [Phoenix](/libs/phoenix/): + + + Make Phoenix work with `decltype`-based + `boost::result\_of`. +* [Polygon](/libs/polygon/): + + + Included Voronoi diagram extensions. + + Introduced new Segment concept. + + Fixed compilation issues. +* [Proto](/libs/proto/): + + + The data parameter to primitive transforms can now optionally have + slots indexed by key. + + Primitive transforms can now operatate on temporary expressions that + are non-const qualified. + + Add callable function object types for the free functions in `` and also for some Boost.Range + functions. + + Boost.MPL algorithms work on Proto expression nodes. + + `proto::pass\_through` primitive transform + now accepts an optional `Domain` + template parameter for specifying the target domain of the resulting + expression. +* [Ratio](/libs/ratio/): + + + *Features:* + + - Replace the `short\_name` + and `long\_name` + functions by symbol and prefix functions respectively. + + *Deprecated:* + + - The `ratio\_string<>::short\_name` + and `ratio\_string<>::long\_name` + are deprecated. Use `ratio\_string<>::symbol` + and `ratio\_string<>::prefix` + respectively. These functions be removed in 1.55. + + *Fixes:* + + - [#7478](http://svn.boost.org/trac/boost/ticket/7478) + Compiles fails with compilers supporting char16\_t and char32\_t + fails if the library doesn't provides std::u16string and std::u32string. +* [Result\_of](/libs/utility/utility.htm#result_of): + + + Switch `boost::result\_of` to use `decltype` on compilers for which support + is deemed "good enough". That means if the compiler implements + [n3276](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3276.pdf). + (For now, that only includes very recent versions of clang.) + + `boost::result\_of` is now "sfinae-friendly" + when it uses `decltype`. + See [n3436](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3436.html). +* [Thread](/libs/thread/index.html): + + + *Deprecated Features*: Deprecated features since + boost 1.50 available only until boost 1.55. These deprecated features + will be provided by default up to boost 1.52. If you don't want to + include the deprecated features you could define BOOST\_THREAD\_DONT\_PROVIDE\_DEPRECATED\_FEATURES\_SINCE\_V3\_0\_0. + Since 1.53 these features will not be included any more by default. + Since this version, if you want to include the deprecated features + yet you could define BOOST\_THREAD\_PROVIDE\_DEPRECATED\_FEATURES\_SINCE\_V3\_0\_0. + These deprecated features will be only available until boost 1.55, + that is you have yet 1 year to move to the new features. + + - Time related functions don't using the Boost.Chrono library, + use the chrono overloads instead. + + Breaking changes when `BOOST\_THREAD\_VERSION==3` + (Default value since Boost 1.53): There are some new features which + share the same interface but with different behavior. These breaking + features are provided by default when BOOST\_THREAD\_VERSION is 3, + but the user can however choose the version 2 behavior by defining + the corresponding macro. As for the deprecated features, these broken + features will be only available until boost 1.55. + + - [#6229](https://svn.boost.org/trac/boost/ticket/6229) C++11 compliance & Breaking change: Rename the + unique\_future to future following the c++11. + - [#6266](https://svn.boost.org/trac/boost/ticket/6266) C++11 compliance & Breaking change: thread destructor + should call terminate if joinable. + - [#6269](https://svn.boost.org/trac/boost/ticket/6269) C++11 compliance & Breaking change: thread move + assignment should call terminate if joinable. + + *New Features:* + + - [#4710](https://svn.boost.org/trac/boost/ticket/4710) C++11 compliance: Missing `async()`. + - [#7283](https://svn.boost.org/trac/boost/ticket/7283) C++11 compliance: Add `notify\_all\_at\_thread\_exit`. + - [#7345](https://svn.boost.org/trac/boost/ticket/7345) C++11 compliance: Add `noexcept` + to recursive mutex `try\_lock`. + + *Fixed Bugs:* + + - [#2361](https://svn.boost.org/trac/boost/ticket/2361) `thread\_specific\_ptr`: + document nature of the key, complexity and rationale. + - [#2797](https://svn.boost.org/trac/boost/ticket/2797) Two problems with `thread\_specific\_ptr`. + - [#5274](https://svn.boost.org/trac/boost/ticket/5274) failed to compile `future.hpp` + with stlport 5.1.5 under msvc8.1, because of undefined class. + - [#5431](https://svn.boost.org/trac/boost/ticket/5431) compile error in Windows CE 6.0(interlocked). + - [#5752](https://svn.boost.org/trac/boost/ticket/5752) `boost::call\_once()` is unreliable on some platforms. + - [#7045](https://svn.boost.org/trac/boost/ticket/7045) Thread library does not automatically compile date\_time. + - [#7173](https://svn.boost.org/trac/boost/ticket/7173) wrong function name `interrupt\_point()`. + - [#7200](https://svn.boost.org/trac/boost/ticket/7200) Unable to build boost.thread modularized. + - [#7220](https://svn.boost.org/trac/boost/ticket/7220) gcc 4.6.2 warns about inline+dllimport functions. + - [#7238](https://svn.boost.org/trac/boost/ticket/7238) `this\_thread::sleep\_for()` does not respond to interrupt(). + - [#7245](https://svn.boost.org/trac/boost/ticket/7245) Minor typos on documentation related to version 3. + - [#7272](https://svn.boost.org/trac/boost/ticket/7272) `win32/thread\_primitives.hpp`: + (Unneccessary) Warning. + - [#7284](https://svn.boost.org/trac/boost/ticket/7284) Clarify that there is no access priority between lock + and shared\_lock on shared mutex. + - [#7329](https://svn.boost.org/trac/boost/ticket/7329) `boost/thread/future.hpp` + does not compile on HPUX. + - [#7336](https://svn.boost.org/trac/boost/ticket/7336) `BOOST\_THREAD\_DONT\_USE\_SYSTEM` + doesn't work. + - [#7349](https://svn.boost.org/trac/boost/ticket/7349) `packaged\_task` + holds reference to temporary. + - [#7350](https://svn.boost.org/trac/boost/ticket/7350) `allocator\_destructor` + does not destroy object +* [uBLAS](/libs/numeric/ublas/): + + + improved performance of inplace\_solve (issue [#4024](https://svn.boost.org/trac/boost/ticket/4024)) + + fixed coordinate\_matrix for use with gcc 4.7 (issue [#7363](https://svn.boost.org/trac/boost/ticket/7363)) +* [Unordered](/libs/unordered/): + + + In assignment, reuse existing nodes where possible. + + Fix bugs when erasing ranges ([#7471](https://svn.boost.org/trac/boost/ticket/7471)). + + Some work on the implementation. +* [Uuid](/libs/uuid/): + + + Fixes [#6118](https://svn.boost.org/trac/boost/ticket/6118), [#6788](https://svn.boost.org/trac/boost/ticket/6788), [#7375](https://svn.boost.org/trac/boost/ticket/7375). + + [#7128](https://svn.boost.org/trac/boost/ticket/7128) - fixed bug in `sha1.hpp` + for messages longer than 536,870,912 bytes. +* [Wave](/libs/wave/): + + + See the [Changelog](/libs/wave/ChangeLog) for details. +* [xpressive](/libs/xpressive/): + + + Make `sub\_match` work + with Boost.Range. Fixes [#7237](https://svn.boost.org/trac/boost/ticket/7237). + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + GCC: 4.2.4, 4.3.4, 4.4.3, 4.5.3, 4.6.2, 4.7.2 + + GCC, C++11 mode: 4.3.4, 4.4.3, 4.5.3, 4.6.2 + + Intel: 11.1, 12.0, 12.1 + + LLVM Clang: 2.8 +* OS X: + + + GCC: 4.4.4 + + GCC, C++11 mode: 4.4.4 + + Intel: 11.1, 12.0 +* Windows: + + + GCC, mingw: 4.4.0, 4.4.7, 4.5.4, 4.6.3, 4.7.0 + + Visual C++: 8.0, 9.0, 10.0 +* FreeBSD: + + + GCC: 4.2.1, 32 and 64 bit + Boost's additional test compilers include: + + + +* Linux: + + + Cray: 8.0 + + Clang: from subversion + + GCC: 4.2.4, 4.3.4, 4.4.4, 4.5.3, 4.6.2, 4.6.3, 4.7.0, 4.7.1, 4.7.2 + + GCC, C++11 mode: 4.3.4, 4.4.4, 4.5.3, 4.6.3, 4.7.1 + + pgCC: 11.9 + + Intel: 10.1, 11.1, 12.0, 12.1 + + Visual Age: 10.1 +* OS X: + + + Clang: from subversion + + Clang, C++11 mode: from subversion + + Intel: 11.1, 12.0 + + GCC: 4.4.4 + + GCC, C++11 mode: 4.4.4 +* Windows: + + + Visual C++: 8.0, 9.0, 10.0, 11.0 + + Visual C++ with STLport: 9.0 + + Visual C++, Windows Mobile 5, with STLport: 9.0 + + GCC, mingw: 4.4.0, 4.4.7, 4.5.4, 4.6.3, 4.7.0 +* AIX: + + + IBM XL C/C++ Enterprise Edition: V12.1.0.0 +* FreeBSD: + + + GCC: 4.2.1, 64 bit +* Solaris: + + + Sun: 5.10 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_53_0.html b/users/history/version_1_53_0.html new file mode 100644 index 0000000..b0c0688 --- /dev/null +++ b/users/history/version_1_53_0.html @@ -0,0 +1,533 @@ +--- +title: Version 1.53.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.53.0 + +/\*\*/ + + + + + + + +Version 1.53.0 +============== + +Version 1.53.0 +-------------- + + +February 4th, 2013 18:29 GMT + + +[Documentation](/doc/libs/1_53_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_53\_0.tar.bz2](https://sourceforge.net/projects/boost/files/boost/1.53.0/boost_1_53_0.tar.bz2) | +| [boost\_1\_53\_0.tar.gz](https://sourceforge.net/projects/boost/files/boost/1.53.0/boost_1_53_0.tar.gz) | +| windows | [boost\_1\_53\_0.7z](https://sourceforge.net/projects/boost/files/boost/1.53.0/boost_1_53_0.7z) | +| [boost\_1\_53\_0.zip](https://sourceforge.net/projects/boost/files/boost/1.53.0/boost_1_53_0.zip) | + + +### New Libraries + + +* [Atomic](/libs/atomic/): + C++11-style `atomic<>`, + from Helge Bahmann, maintained by Tim Blechmann. +* [Coroutine](/libs/coroutine/): + Coroutine library, + from Oliver Kowalke. +* [Lockfree](/libs/lockfree/): + Lockfree data structures, + from Tim Blechmann. +* [Multiprecision](/libs/multiprecision/): + Extended + precision arithmetic types for floating point, integer and rational arithmetic + from John Maddock and Christopher Kormanyos. +* [Odeint](/libs/numeric/odeint/): + Solving ordinary + differential equations, from Karsten Ahnert and Mario Mulansky. + +### News + This release contains a fix for ticket [#7743](https://svn.boost.org/trac/boost/ticket/7743), in Boost.Locale. For more + details, see the [security + notice](/users/news/boost_locale_security_notice.html). + + +### Updated Libraries + + +* [Algorithm](/libs/algorithm/): + + + Fixed non-ASCII char in comment ([#7781](https://svn.boost.org/trac/boost/ticket/7781)). + + Updated the Knuth-Morris-Pratt docs ([#7656](https://svn.boost.org/trac/boost/ticket/7656)). +* [Array](/libs/array/): + + + Added support for boost::get and std::get ([#7652](https://svn.boost.org/trac/boost/ticket/7652)) +* [Asio](/libs/asio/): + + + Fixed some 64-to-32-bit conversion warnings ([#7459](https://svn.boost.org/trac/boost/ticket/7459)). + + Fixed some small errors in documentation and comments ([#7761](https://svn.boost.org/trac/boost/ticket/7761)). + + Fixed an error in the example embedded in `basic\_socket::get\_option`'s + documentation ([#7562](https://svn.boost.org/trac/boost/ticket/7562)). + + Changed to use `long` + rather than `int` for + SSL\_CTX options, to match OpenSSL ([#7209](https://svn.boost.org/trac/boost/ticket/7209)). + + Changed to use `\_snwprintf` + to address a compile error due to the changed `swprintf` + signature in recent versions of MinGW ([#7373](https://svn.boost.org/trac/boost/ticket/7373)). + + Fixed a deadlock that can occur on Windows when shutting down a pool + of `io\_service` threads + due to running out of work ([#7552](https://svn.boost.org/trac/boost/ticket/7552)). + + Enabled the `noexcept` + qualifier for error categories ([#7797](https://svn.boost.org/trac/boost/ticket/7797)). + + Changed UNIX domain socket example to treat errors from `accept` as non-fatal ([#7488](https://svn.boost.org/trac/boost/ticket/7488)). + + Added a small block recycling optimisation to improve default memory + allocation behaviour. +* [Bimap](/libs/bimap/): + + + Refactor map\_view\_iterator to improve error messages. + + Fixed replace\_(left/right/key/data) bug when using relations with + info. + + Fixed vector\_of and list\_of views `assign(size\_type,value\_type)` bug. + + Fixed vector\_of views `operator[](size\_type)` and `at(size\_type)` functions return value. +* [Chrono](/libs/chrono/): + + + *Deprecated:* + + - The chrono i/o version included in Boost.Chrono 1.2.x has been + completly refactored in version 2.0.0 + - chrono I/O: The manipulators \_\_duration\_short, \_\_duration\_long + are depreceated. You should use the parameterized form \_\_duration\_fmt + or the renamed manipulators \_\_duration\_symbol and \_\_duration\_prefix + instead. + - chrono I/O: The \_\_duration\_punct<> facet is depreceated. + You should use the \_\_get\_duration\_style free function to get + the informations and use the \_\_duration\_units facet for localization + purposes. + - When BOOST\_CHRONO\_VERSION==2 the preceding deprecated functions + are not available. + + *Fixes:* + + - [#7546](https://svn.boost.org/trac/boost/ticket/7546) + time\_point output version 2 fails to compile + - [#7547](https://svn.boost.org/trac/boost/ticket/7547) + time\_point input version 2 fails to compile + - [#7868](https://svn.boost.org/trac/boost/ticket/7868) + chrono\_io parses time incorrectly (1.53 and 1.52) +* [Container](/libs/container/): + + + Fixed bug [#7650](https://svn.boost.org/trac/boost/ticket/7650). + + Improved `vector`'s + insertion performance. + + Changed again experimental multiallocation interface for better performance + (still experimental). + + Added no exception support for those willing to disable exceptions + in their compilers. + + Fixed GCC -Wshadow warnings. + + Replaced deprecated BOOST\_NO\_XXXX with newer BOOST\_NO\_CXX11\_XXX macros. +* [Context](/libs/context/): + + + Support for iOS on ARM and MacOS X on x86 (32bit) added. + + Support for SEH Overwrite Protection on Win32. +* [Geometry](/libs/geometry): + + + *Bugfixes* + + - avoid generating output polygons with interior rings below + minimum size (e.g. one or two points) + - `geometry::disjoint` for degenerate segments + (patched by Karsten Ahnert) + - problem in `geometry::difference` + for missing handling tangency, reported by H2 + - fixed `geometry::for\_each` + for use with Lambda's + - fixed `geometry::comparable\_distance` + point-linestring (and -range, -polygon) + + *Additional functionality* + + - combinations for `geometry::disjoint`: + point/ring, point/polygon, point/multi\_polygon + - combinations for `geometry::intersects`: + point/ring, point/polygon, point/multi\_polygon + + *Internal changes* + + - updates in specializations/not\_implemented for various algorithms + (as in an earlier version, these changes are still going on; + they take care for simplified structs, better error reporting, + and automatized documentation) + - fixes in unit tests +* [GIL](/libs/gil/): + + + Fixed self-assignment warnings ([#4919](https://svn.boost.org/trac/boost/ticket/4919)). +* [Graph](/libs/graph/): + + + Fixed the following bugs from Trac: [#3468](https://svn.boost.org/trac/boost/ticket/3468), [#4386](https://svn.boost.org/trac/boost/ticket/4386), [#5269](https://svn.boost.org/trac/boost/ticket/5269), + [#7428](https://svn.boost.org/trac/boost/ticket/7428), [#7457](https://svn.boost.org/trac/boost/ticket/7457), [#7467](https://svn.boost.org/trac/boost/ticket/7467), [#7600](https://svn.boost.org/trac/boost/ticket/7600), [#7648](https://svn.boost.org/trac/boost/ticket/7648), [#7684](https://svn.boost.org/trac/boost/ticket/7684), + [#7728](https://svn.boost.org/trac/boost/ticket/7728), [#7741](https://svn.boost.org/trac/boost/ticket/7741), [#7766](https://svn.boost.org/trac/boost/ticket/7766), [#7771](https://svn.boost.org/trac/boost/ticket/7771), [#7773](https://svn.boost.org/trac/boost/ticket/7773), [#7780](https://svn.boost.org/trac/boost/ticket/7780), + [#7787](https://svn.boost.org/trac/boost/ticket/7787), [#7801](https://svn.boost.org/trac/boost/ticket/7801) + plus other bugs not in Trac. + + Added support for reading from GraphML files containing multiple + graphs. + + Added versions of A\* search specifically for trees, removing the + need for a color map when it is acceptable to visit the same vertex + multiple times. + + Added VF2 subgraph isomorphism algorithm (contributed by Flavio De + Lorenzi). +* [Hash](/libs/functional/hash/): + + + Add support for `boost::int128\_type` + and `boost::uint128\_type` where available. + + On platforms that are known to have standard floating point functions, + don't use the automatic detection ([#7221](https://svn.boost.org/trac/boost/ticket/7221), [#7470](https://svn.boost.org/trac/boost/ticket/7470)). +* [Interprocess](/libs/interprocess/): + + + Fixed GCC -Wshadow warnings. + + Experimental multiple allocation interface improved and changed again. + Still unstable. + + Replaced deprecated BOOST\_NO\_XXXX with newer BOOST\_NO\_CXX11\_XXX macros. + + *ABI breaking*: changed node pool allocators internals + for improved efficiency. + + Fixed bug [#7795](https://svn.boost.org/trac/boost/ticket/7795). +* [Intrusive](/libs/intrusive/): + + + Fixed bugs [#7174](https://svn.boost.org/trac/boost/ticket/7174), + [#7529](https://svn.boost.org/trac/boost/ticket/7529), + [#7815](https://svn.boost.org/trac/boost/ticket/7815). + + Fixed GCC -Wshadow warnings. + + Added missing `explicit` + keyword in several intrusive container constructors. + + Replaced deprecated BOOST\_NO\_XXXX with newer BOOST\_NO\_CXX11\_XXX macros. + + Small documentation fixes. +* [Lexical cast](/libs/conversion/lexical_cast.htm): + + + New character type detection algorithm for user defined types [#6786](https://svn.boost.org/trac/boost/ticket/6786). + + Documentation updates ([#7582](https://svn.boost.org/trac/boost/ticket/7582), [#7831](https://svn.boost.org/trac/boost/ticket/7831)). + + Fixed bugs with std::array [#7799](https://svn.boost.org/trac/boost/ticket/7799). + + Fixed compilation with -ftrapv and numeric to numeric conversions + [#7814](https://svn.boost.org/trac/boost/ticket/7814). +* [Locale](/libs/locale/): + + + Security related bug fix, some invalid UTF-8 sequences where accepted + as valid [#7743](https://svn.boost.org/trac/boost/ticket/7743) + + Invalid Windows codepage names used [#7386](https://svn.boost.org/trac/boost/ticket/7386) + + Fixed missing documentation, caused by a error in Doxygen formatting + [#7734](https://svn.boost.org/trac/boost/ticket/7734) + + Fixed missing std:: in some places [#7701](https://svn.boost.org/trac/boost/ticket/7701) + + Spelling, grammar, typos fixes [#7368](https://svn.boost.org/trac/boost/ticket/7368), [#7762](https://svn.boost.org/trac/boost/ticket/7762) +* [Math](/libs/math/): + + + Fixed issues [#7325](https://svn.boost.org/trac/boost/ticket/7325), + [#7415](https://svn.boost.org/trac/boost/ticket/7415), + [#7416](https://svn.boost.org/trac/boost/ticket/7416), + [#7183](https://svn.boost.org/trac/boost/ticket/7183), + [#7649](https://svn.boost.org/trac/boost/ticket/7649), + [#7694](https://svn.boost.org/trac/boost/ticket/7694), + [#4445](https://svn.boost.org/trac/boost/ticket/4445) + and [#7492](https://svn.boost.org/trac/boost/ticket/7492). + + Fixed mistake in calculating pooled standard deviation in two-sample + students t example [#7402](https://svn.boost.org/trac/boost/ticket/7402). + + Improve complex acos/asin/atan, see [#7290](https://svn.boost.org/trac/boost/ticket/7290), + [#7291](https://svn.boost.org/trac/boost/ticket/7291). + + Improve accuracy in some corner cases of cyl\_bessel\_j and gamma\_p/gamma\_q + thanks to suggestions from Rocco Romeo. + + Improve accuracy in Bessel J and Y with integer orders thanks to + suggestions from Rocco Romeo. +* [MinMax](/libs/algorithm/minmax/): + + + Fixed a misuse of the comma operator ([#7752](https://svn.boost.org/trac/boost/ticket/7752)). + + Updated the docs to fix broken link ([#7751](https://svn.boost.org/trac/boost/ticket/7751)). +* [Move](/libs/move/): + + + Better header segregation (bug [#6524](https://svn.boost.org/trac/boost/ticket/6524)). + + Small documentation fixes + + Replaced deprecated BOOST\_NO\_XXXX with newer BOOST\_NO\_CXX11\_XXX macros. + + Fixed [#7830](https://svn.boost.org/trac/boost/ticket/7830), + [#7832](https://svn.boost.org/trac/boost/ticket/7832). +* [Polygon](/libs/polygon/): + + + *Fixes:* + + - [#6366](https://svn.boost.org/trac/boost/ticket/6366) Bug in `boost::polygon::contains` + for polygon\_90 type. + - [#7678](https://svn.boost.org/trac/boost/ticket/7678) multiple definitions of `bool + boost::polygon::belongs(...)` + by multiple `#include`. + + *Internal changes:* + + - refactored point/segment/interval data/concept/traits. + - added unit tests for point and interval data/concept/traits. + - simplified `transform.hpp` + to operate only in 2D. + - removed point\_3d data/concept/traits. +* [Random](/libs/random/): + + + Now compiles with exceptions disabled ([#5399](https://svn.boost.org/trac/boost/ticket/5399)). +* [Range](/libs/range/): + + + *Bug fixes:* + + - [#5603](https://svn.boost.org/trac/boost/ticket/5603) the "range/any\_range.hpp" header is not + self-sufficient + - [#6103](https://svn.boost.org/trac/boost/ticket/6103) boost::range\_detail vs. boost::range::range\_detail + compiler error + + *Documentation fixes:* + + - [#5160](https://svn.boost.org/trac/boost/ticket/5160) + - [#5314](https://svn.boost.org/trac/boost/ticket/5314) + - [#5440](https://svn.boost.org/trac/boost/ticket/5440) + - [#5775](https://svn.boost.org/trac/boost/ticket/5775) + - [#6212](https://svn.boost.org/trac/boost/ticket/6212) + - [#7585](https://svn.boost.org/trac/boost/ticket/7585) + - [#7843](https://svn.boost.org/trac/boost/ticket/7843) + - [#7916](https://svn.boost.org/trac/boost/ticket/7916) + - [#7926](https://svn.boost.org/trac/boost/ticket/7926) +* [Ratio](/libs/ratio/): + + + *Fixes:* + + - [#7616](https://svn.boost.org/trac/boost/ticket/7616) + br\_mul::nan - warning C4293: '<<' : shift count negative + or too big, undefined behavior`. +* [Regex](/libs/regex/): + Fixed Issues: [#7744](https://svn.boost.org/trac/boost/ticket/7744), + [#7644](https://svn.boost.org/trac/boost/ticket/7644). +* [Smart Pointers](/libs/smart_ptr/): + + + *New Features:* + + - Glen Fernandes provided implementations of make\_shared and + allocate\_shared for arrays. They achieve a single allocation + for an array that can be initialized with constructor arguments + or initializer lists as well as overloads for default initialization + and no value initialization. See the '[make\_shared + and allocate\_shared for arrays](/libs/smart_ptr/make_shared_array.html)' page for more information. + - `shared\_ptr` + can now be used to hold a pointer to a dynamically allocated + array. This is accomplished by using an array type (`T[]` + or `T[N]`) + as the template parameter. + - Smart pointers now use `explicit + operator bool` + on C++11 compilers. This can break code that passes a smart + pointer to a function taking a `bool`, + or that returns a smart pointer from a function with a `bool` return type. Please use + `p != + 0` or `!!p` in such cases. +* [StringAlgo](/libs/algorithm/string): + + + Fixed a bug where it wouldn't find overlapping patterns ([#7784](https://svn.boost.org/trac/boost/ticket/7784)). + + Disambiguated some calls to insert ([#7346](https://svn.boost.org/trac/boost/ticket/7346)). +* [Thread](/libs/thread/): + + + *Deprecated features:* + + - Deprecated features since boost 1.53 will be available only + until boost 1.58. + - C++11 compliance: packaged\_task is deprecated, use + instead packaged\_task. + - [#7537](https://svn.boost.org/trac/boost/ticket/7537) + deprecate Mutex::scoped\_lock and scoped\_try\_lock and boost::condition + + *New Features:* + + - [#6270](https://svn.boost.org/trac/boost/ticket/6270) + C++11 compliance: Add thread constructor from movable callable + and movable arguments + - [#7279](https://svn.boost.org/trac/boost/ticket/7279) + C++11 compliance: Add noexcept in system related functions + - [#7280](https://svn.boost.org/trac/boost/ticket/7280) + C++11 compliance: Add promise::...at\_thread\_exit functions + - [#7281](https://svn.boost.org/trac/boost/ticket/7281) + C++11 compliance: Add ArgTypes to packaged\_task template. + - [#7282](https://svn.boost.org/trac/boost/ticket/7282) + C++11 compliance: Add packaged\_task::make\_ready\_at\_thread\_exit + function + - [#7412](https://svn.boost.org/trac/boost/ticket/7412) + C++11 compliance: Add async from movable callable and movable + arguments + - [#7413](https://svn.boost.org/trac/boost/ticket/7413) + C++11 compliance: Add async when the launch policy is deferred. + - [#7414](https://svn.boost.org/trac/boost/ticket/7414) + C++11 compliance: future::get post-condition should be valid()==false. + - [#7422](https://svn.boost.org/trac/boost/ticket/7422) + Provide a condition variable with zero-overhead performance + penality. + - [#7444](https://svn.boost.org/trac/boost/ticket/7444) + Async: Add make\_future/make\_shared\_future. + - [#7540](https://svn.boost.org/trac/boost/ticket/7540) + Threads: Add a helper class that join a thread on destruction. + - [#7541](https://svn.boost.org/trac/boost/ticket/7541) + Threads: Add a thread wrapper class that joins on destruction. + - [#7575](https://svn.boost.org/trac/boost/ticket/7575) + C++11 compliance: A future created by async should "join" + in the destructor. + - [#7587](https://svn.boost.org/trac/boost/ticket/7587) + Synchro: Add strict\_lock and nested\_strict\_lock. + - [#7588](https://svn.boost.org/trac/boost/ticket/7588) + Synchro: Split the locks.hpp in several files to limit dependencies. + - [#7590](https://svn.boost.org/trac/boost/ticket/7590) + Synchro: Add lockable concept checkers based on Boost.ConceptCheck. + - [#7591](https://svn.boost.org/trac/boost/ticket/7591) + Add lockable traits that can be used with enable\_if. + - [#7592](https://svn.boost.org/trac/boost/ticket/7592) + Synchro: Add a null\_mutex that is a no-op and that is a model + of UpgardeLockable. + - [#7593](https://svn.boost.org/trac/boost/ticket/7593) + Synchro: Add a externally\_locked class. + - [#7594](https://svn.boost.org/trac/boost/ticket/7590) + Threads: Allow to disable thread interruptions. + + *Fixed Bugs:* + + - [#7464](https://svn.boost.org/trac/boost/ticket/7464) + BOOST\_TEST(n\_alive == 1); fails due to race condition in a + regression test tool. + - [#7657](https://svn.boost.org/trac/boost/ticket/7657) + Serious performance and memory consumption hit if condition\_variable + methods condition notify\_one or notify\_all is used repeatedly. + - [#7665](https://svn.boost.org/trac/boost/ticket/7665) + this\_thread::sleep\_for no longer uses steady\_clock in thread. + - [#7668](https://svn.boost.org/trac/boost/ticket/7668) + thread\_group::join\_all() should check whether its threads are + joinable. + - [#7669](https://svn.boost.org/trac/boost/ticket/7669) + thread\_group::join\_all() should catch resource\_deadlock\_would\_occur. + - [#7671](https://svn.boost.org/trac/boost/ticket/7671) + Error including boost/thread.hpp header on iOS. + - [#7672](https://svn.boost.org/trac/boost/ticket/7672) + lockable\_traits.hpp syntax error: "defined" token + misspelled. + - [#7798](https://svn.boost.org/trac/boost/ticket/7798) + boost::future set\_wait\_callback thread safety issues. + - [#7808](https://svn.boost.org/trac/boost/ticket/7808) + Incorrect description of effects for this\_thread::sleep\_for + and this\_thread::sleep\_until. + - [#7812](https://svn.boost.org/trac/boost/ticket/7812) + Returns: cv\_status::no\_timeout if the call is returning because + the time period specified by rel\_time has elapsed, cv\_status::timeout + otherwise. + - [#7874](https://svn.boost.org/trac/boost/ticket/7874) + compile warning: thread.hpp:342: warning: type attributes are + honored only at type definition. + - [#7875](https://svn.boost.org/trac/boost/ticket/7875) + BOOST\_THREAD\_THROW\_IF\_PRECONDITION\_NOT\_SATISFIED should not + be enabled by default. + - [#7882](https://svn.boost.org/trac/boost/ticket/7882) + wrong exception text from condition\_variable::wait(unique\_lock&). + - [#7890](https://svn.boost.org/trac/boost/ticket/7890) + thread::do\_try\_join\_until() is missing a return type. +* [Unordered](/libs/unordered/): + + + Remove support for the old pre-standard variadic pair constructors, + and equality implementation. Both have been deprecated since Boost + 1.48. + + More internal implementation changes, including a much simpler implementation + of `erase`, and removed + more deprecated config macros. +* [Utility](/libs/utility/): + + + Added [string\_ref](/libs/utility/doc/html/string_ref.html), + a non-owning reference to a contiguous sequence of characters. +* [Variant](/libs/variant/): + + + Added rvalue constructors and rvalue assignment operators (for C++11 + compatible compilers only). Library now can be used with move-only + types ([#7620](https://svn.boost.org/trac/boost/ticket/7620), [#7718](https://svn.boost.org/trac/boost/ticket/7718)). +* [Wave](/libs/wave/): + + + See the [Changelog](/libs/wave/ChangeLog) for details. +* [xpressive](/libs/xpressive/): + + + Accomodate recent smart pointer changes ([#7809](https://svn.boost.org/trac/boost/ticket/7809)). + +### Updated Tools + + +* [Boost Build System](/tools/build/index.html): + + + Qt5 toolset + + improved rcc support ([#7576](https://svn.boost.org/trac/boost/ticket/7576)) + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + GCC: 4.1.2, 4.2.4, 4.4.4, 4.5.3, 4.6.3, 4.7.2 + + GCC, C++11 mode: 4.4.4, 4.5.3, 4.6.3, 4.7.2 + + Intel: 11.1, 12.1 + + LLVM Clang: 2.8 + + LLVM Clang, with libc++: 3.2 +* OS X: + + + GCC: 4.4.7 + + GCC, C++11 mode: 4.4.4 + + Intel: 11.1, 12.0 +* Windows: + + + Visual C++: 9.0, 10.0 +* FreeBSD: + + + GCC: 4.2.1, 32 and 64 bit + Boost's additional test compilers include: + + + +* Linux: + + + Cray: 4.6.1 + + Clang: from subversion + + LLVM Clang, with libc++: 3.2 + + GCC: 4.2.4, 4.4.4, 4.5.3, 4.6.3, 4.7.1 + + GCC, C++11 mode: 4.4.4, 4.5.3, 4.6.3, 4.7.1, 4.7.2 + + pgCC: 11.9 + + Intel: 10.1, 11.1, 12.1 + + Intel, C++11 mode: 13.0.1 + + Visual Age: +* OS X: + + + Clang: from subversion + + Clang, C++11 mode: from subversion + + Intel: 11.1, 12.0 + + GCC: 4.4.7 + + GCC, C++11 mode: 4.4.4 +* Windows: + + + Visual C++: 10.0, 11.0 + + Visual C++ with STLport: 9.0 + + Visual C++, Windows Mobile 5, with STLport: 9.0 +* AIX: + + + IBM XL C/C++ Enterprise Edition: V12.1.0.1 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_54_0.html b/users/history/version_1_54_0.html new file mode 100644 index 0000000..32b38f4 --- /dev/null +++ b/users/history/version_1_54_0.html @@ -0,0 +1,651 @@ +--- +title: Version 1.54.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.54.0 + +/\*\*/ + + + + + + + +Version 1.54.0 +============== + +Version 1.54.0 +-------------- + + +July 1st, 2013 17:10 GMT + + +[Documentation](/doc/libs/1_54_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_54\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.54.0/boost_1_54_0.tar.bz2) | +| [boost\_1\_54\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.54.0/boost_1_54_0.tar.gz) | +| windows | [boost\_1\_54\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.54.0/boost_1_54_0.7z) | +| [boost\_1\_54\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.54.0/boost_1_54_0.zip) | + + +### Patches + These are patches from library authors which were found too late to be fixed + in the 1.54.0 release. Be careful as they have not been through the normal + testing process. + + + +1. [Coroutine patch](/patches/1_54_0/001-coroutine.patch) +2. [Date Time patch](/patches/1_54_0/002-date-time.patch) +3. [Log patch](/patches/1_54_0/003-log.patch) +4. [Thread patch](/patches/1_54_0/004-thread.patch) + +### News +### Supported CPUs + Boost no longer supports the 80386 target CPU, the minimum x86 32-bit target + is i486. The 80386 target was not properly supported by [Boost.SmartPtr](/libs/smart_ptr/) + and [Boost.Atomic](/libs/atomic/) (as well as the libraries + that used them internally) even before this release. Some Boost libraries + may have higher requirements on the minimum target CPU (like [Boost.Log](/libs/log/) + for example), see the respective library documentation for details. + + Also by default, when building Boost for x86 32-bit targets it will compile + for i686 (Pentium Pro) and later CPUs. This can be changed by specifying + the instruction-set property in b2 + or bjam command line, for example: + +``` +b2 variant=release architecture=x86 instruction-set=i486 stage + +``` + + + Possible values for the instruction-set are: + + + +* Target for the host CPU: native +* Generic x86 CPUs: i486, i586, + i686 +* Intel CPUs: pentium, pentium-mmx, + pentiumpro, pentium2, pentium3, + pentium3m, pentium-m, pentium4, + pentium4m, prescott, nocona, + core2, corei7, corei7-avx, + core-avx-i, conroe, conroe-xe, + conroe-l, allendale, merom, + merom-xe, kentsfield, kentsfield-xe, + penryn, wolfdale, yorksfield, + nehalem, sandy-bridge, ivy-bridge, + haswell, atom +* AMD CPUs: k6, k6-2, k6-3, + athlon, athlon-tbird, athlon-4, + athlon-xp, athlon-mp, k8, + opteron, athlon64, athlon-fx, + k8-sse3, opteron-sse3, athlon64-sse3, + amdfam10, barcelona, bdver1, + bdver2, bdver3, btver1, + btver2 +* VIA CPUs: c3, c3-2 +* IDT CPUs: winchip-c6, winchip2 + Note that not all these values may be supported by a particular compiler. + + +### Signals deprecated + Boost.Signals is no longer being actively maintained, so it has been deprecated. + Do not use Boost.Signals for new development (use [Boost.Signals2](/libs/signals2/) + instead). If you have existing Boost.Signals-based code, it will continue + to work, but consider moving to Boost.Signals2. There is [a + porting guide](/doc/html/signals2/api_changes.html#signals2.porting) in the Signals2 documentation. + + + +### New Libraries + + +* [Log](/libs/log/): + Logging library, from Andrey + Semashev. +* [TTI](/libs/tti/): + Type Traits Introspection library, + from Edward Diener. +* [Type Erasure](/libs/type_erasure/): + Runtime polymorphism + based on concepts. + +### Updated Libraries + + +* [Accumulators](/libs/accumulators/): + + + Fixes comment typos ([#7917](http://svn.boost.org/trac/boost/ticket/7917)) + + Silence unused variable warnings ([#6926](http://svn.boost.org/trac/boost/ticket/6926)) +* [Algorithm](/libs/algorithm/): + + + The return types for copy\_while and copy\_until have been changed. + This is an interface change. If you were using the return values + from these functions, then you will have to modify your code. Instead + of just returning the modified `OutputIterator`, + these functions now return a `std::pair`. If this change affects your + code, the simplest change is to add a `.second` to the end of the call, + which will get you the same behavior that you had before. + + Added C++14 versions of 'is\_permutation', 'equal' and 'mismatch'. +* [Any](/libs/any/): + + + Added C++11 features support [#6999](https://svn.boost.org/trac/boost/ticket/6999): + + - Move assignment and move constructors. + - Added `noexcept` + modifiers. +* [Asio](/libs/asio/): + + + Added new traits classes, `handler\_type` + and `async\_result`, + that allow the customisation of the return type of an initiating + function. + + Added the `asio::spawn()` + function, a high-level wrapper for running stackful coroutines, based + on the Boost.Coroutine library. The `spawn()` function enables programs to implement + asynchronous logic in a synchronous manner. For example: `size\_t n + = my\_socket.async\_read\_some(my\_buffer, yield);`. + + Added the `asio::use\_future` special value, which + provides first-class support for returning a C++11 `std::future` from an asynchronous operation's + initiating function. For example: `future n + = my\_socket.async\_read\_some(my\_buffer, asio::use\_future);`. + + Promoted the stackless coroutine class and macros to be part of Asio's + documented interface, rather than part of the HTTP server 4 example. + + Added a new handler hook called `asio\_handler\_is\_continuation`. + Asynchronous operations may represent a continuation of the asynchronous + control flow associated with the current executing handler. The + `asio\_handler\_is\_continuation` + hook can be customised to return `true` + if this is the case, and Asio's implementation can use this knowledge + to optimise scheduling of the new handler. To cover common cases, + Asio customises the hook for strands, `spawn()` and composed asynchronous operations. + + Added four new generic protocol classes, `generic::datagram\_protocol`, + `generic::raw\_protocol`, `generic::seq\_packet\_protocol` + and `generic::stream\_protocol`, which implement + the `Protocol` type + requirements, but allow the user to specify the address family (e.g. + `AF\_INET`) and protocol + type (e.g. `IPPROTO\_TCP`) + at runtime. + + Added C++11 move constructors that allow the conversion of a socket + (or acceptor) into a more generic type. For example, an `ip::tcp::socket` can be converted into a + `generic::stream\_protocol::socket` via move construction. + + Extended the `basic\_socket\_acceptor<>` class's `accept()` and `async\_accept()` functions to allow a new connection + to be accepted directly into a socket of a more generic type. For + example, an `ip::tcp::acceptor` can be used to accept + into a `generic::stream\_protocol::socket` object. + + Moved existing examples into a C++03-specific directory, and added + a new directory for C++11-specific examples. A limited subset of + the C++03 examples have been converted to their C++11 equivalents. + + Various SSL enhancements. Thanks go to Nick Jones, on whose work + these changes are based. + + - Added support for SSL handshakes with re-use of data already + read from the wire. New overloads of the `ssl::stream<>` class's `handshake()` + and `async\_handshake()` functions have been added. + These accept a `ConstBufferSequence` + to be used as initial input to the ssl engine for the handshake + procedure. + - Added support for creation of TLSv1.1 and TLSv1.2 `ssl::context` objects. + - Added a `set\_verify\_depth()` function to the `ssl::context` and `ssl::stream<>` + classes. + - Added the ability to load SSL certificate and key data from + memory buffers. New functions, `add\_certificate\_authority()`, `use\_certificate()`, `use\_certificate\_chain()`, `use\_private\_key()`, `use\_rsa\_private\_key()` and `use\_tmp\_dh()`, have been added to the + `ssl::context` class. + - Changed `ssl::context` + to automatically disable SSL compression by default. To enable, + use the new `ssl::context::clear\_options()` function, as in `my\_context.clear\_options(ssl::context::no\_compression)`. + + Fixed a potential deadlock in `signal\_set` + implementation. + + Fixed an error in acceptor example in documentation [#8421](https://svn.boost.org/trac/boost/ticket/8421). + + Fixed copy-paste errors in waitable timer documentation [#8602](https://svn.boost.org/trac/boost/ticket/8602). + + Added assertions to satisfy some code analysis tools [#7739](https://svn.boost.org/trac/boost/ticket/7739). + + Fixed a malformed `#warning` + directive [#7939](https://svn.boost.org/trac/boost/ticket/7939). + + Fixed a potential data race in the Linux `epoll` + implementation. + + Fixed a Windows-specific bug, where certain operations might generate + an `error\_code` with + an invalid (i.e. `NULL`) + `error\_category` [#8613](https://svn.boost.org/trac/boost/ticket/8613). + + Fixed `basic\_waitable\_timer`'s + underlying implementation so that it can handle any `time\_point` value without overflowing + the intermediate duration objects. + + Fixed a problem with lost thread wakeups that can occur when making + concurrent calls to `run()` and `poll()` on the same `io\_service` + object [#8354](https://svn.boost.org/trac/boost/ticket/8354). + + Fixed implementation of asynchronous connect operation so that it + can cope with spurious readiness notifications from the reactor [#7961](https://svn.boost.org/trac/boost/ticket/7961). +* [Chrono](/libs/chrono/): + + + *Fixed Bugs:* + + - [#8079](http://svn.boost.org/trac/boost/ticket/8079) + Chrono memory leak + - [#8318](http://svn.boost.org/trac/boost/ticket/8318) + BOOST\_FORCEINLINE constructors of time\_point and duration + - [#8367](http://svn.boost.org/trac/boost/ticket/8367) + chrono does not compile with clang from XCode 4.5.2 with -std=c++11 + -stdlib=libc++ and -arch armv7 + - [#8370](http://svn.boost.org/trac/boost/ticket/8370) + typo in chrono reference + - [#8435](http://svn.boost.org/trac/boost/ticket/8435) + Can't compile Chrono on HP-UX due to no CLOCK\_REALTIME macro. +* [Circular Buffer](/libs/circular_buffer): + + + Fixed warnings ([#8032](https://svn.boost.org/trac/boost/ticket/8032)). +* [Container](/libs/container/): + + + Added experimental `static\_vector` + class, based on Andrew Hundt's and Adam Wulkiewicz's high-performance + `varray` class. + + Speed improvements in `vector` + constructors/copy/move/swap, dispatching to memcpy when possible. + + Support for `BOOST\_NO\_EXCEPTIONS` + [#7227](https://svn.boost.org/trac/boost/ticket/7227). + + Fixed bugs [#7921](https://svn.boost.org/trac/boost/ticket/7921), + [#7969](https://svn.boost.org/trac/boost/ticket/7969), + [#8118](https://svn.boost.org/trac/boost/ticket/8118), + [#8294](https://svn.boost.org/trac/boost/ticket/8294), + [#8553](https://svn.boost.org/trac/boost/ticket/8553). +* [Context](/libs/context/): + + + Support for SPARC architecture added. +* [Coroutine](/libs/coroutine/): + + + Support for segmented stacks (stack grows on demand) added. + + [#7805](http://svn.boost.org/trac/boost/ticket/7805) + Typo + + [#7972](http://svn.boost.org/trac/boost/ticket/7972) + GCC warnings + + [#7988](http://svn.boost.org/trac/boost/ticket/7988) + C++11 range-for + + [#8023](http://svn.boost.org/trac/boost/ticket/8023) + Using iterator traits + + [#8024](http://svn.boost.org/trac/boost/ticket/8024) + Create const\_iterator + + [#8101](http://svn.boost.org/trac/boost/ticket/8101) + Postfix operator++ for iterator + + [#8526](http://svn.boost.org/trac/boost/ticket/8526) + memory leak + + [#8544](http://svn.boost.org/trac/boost/ticket/8544) + calling managed DLL +* [Geometry](/libs/geometry/): + + + *Additional functionality* + + - added Spatial Index, developed for Boost.Geometry by Adam Wulkiewicz. + The spatial index was originally started by Federico J. Fernandez + during the Google Summer of Code 2008 program, mentored by + Hartmut Kaiser. + - added SVG-output, this was already in extensions for several + years + + *Documentation* + + - small fixes of missing words + + *Bugfixes* + + - collinear opposite segments did sometimes (in circles) have + a robustness issue, fixed + - fixed insertion of false intersection point (found by buffer) + - applied patch of Vladimir Petrovic for debugging traversals + + *Solved tickets* + + - [7462](https://svn.boost.org/trac/boost/ticket/7462) + degenerate union result for float, fixed + - [7465](https://svn.boost.org/trac/boost/ticket/7465) + wrong construtors access type in scale\_transformer class, fixed + - [7802](https://svn.boost.org/trac/boost/ticket/7802) + cart\_intersect.hpp unused parameter warnings, fixed + - [8254](https://svn.boost.org/trac/boost/ticket/8254) + faulty intersection, fixed + - [8393](https://svn.boost.org/trac/boost/ticket/8393) + polygon model doesn't adhere to stated Polygon concept rules, + doc updated. + - [8403](https://svn.boost.org/trac/boost/ticket/8403) + silenced compiler warning C4127: conditional expression is + constant + - [8405](https://svn.boost.org/trac/boost/ticket/8405) + silenced compiler warning C4189: '...' : local variable is + initialized but not referenced + + *Internal changes* + + - Made several algorithms variant-aware (append, area, clear, + convert, equals, length, num\_points) +* [Graph](/libs/graph): + + + Bugs fixed from Trac: [#6780](https://svn.boost.org/trac/boost/ticket/6780), [#7016](https://svn.boost.org/trac/boost/ticket/7016), [#7155](https://svn.boost.org/trac/boost/ticket/7155), [#7845](https://svn.boost.org/trac/boost/ticket/7845), + [#7863](https://svn.boost.org/trac/boost/ticket/7863), [#7877](https://svn.boost.org/trac/boost/ticket/7877), [#8166](https://svn.boost.org/trac/boost/ticket/8166), [#8192](https://svn.boost.org/trac/boost/ticket/8192), [#8398](https://svn.boost.org/trac/boost/ticket/8398), [#8411](https://svn.boost.org/trac/boost/ticket/8411), + [#8427](https://svn.boost.org/trac/boost/ticket/8427), [#8428](https://svn.boost.org/trac/boost/ticket/8428), [#8434](https://svn.boost.org/trac/boost/ticket/8434), [#8490](https://svn.boost.org/trac/boost/ticket/8490), [#8681](https://svn.boost.org/trac/boost/ticket/8681). + + Added updates to VF2 subgraph isomorphism from Jakob Lykke Andersen + and Flavio De Lorenzi. + + Added maximum adjacency search from Fernando Vilas. + + Added timeout support from Brammert Ottens to resource-constrained + shortest paths (r\_c\_shortest\_paths) algorithm. + + Various fixes to documentation and examples and removal of outdated + compiler workarounds. +* [Interprocess](/libs/interprocess/): + + + Added support for platform-specific flags to mapped\_region (ticket + #8030) + + Fixed bugs [#7484](https://svn.boost.org/trac/boost/ticket/7484), + [#7598](https://svn.boost.org/trac/boost/ticket/7598), + [#7682](https://svn.boost.org/trac/boost/ticket/7682), + [#7923](https://svn.boost.org/trac/boost/ticket/7923), + [#7924](https://svn.boost.org/trac/boost/ticket/7924), + [#7928](https://svn.boost.org/trac/boost/ticket/7928), + [#7936](https://svn.boost.org/trac/boost/ticket/7936), + [#8521](https://svn.boost.org/trac/boost/ticket/8521), + [#8595](https://svn.boost.org/trac/boost/ticket/8595). + + **ABI breaking**: Changed bootstamp + function in Windows to use EventLog service start time as system + bootup time. Previously used `LastBootupTime` + from WMI was unstable with time synchronization and hibernation and + unusable in practice. If you really need to obtain pre Boost 1.54 + behaviour define `BOOST\_INTERPROCESS\_BOOTSTAMP\_IS\_LASTBOOTUPTIME` + from command line or `detail/workaround.hpp`. +* [Intrusive](/libs/intrusive/): + + + Added `BOOST\_NO\_EXCEPTIONS` + support (bug [#7849](https://svn.boost.org/trac/boost/ticket/7849)). +* [Iostreams](/libs/iostreams/): + + + `tee` now works correctly + for std::streams ([#8315](https://svn.boost.org/trac/boost/ticket/8315)). + + Documentation fixes ([#8385](https://svn.boost.org/trac/boost/ticket/8385), [#8460](https://svn.boost.org/trac/boost/ticket/8460)). + + Avoid warning from Clang's `-Wimplicit-fallthrough` ([#8482](https://svn.boost.org/trac/boost/ticket/8482)). +* [Lexical cast](/libs/conversion/lexical_cast.htm): + + + Converting to character pointer now triggers compile time assert + instead of runtime [#8334](https://svn.boost.org/trac/boost/ticket/8334). + + Lexical cast is now capable of converting `boost::int128\_type` + and `boost::uint128\_type` [#7909](https://svn.boost.org/trac/boost/ticket/7909). + + Changed internal stream buffer handling, now works with libc++ [#8267](https://svn.boost.org/trac/boost/ticket/8267), + [#7704](https://svn.boost.org/trac/boost/ticket/7704). + + Restored getting address of `lexical\_cast` + function that was broken in 1.53.0 [#7421](https://svn.boost.org/trac/boost/ticket/7421). + + Fixed warnings, internals and tests [#2558](https://svn.boost.org/trac/boost/ticket/2558), [#7949](https://svn.boost.org/trac/boost/ticket/7949), [#8162](https://svn.boost.org/trac/boost/ticket/8162), + [#8369](https://svn.boost.org/trac/boost/ticket/8369), [#8547](https://svn.boost.org/trac/boost/ticket/8547). +* [Math](/libs/math/): + + + Major reorganization to incorporate other Boost.Math like Integer + Utilities (Greatest Common Divisor and Least Common Multiple), quaternions + and octonions. Making new chapter headings. + + Added many references to Boost.Multiprecision and `cpp\_dec\_float\_50` + as an example of a User-defined Type (UDT). + + Added Clang to list of supported compilers. + + Fixed constants to use a thread-safe cache of computed values when + used at arbitrary precision. + + Added finding zeros of Bessel functions `cyl\_bessel\_j\_zero`, + `cyl\_neumann\_zero`, + `airy\_ai\_zeros` and + `airy\_bi\_zeros`(by + Christopher Kormanyos). + + More accuracy improvements to the Bessel J and Y functions from Rocco + Romeo. + + Fixed nasty cyclic dependency bug that caused some headers to not + compile [#7999](https://svn.boost.org/trac/boost/ticket/7999). + + Fixed bug in \_\_tgamma that caused spurious overflow for arguments + between 142.5 and 143. + + Fixed bug in raise\_rounding\_error that caused it to return an incorrect + result when throwing an exception is turned off [#7905](https://svn.boost.org/trac/boost/ticket/7905). + + Added minimal \_\_float128 support. + + Fixed bug in edge-cases of poisson quantile [#8308](https://svn.boost.org/trac/boost/ticket/8308). + + Adjusted heuristics used in Halley iteration to cope with inverting + the incomplete beta in tricky regions where the derivative is flatlining. + Example is computing the quantile of the Fisher F distribution for + probabilities smaller than machine epsilon. See ticket [#8314](https://svn.boost.org/trac/boost/ticket/8314). +* [Meta State Machine](/libs/msm/): + + + Bugfix: Exit points broken for the favor\_compile\_time policy. + + Bugfix: copy breaks exit points of subsubmachines. + + Bugfix: [#8046](https://svn.boost.org/trac/boost/ticket/8046) +* [Move](/libs/move/): + + + Fixed bugs [#7969](https://svn.boost.org/trac/boost/ticket/7969)), + [#8231](https://svn.boost.org/trac/boost/ticket/8231)). +* [Multiprecision](/libs/multiprecision/): + + + **Breaking change** renamed `rational\_adapter` to `rational\_adaptor`. + + Add support for [MPFI](http://perso.ens-lyon.fr/nathalie.revol/software.html). + + Add logged\_adaptor. + + Add support for 128-bit floats via GCC's `\_\_float128` + or Intel's `\_Quad` + data types. + + Add support for user-defined literals in cpp\_int, improve `constexpr` support. + + Fixed bug in integer division of `cpp\_int` + that results in incorrect sign of `cpp\_int` + when both arguments are small enough to fit in a `double\_limb\_type`. + See [8126](https://svn.boost.org/trac/boost/ticket/8126). + + Fixed bug in subtraction of a single limb in `cpp\_int` + that results in incorrect value when the result should have a 0 in + the last limb: [8133](https://svn.boost.org/trac/boost/ticket/8133). + + Fixed bug in `cpp\_int` + where division of 0 by something doesn't get zero in the result: + [8160](https://svn.boost.org/trac/boost/ticket/8160). + + Fixed bug in some transcendental functions that caused incorrect + return values when variables are reused, for example with `a = pow(a, b)`. + See [8326](https://svn.boost.org/trac/boost/ticket/8326). +* [Polygon](/libs/polygon/): + + + Updates and fixes to the Voronoi documentation. + + Bugs fixed from Trac: [#8026](https://svn.boost.org/trac/boost/ticket/8026), [#8197](https://svn.boost.org/trac/boost/ticket/8197), [#8257](https://svn.boost.org/trac/boost/ticket/8257). +* [PropertyMap](/libs/property_map/): + + + Added `compose\_property\_map` + from Guillaume Pinot. +* [Range](/libs/range/): + + + *Bug fixes:* + + - [#6944](https://svn.boost.org/trac/boost/ticket/6944) Some Range concepts use the incorrect Iterator concept + - [#7407](https://svn.boost.org/trac/boost/ticket/7407) istream\_range does not compile with wcin + - [#7408](https://svn.boost.org/trac/boost/ticket/7408) istream\_range should not pull istream + - [#7731](https://svn.boost.org/trac/boost/ticket/7731) irange doesn't end iteration properly when step\_size + is 3 or more + - [#7827](https://svn.boost.org/trac/boost/ticket/7827) [range] cant compile r | indexed to range algorithm + - [#8338](https://svn.boost.org/trac/boost/ticket/8338) Iterator range does not work with pointer to array + as iterator + - [#8453](https://svn.boost.org/trac/boost/ticket/8453) Incorrect configuration macro BOOST\_NO\_PARTIAL\_TEMPLATE\_SPECIALIZATION +* [Signals](/libs/signals/): + + + No longer actively maintained, so it is deprecated. Use [Signals2](/libs/signals2) + for new development. +* [Thread](/libs/thread/): + + + *New Features:* + + - [#7285](http://svn.boost.org/trac/boost/ticket/7285) + C++11 compliance: Allow to pass movable arguments for call\_once. + - [#7445](http://svn.boost.org/trac/boost/ticket/7445) + Async: Add future<>.then + - [#7449](http://svn.boost.org/trac/boost/ticket/7449) + Synchro: Add a synchronized value class + + *Fixed Bugs:* + + - [#4878](http://svn.boost.org/trac/boost/ticket/4878) + MinGW 4.5.0 undefined reference to bool interruptible\_wait(detail::win32::handle + handle\_to\_wait\_for,detail::t imeout target\_time). + - [#4882](http://svn.boost.org/trac/boost/ticket/4882) + Win32 shared\_mutex does not handle timeouts correctly. + - [#5752](http://svn.boost.org/trac/boost/ticket/5752) + boost::call\_once() is unreliable on some platforms + - [#6652](http://svn.boost.org/trac/boost/ticket/6652) + Boost.Thread shared\_mutex.hpp:50:99: warning: dereferencing + type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing] + - [#6843](http://svn.boost.org/trac/boost/ticket/6843) + [Intel C++] Compile Errors with '#include ' + - [#6966](http://svn.boost.org/trac/boost/ticket/6966) + future boost::future\_category inconsistent dll linkage + - [#7720](http://svn.boost.org/trac/boost/ticket/7720) + exception lock\_error while intensive locking/unlocking of mutex + - [#7755](http://svn.boost.org/trac/boost/ticket/7755) + Thread: deadlock with shared\_mutex on Windows + - [#7980](http://svn.boost.org/trac/boost/ticket/7980) + Build error: msvc-11.0 and BOOST\_THREAD\_DONT\_USE\_DATETIME + - [#7982](http://svn.boost.org/trac/boost/ticket/7982) + pthread\_delay\_np() parm compile error on AIX + - [#8027](http://svn.boost.org/trac/boost/ticket/8027) + thread library fails to compile with Visual Studio 2003 + - [#8070](http://svn.boost.org/trac/boost/ticket/8070) + prefer GetTickCount64 over GetTickCount + - [#8136](http://svn.boost.org/trac/boost/ticket/8136) + boost::this\_thread::sleep\_for() sleeps longer than it should + in Windows + - [#8212](http://svn.boost.org/trac/boost/ticket/8212) + Boost thread compilation error on Solaris 10 + - [#8237](http://svn.boost.org/trac/boost/ticket/8237) + fix documentation for 'thread\_group' + - [#8239](http://svn.boost.org/trac/boost/ticket/8239) + barrier::wait() not marked as interruption\_point + - [#8323](http://svn.boost.org/trac/boost/ticket/8323) + boost::thread::try\_join\_for/try\_join\_until may block indefinitely + due to a combination of problems in Boost.Thread and Boost.Chrono + - [#8337](http://svn.boost.org/trac/boost/ticket/8337) + The internal representation of "std::string(this->code()->message())" + escapes, but is destroyed when it exits scope. + - [#8371](http://svn.boost.org/trac/boost/ticket/8371) + C++11 once\_flag enabled when constexpr is not available + - [#8443](http://svn.boost.org/trac/boost/ticket/8443) + Header file inclusion order may cause crashes + - [#8451](http://svn.boost.org/trac/boost/ticket/8451) + Missing documented function 'boost::scoped\_thread::joinable' + - [#8530](http://svn.boost.org/trac/boost/ticket/8530) + [Coverity] Unused variable thread\_handle, uninitialized variable + cond\_mutex in thread/pthread/thread\_data.hpp + - [#8596](http://svn.boost.org/trac/boost/ticket/8596) + With C++0x enabled, boost::packaged\_task stores a reference + to function objects, instead of a copy. +* [Type Traits](/libs/type_traits/): + + + New type traits implemented [#8189](https://svn.boost.org/trac/boost/ticket/8189): + + - is\_nothrow\_move\_constructible + - is\_nothrow\_move\_assignable + - has\_trivial\_move\_assign + - has\_trivial\_move\_constructor +* [uBLAS](/libs/numeric/ublas): + + + [#6511](https://svn.boost.org/trac/boost/ticket/6511) Division by scalar should use `enable\_if<>` + + [#7297](https://svn.boost.org/trac/boost/ticket/7297) Make the free functions 'num\_columns' and 'num\_rows' support + the uBLAS traits system and better work with expression types + + [#6010](https://svn.boost.org/trac/boost/ticket/6010) fixed linkage problems in assignment.hpp + + updated doc +* [Unordered](/libs/unordered/): + + + Some very basic `noexcept` + support. +* [Utility](/libs/utility/): + + + Fix `basic\_string\_ref::find` + ([#8067](https://svn.boost.org/trac/boost/ticket/8067)). + + Fix `string\_ref`'s + logical operators. + + Update noncopyable for C++11 ([#6578](https://svn.boost.org/trac/boost/ticket/6578)). + + Fix noncopyable compiler warning when used in DLL interface ([#6935](https://svn.boost.org/trac/boost/ticket/6935)). + + Fix using `boost::addressof` with `boost::function` + on SolarisStudio compiler ([#7079](https://svn.boost.org/trac/boost/ticket/7079)). + + Disable annoying MSVC warning about operator comma ([#7663](https://svn.boost.org/trac/boost/ticket/7663)) +* [Variant](/libs/variant/): + + + Now uses new type traits from Boost.TypeTrait to detect `noexcept` constructors and assignment + operators [#8296](https://svn.boost.org/trac/boost/ticket/8296). This shall increase performance of `boost::variant` for many types in C++11. + + Multivisitation implemented [#8459](https://svn.boost.org/trac/boost/ticket/8459). + + Documentation updated to reflect C++11 features support. +* [Wave](/libs/wave/): + + + See the [Changelog](/libs/wave/ChangeLog) for details. +* [xpressive](/libs/xpressive): + + + Remove unused variables, fixes [#8039](https://svn.boost.org/trac/boost/ticket/8039) + + Avoid name clash with macro `None` + in glx.h, fixes [#8204](https://svn.boost.org/trac/boost/ticket/8204) + + Silence a gcc warning, fixes [#8138](https://svn.boost.org/trac/boost/ticket/8138) + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + GCC: 4.4.7, 4.5.3, 4.6.2, 4.6.3, 4.7.3 + + GCC, C++98 mode: 4.7.3 + + GCC, C++11 mode: 4.7.2, 4.7.3, 4.8.0 + + Clang: 3.0, 3.1, 3.2 + + Clang, C++11 mode: 3.2 +* OS X: + + + GCC: 4.2 + + Apple Clang: 4.2.1 + + Apple Clang, C++11 mode: 4.2.1 +* Windows: + + + GCC, mingw: 4.4.0, 4.4.7, 4.5.4, 4.6.3, 4.7.2, 4.8.0 + + Visual C++: 8.0, 9.0, 10.0, 11.0 +* FreeBSD: + + + GCC: 4.2.1 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.1, 3.2, from Subversion + + Clang, with libc++: 3.2 + + GCC: 4.4.7, 4.5.3, 4.6.2, 4.6.3, 4.7.2, 4.7.3 + + GCC, C++98 mode: 4.7.3 + + GCC, C++11 mode: 4.7.3, 4.8.0 +* OS X: + + + Apple Clang: 4.2.1 + + Apple Clang, C++11 mode: 4.2.1 + + Clang: from Subversion + + Clang, C++11 mode: from Subversion + + GCC: 4.2 +* Windows: + + + GCC, mingw: 4.4.0, 4.4.7, 4.5.4, 4.6.3, 4.7.2, 4.8.0 + + Visual C++: 9.0, 10.0, 11.0 + + Visual C++, Windows Mobile 5, with STLport: 9.0 +* AIX: + + + IBM XL C/C++ Enterprise Edition: 12.1.0.1 +* FreeBSD: + + + GCC: 4.2.1 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_55_0.html b/users/history/version_1_55_0.html new file mode 100644 index 0000000..e4e2e2e --- /dev/null +++ b/users/history/version_1_55_0.html @@ -0,0 +1,736 @@ +--- +title: Version 1.55.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.55.0 + +/\*\*/ + + + + + + + +Version 1.55.0 +============== + +Version 1.55.0 +-------------- + + +November 11th, 2013 19:50 GMT + + +[Documentation](/doc/libs/1_55_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_55\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.55.0/boost_1_55_0.tar.bz2) | +| [boost\_1\_55\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.55.0/boost_1_55_0.tar.gz) | +| windows | [boost\_1\_55\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.55.0/boost_1_55_0.7z) | +| [boost\_1\_55\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.55.0/boost_1_55_0.zip) | + + +### Other Downloads + + +* [Windows + binaries](https://sourceforge.net/projects/boost/files/boost-binaries/1.55.0/) +* [PDF + documentation](https://sourceforge.net/projects/boost/files/boost-docs/1.55.0/) (only for BoostBook based documentation). + +### News + Support was removed from [Config](/libs/config/) for some + very old versions of compilers. The new minimum requirements are: + + + +* Digitial Mars 8.41 +* GCC 3.3 +* Intel 6.0 +* Visual C++ 7.1 +**Note:** This is just the mininimum requirements + for Config. Some Boost libraries may have higher mininimum requirements and + not support all platforms or compilers. + + Other compilers are currently unchanged, but we are considering removing support + for some other old compilers. **Candidates** for + removal are: + + + +* Metroworks C++ (i.e. codewarrior) +* SunPro 5.7 and earlier +* Borland C++ Builder 2006 (5.82) and earlier + If you're using any of these, please let us know on the mailing lists. We will + take into account any feedback received before making a decision. + + +### Known Bugs with Visual Studio + 2013/Visual C++ 12 + Visual Studio 2013 was released quite late in the release process, so there + exist several unresolved issues. These include: + + + +* Serialization can't compile because of a missing include. +* Using `has\_member\_function\_callable\_with` + from Boost.Container's `allocator\_traits` + causes a compile error ([#9332](https://svn.boost.org/trac/boost/ticket/9332)). +* In libraries such as Unordered and MultiIndex, calling overloaded functions + with initializer lists can result in a compile error, with Visual C++ claiming + that the overloads are ambiguous. This is a Visual C++ bug and it isn't + clear if there's a good workaround. This won't affect code that doesn't + use initializer lists, or uses an initializer list that doesn't require + an implicit conversion (i.e. an initializer list of the container's exact + value type). +* Thread: `ex\_scoped\_thread` + compile fails ([#9333](https://svn.boost.org/trac/boost/ticket/9333)). + +### Patches + + +1. [Log patch](/patches/1_55_0/001-log_fix_dump_avx2.patch): + fixes incorrect output of the [dump](https://www.boost.org/doc/libs/1_55_0/libs/log/doc/html/log/detailed/utilities.html#log.detailed.utilities.manipulators.dump) + manipulator, when used on AVX2-enabled CPU (e.g. Intel Haswell). + +### New Libraries + + +* [Predef](/libs/predef/): This library defines a + set of compiler, architecture, operating system, library, and other version + numbers from the information it can gather of C, C++, Objective C, and + Objective C++ predefined macros or those defined in generally available + headers, from Rene Rivera. + +### Updated Libraries + + +* [Accumulators](/libs/accumulators/): + + + [#7915](https://svn.boost.org/trac/boost/ticket/7915) Fix silly typos. + + [#8850](https://svn.boost.org/trac/boost/ticket/8850) Fix MSVC warnings. + + [#8262](https://svn.boost.org/trac/boost/ticket/8262) Rename `average` + to `fdiv`. +* [Any](/libs/any/): + + + `boost::bad\_any\_cast` exception is now visible + across modules [#8751](https://svn.boost.org/trac/boost/ticket/8751). + + Added `clear()` + member function. + + Added missing `BOOST\_NOEXCEPT`. + + Fixed issue with const rvalues [#9215](https://svn.boost.org/trac/boost/ticket/9215). +* [Asio](/libs/asio/): + + + Implemented a limited port to Windows Runtime. This support requires + that the language extensions be enabled. Due to the restricted facilities + exposed by the Windows Runtime API, the port also comes with the + following caveats: + + - The core facilities such as the `io\_service`, + `strand`, buffers, + composed operations, timers, etc., should all work as normal. + - For sockets, only client-side TCP is supported. + - Explicit binding of a client-side TCP socket is not supported. + - The `cancel()` function is not supported + for sockets. Asynchronous operations may only be cancelled + by closing the socket. + - Operations that use `null\_buffers` + are not supported. + - Only `tcp::no\_delay` and `socket\_base::keep\_alive` options are supported. + - Resolvers do not support service names, only numbers. I.e. + you must use "80" rather than "http". + - Most resolver query flags have no effect. + + Fixed a regression (introduced in Boost 1.54) where, on some platforms, + errors from `async\_connect` + were not correctly propagated through to the completion handler ([#8795](https://svn.boost.org/trac/boost/ticket/8795)). + + Fixed a Windows-specific regression (introduced in Boost 1.54) that + occurs when multiple threads are running an `io\_service`. + When the bug occurs, the result of an asynchronous operation (error + and bytes transferred) is incorrectly discarded and zero values used + instead. For TCP sockets this results in spurious end-of-file notifications + ([#8933](https://svn.boost.org/trac/boost/ticket/8933)). + + Fixed a bug in handler tracking, where it was not correctly printing + out some handler IDs ([#8808](https://svn.boost.org/trac/boost/ticket/8808)). + + Fixed the comparison used to test for successful synchronous accept + operations so that it works correctly with unsigned socket descriptors + ([#8752](https://svn.boost.org/trac/boost/ticket/8752)). + + Ensured the signal number is correctly passed to the completion handler + when starting an `async\_wait` + on a signal that is already raised ([#8738](https://svn.boost.org/trac/boost/ticket/8738)). + + Suppressed a g++ 4.8+ warning about unused typedefs ([#8980](https://svn.boost.org/trac/boost/ticket/8980)). + + Enabled the move optimisation for handlers that use the default invocation + hook ([#8624](https://svn.boost.org/trac/boost/ticket/8624)). + + Clarified that programs must not issue overlapping `async\_write\_at` operations ([#8669](https://svn.boost.org/trac/boost/ticket/8669)). + + Changed the Windows `HANDLE` + backend to treat `ERROR\_MORE\_DATA` + as a non-fatal error when returned by `GetOverlappedResult` + for a synchronous read ([#8722](https://svn.boost.org/trac/boost/ticket/8722)). + + Visual C++ language extensions use `generic` + as a keyword. Added a workaround that renames the namespace to `cpp\_generic` when those language + extensions are in effect. + + Fixed some asynchronous operations that missed out on getting `async\_result` support in Boost 1.54. + In particular, the buffered stream templates have been updated so + that they adhere to current handler patterns ([#9000](https://svn.boost.org/trac/boost/ticket/9000), [#9001](https://svn.boost.org/trac/boost/ticket/9001)). + + Enabled move support for Microsoft Visual Studio 2012 ([#8959](https://svn.boost.org/trac/boost/ticket/8959)). + + Added `use\_future` + support for Microsoft Visual Studio 2012. + + Removed a use of `std::min` + in the Windows IOCP backend to avoid a dependency on the `` header ([#8758](https://svn.boost.org/trac/boost/ticket/8758)). + + Eliminated some unnecessary handler copies. + + Fixed various minor and cosmetic issues in code and documentation + (including [#8347](https://svn.boost.org/trac/boost/ticket/8347), [#8950](https://svn.boost.org/trac/boost/ticket/8950), [#8953](https://svn.boost.org/trac/boost/ticket/8953), [#8965](https://svn.boost.org/trac/boost/ticket/8965), [#8997](https://svn.boost.org/trac/boost/ticket/8997)). +* [Atomic](/libs/atomic/): + + + Added support for 64-bit atomic operations on x86 target for GCC, + MSVC and compatible compilers. The support is enabled when it is + known at compile time that the target CPU supports required instructions. + + Added support for 128-bit atomic operations on x86-64 target for + GCC and compatible compilers. The support is enabled when it is known + at compile time that the target CPU supports required instructions. + The support can be tested for with the new `BOOST\_ATOMIC\_INT128\_LOCK\_FREE` + macro. + + Added a more efficient implementation of `atomic<>` based on GCC `\_\_atomic\*` + intrinsics available since GCC 4.7. + + Added support for more ARM v7 CPUs, improved detection of Thumb 2. + + Added support for x32 (i.e. 64-bit x86 with 32-bit pointers) target + on GCC and compatible compilers. + + Removed dependency on Boost.Thread. + + Internal lock pool now includes proper padding and alignment to avoid + false sharing. + + Fixed compilation with Intel compiler on Windows. Removed internal + macro duplication when compiled on Windows. + + Some code refactoring to use C++11 features when available. +* [Chrono](/libs/chrono/): + + + *Fixed Bugs:* + + - [#7868](http://svn.boost.org/trac/boost/ticket/7868) + `chrono\_io` parses + time incorrectly (1.53 and 1.52) + - [#9028](http://svn.boost.org/trac/boost/ticket/9028) + Typo in `boost/chrono/stopwatches/formatters/base\_formatter.hpp` + - [#9147](http://svn.boost.org/trac/boost/ticket/9147) + uninitialized `std::tm` +* [Circular Buffer](/libs/circular_buffer/): + + + Added support for rvalue references and rvalue references emulation + using Boost.Move. Values are moved only if value type has noexcept + move constructor and noexcept move assignment operator [#7888](https://svn.boost.org/trac/boost/ticket/7888). + Now Circular Buffer is usable with move-only types. + + Much better documentation. + + [#5362](http://svn.boost.org/trac/boost/ticket/5362) + circular\_buffer does not compile with `BOOST\_NO\_EXCEPTIONS`. + + [#7025](http://svn.boost.org/trac/boost/ticket/7025) + circular buffer reports warning: " type qualifiers ignored on + function return type" while compile. + + [#7950](http://svn.boost.org/trac/boost/ticket/7950) + Eliminate W4-warnings under VS2005 - warning C4913: user defined + binary operator ',' exists but no overload could convert all operands, + default built-in binary operator ',' used. +* [Config](/libs/config/): + + + **Breaking change:** Removed support + for some older compilers. The new minimum compiler versions are: + + - Digitial Mars 8.41 + - GCC 3.3 + - Intel 6.0 + - Visual C++ 7.1 + Other compilers are unchanged. +* [Container](/libs/container/): + + + Implemented SCARY + iterators. + + Fixed bugs [#8269](https://svn.boost.org/trac/boost/ticket/8269), + [#8473](https://svn.boost.org/trac/boost/ticket/8473), + [#8892](https://svn.boost.org/trac/boost/ticket/8892), + [#9009](https://svn.boost.org/trac/boost/ticket/9009), + [#9064](https://svn.boost.org/trac/boost/ticket/9064), + [#9092](https://svn.boost.org/trac/boost/ticket/9092), + [#9108](https://svn.boost.org/trac/boost/ticket/9108). +* [Context](/libs/context/): + + + [#8650](http://svn.boost.org/trac/boost/ticket/8650) + SSE2 intrinsics +* [Coroutine](/libs/coroutine/): + + + New interface (unidirectional data transfer). + + [#8782](http://svn.boost.org/trac/boost/ticket/8782) + no best alternative + + [#8801](http://svn.boost.org/trac/boost/ticket/8801) + auto-linking +* [Filesystem](/libs/filesystem/): + + + Fixed Android compilation [#8706](https://svn.boost.org/trac/boost/ticket/8706). +* [Fusion](/libs/fusion/): + + + [#8759](https://svn.boost.org/trac/boost/ticket/8759) specialization of `convert\_impl` + for `map\_tag` +* [Geometry](/libs/geometry/index.html): + + + *Additional functionality* + + - Added centroid for segment type + - Added intersects() and disjoints() for Segment-Box and Linestring-Box + - Added rtree creation using packing algorithm + - Added contains() and covers() spatial query predicates + - Added iterative queries + + *Bugfixes* + + - In some cases .back() or .clear() was called, violating the + usage of Concepts. Fixed for the reported cases + + *Solved tickets* + + - [6958](https://svn.boost.org/trac/boost/ticket/6958) + Intersection generates self-intersection. Caused by spike, + fixed + - [8364](https://svn.boost.org/trac/boost/ticket/8364) + Invalid input exception, caused by spikes in previous steps, + fixed + - [8365](https://svn.boost.org/trac/boost/ticket/8365) + Invalid input exception, caused by spikes in previous steps, + fixed + - [8969](https://svn.boost.org/trac/boost/ticket/8969) + boost::geometry::model::point single argument constructor should + be explicit + - [8825](https://svn.boost.org/trac/boost/ticket/8825) + Patch adding member variable documentation to doxygen\_xml2qbk + - [8652](https://svn.boost.org/trac/boost/ticket/8652) + Intersection fails for triangle-triangle intersection. Caused + by spike, fixed + - [9047](https://svn.boost.org/trac/boost/ticket/9047) + Boost files that include themselves (strategies/intersection.hpp), + fixed +* [Graph](/libs/graph/index.html): + + + `void` is no longer allowed + as a bundled property type (for example, in the VertexProperties + template parameters to graph types); it did not work reliably before, + but a static assertion now forbids it entirely. Use `boost::no\_property` instead. + + Added support for `finish\_edge` + visitor event point in depth-first search; the change should be backward-compatible + with visitors that do not have that member function. + + Disabled building of tests on Sun compiler. + + Multiple source vertices are supported in non-named-parameter versions + of `breadth\_first\_visit`, + `breadth\_first\_search`, + `dijkstra\_shortest\_paths`, + and `dijkstra\_shortest\_paths\_no\_init`. + This feature is not yet documented; to use it, replace the single + parameter for the source vertex in each of these functions by two + input iterators of the same type containing the source vertices to + use. + + Added Hawick circuits algorithm; contributed by Louis Dionne. + + Added edge coloring algorithm; contributed by Maciej Piechotka. + + Added min-cost max-flow algorithm; contributed by Piotr Wygocki. + + Bugs and feature requests from Trac fixed: [#5269](https://svn.boost.org/trac/boost/ticket/5269), [#8317](https://svn.boost.org/trac/boost/ticket/8317), + [#8433](https://svn.boost.org/trac/boost/ticket/8433), [#8791](https://svn.boost.org/trac/boost/ticket/8791), [#8877](https://svn.boost.org/trac/boost/ticket/8877), [#8986](https://svn.boost.org/trac/boost/ticket/8986), [#9012](https://svn.boost.org/trac/boost/ticket/9012), [#9080](https://svn.boost.org/trac/boost/ticket/9080). +* [Hash](/libs/functional/hash/): + + + Simplify a SFINAE check so that it will hopefully work on Sun 5.9 + ([#8822](https://svn.boost.org/trac/boost/ticket/8822)). + + Suppress Visual C++ infinite loop warning ([#8568](https://svn.boost.org/trac/boost/ticket/8568)). +* [Interprocess](/libs/interprocess/): + + + Fixed bugs [#7156](https://svn.boost.org/trac/boost/ticket/7156), + [#7164](https://svn.boost.org/trac/boost/ticket/7164), + [#8277](https://svn.boost.org/trac/boost/ticket/8277), + [#8976](https://svn.boost.org/trac/boost/ticket/8976), + [#9065](https://svn.boost.org/trac/boost/ticket/9065), + [#9073](https://svn.boost.org/trac/boost/ticket/9073), + [#9008](https://svn.boost.org/trac/boost/ticket/9008). +* [Intrusive](/libs/intrusive/): + + + **Source breaking**: Deprecated `xxx\_dont\_splay` functions from splay + containers. Deprecated `splay\_set\_hook` + from splay containers, use `bs\_set\_hook` + instead. Both will be removed in Boost 1.56. + + **ABI breaking**: Hash containers' end + iterator was implemented pointing to one-past the end of the bucket + array (see [#8698](https://svn.boost.org/trac/boost/ticket/8698)) + causing severe bugs when values to be inserted where allocated next + to the bucket array. End iterator implementation was changed to point + to the beginning of the bucket array. + + Big refactoring in order to reduce template and debug symbol bloat. + Test object files have been slashed to half in MSVC compilers in + Debug mode. Toolchains without Identical COMDAT Folding (ICF) should + notice size improvements. + + Implemented SCARY iterators. +* [Lexical cast](/libs/conversion/lexical_cast.htm): + + + `std::bad\_alloc` exceptions are now are + not converted to `boost::bad\_lexical\_cast` + [#8966](https://svn.boost.org/trac/boost/ticket/8966). + + Added static assert that checks for `std::numeric\_limits` + specializations if they are required for conversion. Use `BOOST\_HAS\_INT128` for detecting + 128 bit integers support [#8790](https://svn.boost.org/trac/boost/ticket/8790). + + Documentation improved and more usage examples added. +* [Log](/libs/log/): + + + General changes: + + - Added a new configuration macro `BOOST\_LOG\_WITHOUT\_DEFAULT\_FACTORIES`. + By defining this macro the user can disable compilation of + the default filter and formatter factories used by settings + parsers. This can substantially reduce binary sizes while still + retaining support for settings parsers. + - Rewritten some of the parsers to reduce the compiled binary + size. The rewritten parsers are more robust in detecting ambiguous + and incorrect input. + - The following headers are deprecated: `boost/log/utility/intrusive\_ref\_counter.hpp`, + `boost/log/utility/explicit\_operator\_bool.hpp`, `boost/log/utility/empty\_deleter.hpp`. + These headers will be removed in future releases. The contents + of these headers were moved to other libraries. + + Bug fixes: + + - Fixed `timer` + attribute generating incorrect time readings on Windows on + heavy thread contention when `QueryPerformanceCounter` + API was used. + - Fixed a bug in the filter parser that prevented using parsed + filters with some attributes. + - Fixed thread id formatting discrepancies between the default + sink and formatters. + - Closed tickets: [#8815](https://svn.boost.org/trac/boost/ticket/8815), [#8819](https://svn.boost.org/trac/boost/ticket/8819), [#8915](https://svn.boost.org/trac/boost/ticket/8915), [#8917](https://svn.boost.org/trac/boost/ticket/8917), + [#9139](https://svn.boost.org/trac/boost/ticket/9139), [#9140](https://svn.boost.org/trac/boost/ticket/9140), [#9153](https://svn.boost.org/trac/boost/ticket/9153), [#9155](https://svn.boost.org/trac/boost/ticket/9155). + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Math](/libs/math/): + + + Suppress numerous warnings (mostly from GCC-4.8 and MSVC) [#8384](https://svn.boost.org/trac/boost/ticket/8384), + [#8855](https://svn.boost.org/trac/boost/ticket/8855), + [#9107](https://svn.boost.org/trac/boost/ticket/9107), + [#9109](https://svn.boost.org/trac/boost/ticket/9109).. + + Fixed PGI compilation issue [#8333](https://svn.boost.org/trac/boost/ticket/8333). + + Fixed PGI constant value initialization issue that caused erf to + generate incorrect results [#8621](https://svn.boost.org/trac/boost/ticket/8621). + + Prevent macro expansion of some C99 macros that are also C++ functions + [#8732](https://svn.boost.org/trac/boost/ticket/8732) + and [#8733](https://svn.boost.org/trac/boost/ticket/8733).. + + Fixed Student's T distribution to behave correctly with huge degrees + of freedom (larger than the largest representable integer) [#8837](https://svn.boost.org/trac/boost/ticket/8837). + + Make some core functions usable with `long + double` even when the platform + has no standard library `long + double` support [#8940](https://svn.boost.org/trac/boost/ticket/8940). + + Fix error handling of distributions to catch invalid scale and location + parameters when the random variable is infinite [#9042](https://svn.boost.org/trac/boost/ticket/9042) + and [#9126](https://svn.boost.org/trac/boost/ticket/9126). + + Add workaround for broken in Intel C++ 14 [#9087](https://svn.boost.org/trac/boost/ticket/9087). + + Improve consistency of argument reduction in the elliptic integrals + [#9104](https://svn.boost.org/trac/boost/ticket/9104). + + Fix bug in inverse incomplete beta that results in cancellation errors + when the beta function is really an arcsine or Student's T distribution. + + Fix issue in Bessel I and K function continued fractions that causes + spurious over/underflow. + + Add improvement to non-central chi squared distribution quantile + due to Thomas Luu. +* [Move](/libs/move/): + + + Fixed bugs [#7952](https://svn.boost.org/trac/boost/ticket/7952), + [#8764](https://svn.boost.org/trac/boost/ticket/8764), + [#8765](https://svn.boost.org/trac/boost/ticket/8765), + [#8842](https://svn.boost.org/trac/boost/ticket/8842), + [#8979](https://svn.boost.org/trac/boost/ticket/8979). +* [Meta State Machine](/libs/msm/): + + + New feature: interrupt states now support a sequence of events to + end the interruption. + + Fixed Trac [#8686](https://svn.boost.org/trac/boost/ticket/8686). +* [Multiprecision](/libs/multiprecision/): + + + Added support for Boost.Serialization. + + Suppressed some GCC warnings. See [8872](https://svn.boost.org/trac/boost/ticket/8872). + + Fixed bug in pow for large integer arguments. See [8809](https://svn.boost.org/trac/boost/ticket/8809). + + Fixed bug in pow for calculation of 0[super N]. See [8798](https://svn.boost.org/trac/boost/ticket/8798). + + Fixed bug in fixed precision cpp\_int IO code that causes conversion + to string to fail when the bit count is very small (less than CHAR\_BIT). + See [8745](https://svn.boost.org/trac/boost/ticket/8745). + + Fixed bug in cpp\_int that causes left shift to fail when a fixed + precision type would overflow. See [8741](https://svn.boost.org/trac/boost/ticket/8741). + + Fixed some cosmetic warnings from cpp\_int. See [8748](https://svn.boost.org/trac/boost/ticket/8748). + + Fixed calls to functions which are required to be macros in C99. + See [8732](https://svn.boost.org/trac/boost/ticket/8732). + + Fixed bug that causes construction from INT\_MIN, LONG\_MIN etc to + fail in cpp\_int. See [8711](https://svn.boost.org/trac/boost/ticket/8711). +* [Multi-index Containers](/libs/multi_index/index.html): + + + Boost.MultiIndex has been brought to a higher level of compliance + with C++11. + + - `multi\_index\_container` + is now efficiently movable. + - Initializer lists supported. + - Emplace functions provided. + - Non-copyable elements (such as `std::unique\_ptr`) supported. This includes + insertion of a range [`first`,`last`) where the iterators point + to a type that is convertible to that of the element: no copy + construction happens in the process. + - Random access indices provide `shrink\_to\_fit()`. + Refer to the [compiler + specifics](/libs/multi_index/doc/compiler_specifics.html) section for limitations on pre-C++11 compilers. + + The following classes are deprecated: + + - [`member\_offset`](/libs/multi_index/doc/reference/key_extraction.html#member_offset), + - [`const\_mem\_fun\_explicit`](/libs/multi_index/doc/reference/key_extraction.html#const_mem_fun_explicit), + - [`mem\_fun\_explicit`](/libs/multi_index/doc/reference/key_extraction.html#const_mem_fun_explicit), + - [`composite\_key\_result\_equal\_to`](/libs/multi_index/doc/reference/key_extraction.html#composite_key_result_equal_to), + - [`composite\_key\_result\_less`](/libs/multi_index/doc/reference/key_extraction.html#composite_key_result_less), + - [`composite\_key\_result\_greater`](/libs/multi_index/doc/reference/key_extraction.html#composite_key_result_greater), + - [`composite\_key\_result\_hash`](/libs/multi_index/doc/reference/key_extraction.html#composite_key_result_hash). + + Maintenance fixes. +* [MPI](/libs/mpi/): + + + Replaced calls to deprecated MPI functions + + Added support for multi-threaded initialization + + Added in-place collectives +* [Phoenix](/libs/phoenix/): + + + [#9049](https://svn.boost.org/trac/boost/ticket/9049) `phoenix::function` + constructor is constexpr. +* [Polygon](/libs/polygon/): + + + Updated CGAL part of the Voronoi benchmark with patches from Sebastien + Loriot. Updated documentation. + + Added polygon decomposition capability to polygon\_90\_set\_data container + (patch from Intel). Updated documentation. + + Bugs fixed from Trac: [#8197](https://svn.boost.org/trac/boost/ticket/8197). +* [PropertyMap](/libs/property_map/index.html): + + + dynamic\_properties objects can now be built by non-destructively + chaining `.property(name, pm)` calls. Example: + + + ``` + boost::dynamic\_properties() + .property("color", color\_map) + .property("pos", position\_map) + + ``` + + The use of raw pointers as property maps is deprecated; it often + failed on Visual Studio in the past. This usage has been removed + from all tests and examples in Boost.Graph. The replacement to use + for vertex properties in graphs (the most common use for this feature) + is: + + + ``` + boost::make\_iterator\_property\_map( + , + get(boost::vertex\_index, )) + + ``` + + + (Note: the lack of namespace qualification on get() in this code + is necessary for generic code). Outside a graph context, the closest + equivalent is: + + + ``` + boost::make\_iterator\_property\_map( + , + boost::typed\_identity\_property\_map()) + + ``` + + + There are commented-out static assertions on lines 151 and 159 of + `` that can be un-commented to find + deprecated uses of pointers in user code. +* [Rational](/libs/rational): + + + Added `lowest` and + `max\_digits10`, members + of std::numeric\_limits added in C++11, to the unit-test code. Needed + since Boost.Test refers to one of them when compiled in C++11 mode. + + Changed initialization of some internal variables to something that + cannot be a narrowing conversion, which fixes issue [#5855](https://svn.boost.org/trac/boost/ticket/5855). Needed + since narrowing conversions are an error in C++11. +* [SmartPtr](/libs/smart_ptr/index.html): + + + Added `boost/smart\_ptr/intrusive\_ref\_counter.hpp` header, extracted from Boost.Log. + The header implements a mixin base class that adds support for `intrusive\_ptr` to user's classes. +* [Thread](/libs/thread/): + + + *New Features:* + + - [#8519](http://svn.boost.org/trac/boost/ticket/8519) + Synchro: Update class barrier with a completion function. + - [#8515](http://svn.boost.org/trac/boost/ticket/8515) + Async: Add `shared\_future::then`. + - [#8519](http://svn.boost.org/trac/boost/ticket/8519) + Synchro: Update class barrier with a completion function + - [#8615](http://svn.boost.org/trac/boost/ticket/8615) + Async: Replace make\_future/make\_shared\_future by make\_ready\_future. + - [#8627](http://svn.boost.org/trac/boost/ticket/8627) + Async: Add future<>::unwrap and unwrapping constructor. + - [#8677](http://svn.boost.org/trac/boost/ticket/8677) + Async: Add future<>::get\_or. + - [#8678](http://svn.boost.org/trac/boost/ticket/8678) + Async: Add future<>::fallback\_to. + - [#8891](http://svn.boost.org/trac/boost/ticket/8891) + upgrade\_to\_unique\_lock: missing mutex() function. + - [#8955](http://svn.boost.org/trac/boost/ticket/8955) + Request for more efficient way to get exception\_ptr from future. + + *Fixed Bugs:* + + - [#7461](http://svn.boost.org/trac/boost/ticket/7461) + detail::win32::ReleaseSemaphore may be called with count\_to\_release + equal to 0 + - [#8070](http://svn.boost.org/trac/boost/ticket/8070) + prefer GetTickCount64 over GetTickCount + - [#8768](http://svn.boost.org/trac/boost/ticket/8768) + win32 condition\_variable::wait\_until infinite wait in rare + cases. + - [#8817](http://svn.boost.org/trac/boost/ticket/8817) + Boost Thread Windows CE \_createthreadex handling breaks mingw + w64. + - [#8943](http://svn.boost.org/trac/boost/ticket/8943) + Failed to compile code using boost::call\_once with Intel C++ + Composer XE 2013 on Windows. + - [#8931](http://svn.boost.org/trac/boost/ticket/8931) + Typos in external\_locking reference. + - [#9029](http://svn.boost.org/trac/boost/ticket/9029) + Misprint in documentation. + - [#9037](http://svn.boost.org/trac/boost/ticket/9037) + gcc -Wshadow gives warnings in condition\_variable{,\_fwd}.hpp. + - [#9041](http://svn.boost.org/trac/boost/ticket/9041) + Boost.Thread DSO's may need to link with Boost.Atomic. + - [#9048](http://svn.boost.org/trac/boost/ticket/9048) + boost::scoped\_thread useless ctor with variadic template arguments. + - [#9079](http://svn.boost.org/trac/boost/ticket/9079) + Condition variable will wait forever for some timepoint values + (Win). +* [Timer](/libs/timer/): + + + Fixed compilation on Intel compiler [#8956](https://svn.boost.org/trac/boost/ticket/8956). +* [Type Traits](/libs/type_traits/): + + + Added `is\_copy\_contructible` + trait [#8802](https://svn.boost.org/trac/boost/ticket/8802). +* [Unordered](/libs/unordered/): + + + Avoid some warnings ([#8851](https://svn.boost.org/trac/boost/ticket/8851), [#8874](https://svn.boost.org/trac/boost/ticket/8874)). + + Avoid exposing some detail functions via. ADL on the iterators. + + Work around variadic parameter bug in Visual Studio 2013. The compiler + still has problems with initializer lists, but it might not be possible + to work around those. +* [Utility](/libs/utility/index.html): + + + `boost::result\_of` can be set to use TR1 + protocol by default and fall back to `decltype` + if the function object does not support it (like C++11 lambda functions, + for example). Define `BOOST\_RESULT\_OF\_USE\_TR1\_WITH\_DECLTYPE\_FALLBACK` + configuration macro to enable this mode. + + Improved support for C++11 in the `boost::base\_from\_member` + class template. The class implements perfect forwarding for the constructor + arguments, if the compiler supports rvalue references, variadic templates + and function template default arguments. + + Added `boost/utility/explicit\_operator\_bool.hpp` and `boost/utility/empty\_deleter.hpp` + headers, which were extracted from Boost.Log. The headers implement + utilities for defining explicit conversion operators to `bool` and a deleter function object + that does nothing, respectively. +* [Variant](/libs/variant/): + + + Fixed compilation of constructor and assignment operator with const + rvalues input parameters [#8988](https://svn.boost.org/trac/boost/ticket/8988). + + Fixed compilation of move assignment operator for situations when + one of the variant template classes has nothrow copy constructor + and throwing move constructor [#8772](https://svn.boost.org/trac/boost/ticket/8772). + + Fix compilation on exception-disabled environments [#8717](https://svn.boost.org/trac/boost/ticket/8717). + + Fix unreachable code warnings [#8665](https://svn.boost.org/trac/boost/ticket/8665). + + Removed duplicate code [#7601](https://svn.boost.org/trac/boost/ticket/7601). +* [Wave](/libs/wave/): + + + See the [Changelog](/libs/wave/ChangeLog) for details. +* [xpressive](/libs/xpressive): + + + [#8843](https://svn.boost.org/trac/boost/ticket/8843) throw instead of assert at incomplete charset + + [#8880](https://svn.boost.org/trac/boost/ticket/8880) remove unused local typedef + + [#8882](https://svn.boost.org/trac/boost/ticket/8882) use RAII instead of try/catch in sequence\_stack.hpp + + [#8474](https://svn.boost.org/trac/boost/ticket/8474) make xpressive play nice with clang's -Wimplicit-fallthrough + diagnostic + +### Updated Tools + + +* [Quickbook](/tools/quickbook): + + + Quickbook 1.6 finalized, see the [Quickbook + documentation for details](/doc/html/quickbook/versions.html#language_versions.1_6). + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.3, 3.2, 3.1, 3.0 + + Clang, C++11, libc++: 3.4, 3.3 + + GCC: 4.8.1, 4.7.3, 4.6.3, 4.5.3, 4.4.7 + + GCC, C++11: 4.8.1 + + GCC, C++98: 4.8.1 +* OS X: + + + GCC: 4.2 + + Apple Clang: 5.0 + + Apple Clang, C++11: 5.0 +* Windows: + + + GCC, mingw: 4.8.0, 4.7.2, 4.6.3, 4.5.4, 4.4.7 + + Visual C++: 11.0, 10.0, 9.0 + Boost's additional test compilers include: + + + +* OS X: + + + Apple Clang: 5.0 + + Apple Clang, C++11: 5.0 + + Clang: trunk + + Clang, C++11: trunk + + GCC: 4.2.1 +* Linux: + + + Clang: 3.3, 3.2, 3.1, 3.0, trunk + + Clang, C++11: 3.4 + + Clang, C++11, libc++: 3.4, 3.3 + + GCC: 4.9.0 (experimental), 4.8.1, 4.7.3, 4.6.4, 4.5.3, 4.4.7 + + GCC, C++11: 4.8.1 + + GCC, C++98: 4.8.1 + + Intel: 13.0.1, 12.1.6 +* Windows: + + + GCC, mingw: 4.8.0, 4.7.2, 4.6.3, 4.5.4, 4.4.7 + + Visual C++: 11.0, 10.0, 9.0 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_56_0.html b/users/history/version_1_56_0.html new file mode 100644 index 0000000..7829f96 --- /dev/null +++ b/users/history/version_1_56_0.html @@ -0,0 +1,940 @@ +--- +title: Version 1.56.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.56.0 + +/\*\*/ + + + + + + + +Version 1.56.0 +============== + +Version 1.56.0 +-------------- + + +August 7th, 2014 16:08 GMT + + +[Documentation](/doc/libs/1_56_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_56\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.56.0/boost_1_56_0.tar.bz2) | +| [boost\_1\_56\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.56.0/boost_1_56_0.tar.gz) | +| windows | [boost\_1\_56\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.56.0/boost_1_56_0.7z) | +| [boost\_1\_56\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.56.0/boost_1_56_0.zip) | + + +### Other Downloads + + +* [Windows + binaries](https://sourceforge.net/projects/boost/files/boost-binaries/1.56.0/) + +### Modularization + Boost version control has migrated to a system using git submodules. This shouldn't + make too much of a difference to users, although the directory structure is + now a bit different. + + Parts of some libraries have been moved into different modules, and several + new modules have been extracted from existing code. All header paths should + remain the same. The new modules are: + + + +* [Assert](/libs/assert/): + Customizable assert macros. + Maintained by Peter Dimov. +* [Core](/libs/core/): + Core utilities used by other + libraries, with minimal dependencies. Maintained by Peter Dimov, Glen Fernandes + and Andrey Semashev. +* [Lexical\_Cast](/libs/lexical_cast/): + General literal + text conversions, such as an int represented a string, or vice-versa, from + Kevlin Henney. +* [Throw\_Exception](/libs/throw_exception/): + A common + infrastructure for throwing exceptions from Boost libraries, from Emil + Dotchevski. +* Winapi: + Windows API declarations without , for internal + Boost use. + +### New Libraries + + +* [Align](/libs/align/): + Memory alignment functions, + allocators, and adaptors, from Glen Fernandes. +* [Type\_Index](/libs/type_index/): + Runtime/Compile + time copyable type info, from Antony Polukhin. + +### Updated Libraries + + +* [Acumulators](/libs/accumulators/): + + + New accumulators `rolling\_variance` + and `rolling\_moment` +* [Any](/libs/any/): + + + Fixed rvalue references related issues ([#9215](https://svn.boost.org/trac/boost/ticket/9215), [#9462](https://svn.boost.org/trac/boost/ticket/9462)). + + Dropped support of antique compilers. +* [Asio](/libs/asio/): + + + Fixed `asio::spawn()` + to work correctly with new Boost.Coroutine interface ([#9442](https://svn.boost.org/trac/boost/ticket/9442), + [#9928](https://svn.boost.org/trac/boost/ticket/9928)). + + Ensured that incomplete `asio::spawn()` coroutines are correctly unwound + when cleaned up by the `io\_service` + destructor ([#9731](https://svn.boost.org/trac/boost/ticket/9731)). + + Fixed delegation of continuation hook for handlers produced by `io\_service::wrap()` + and `strand::wrap()` + ([#9741](https://svn.boost.org/trac/boost/ticket/9741)). + + Changed the Windows I/O completion port backend to use `ConnectEx`, if available, for connection-oriented + IP sockets. + + Changed the `io\_service` + backend for non-Windows (and non-IOCP Windows) platforms to use a + single condition variable per `io\_service` + instance. This addresses a potential race condition when `run\_one()` + is used from multiple threads. + + Prevented integer overflow when computing timeouts based on some + `boost::chrono` and `std::chrono` + clocks ([#9662](https://svn.boost.org/trac/boost/ticket/9662), [#9778](https://svn.boost.org/trac/boost/ticket/9778)). + + Made further changes to `EV\_CLEAR` + handling in the kqueue backend, to address other cases where the + `close()` + system call may hang on Mac OS X. + + Fixed infinite recursion in implementation of `resolver\_query\_base::flags::operator~` ([#9548](https://svn.boost.org/trac/boost/ticket/9548)). + + Made the `select` reactor + more efficient on Windows for large numbers of sockets ([#9528](https://svn.boost.org/trac/boost/ticket/9528)). + + Fixed a Windows-specific type-aliasing issue reported by gcc + ([#9550](https://svn.boost.org/trac/boost/ticket/9550)). + + Prevented execution of compile-time-only buffer test to avoid triggering + an address sanitiser warning ([#8295](https://svn.boost.org/trac/boost/ticket/8295)). + + Disabled the `GetQueuedCompletionStatus` + timeout workaround on recent versions of Windows. + + Added support for string-based scope IDs when using link-local multicast + addresses. + + Changed IPv6 multicast group join to use the address's scope ID as + the interface, if an interface is not explicitly specified. + + Fixed multicast test failure on Mac OS X and the BSDs by using a + link-local multicast address. + + Worked around a gcc problem to do with anonymous + enums ([#10042](https://svn.boost.org/trac/boost/ticket/10042)). + + Reverted the Windows `HANDLE` + backend change to ignore `ERROR\_MORE\_DATA`. + Instead, the error will be propagated as with any other (i.e. in + an `error\_code` or + thrown as a `system\_error`), + and the number of bytes transferred will be returned. For code that + needs to handle partial messages, the `error\_code` + overload should be used ([#10034](https://svn.boost.org/trac/boost/ticket/10034)). + + Fixed an off-by-one error in the `signal\_set` + implementation's signal number check ([#9324](https://svn.boost.org/trac/boost/ticket/9324)). + + Changed to use SSE2 intrinsics rather than inline assembly, to allow + the Cray compiler to work. + + Stopped using certain Winsock functions that are marked as deprecated + in the latest Visual C++ and Windows SDK. + + Added a workaround for building the unit tests with gcc + on AIX. + + Various minor documentation improvements ([#8295](https://svn.boost.org/trac/boost/ticket/8295), [#9605](https://svn.boost.org/trac/boost/ticket/9605), [#9771](https://svn.boost.org/trac/boost/ticket/9771)). +* [Assign](/libs/assign/): + + + Resolve some C++11 ambiguities ([#3073](https://svn.boost.org/trac/boost/ticket/3073)). +* [Atomic](/libs/atomic/): + + + The library has been redesigned. Besides internal refactoring, various + bugs were fixed, including incorrect values of feature test macros + and integer overflow handling. + + Changed values of the `memory\_order` + enumeration. The concrete values are not part of the interface, but + this change may potentially break ABI, if the enum is used in user's + interfaces. + + Implemented support for 128-bit atomic operations on Windows x64 + with MSVC. The library assumes presence of the `cmpxchg16b` + instruction in the target CPUs. Some early AMD CPUs don't support + this instruction. To target those define the `BOOST\_ATOMIC\_NO\_CMPXCHG16B` + macro. + + Implemented experimental support for Windows ARM target with MSVC. + + Implemented experimental support for DEC Alpha target with GCC. + + Improved support for ARMv6 and later with GCC. Implemented all atomic + operations as assembler blocks instead of CAS-based loops. 64-bit + operations are supported with ARMv7. + + Implemented optional support for the `BOOST\_ATOMIC\_FLAG\_INIT` + macro and static initialization of `atomic\_flag`. + ([#8158](https://svn.boost.org/trac/boost/ticket/8158)) + + Fixed compilation for SPARCv9 target. ([#9446](https://svn.boost.org/trac/boost/ticket/9446)) + + Fixed compilation for PowerPC target. ([#9447](https://svn.boost.org/trac/boost/ticket/9447)) + + Fixed several compatibility problems with Clang on x86 and x86-64. + ([#9610](https://svn.boost.org/trac/boost/ticket/9610), [#9842](https://svn.boost.org/trac/boost/ticket/9842)) + + Removed specialized code for Windows on IA64 platform. +* [Circular Buffer](/libs/circular_buffer/): + + + [#9970](https://svn.boost.org/trac/boost/ticket/9970),[#9334](https://svn.boost.org/trac/boost/ticket/9334) Support for the C++11 allocator model. + + Dropped support of antique compilers. +* [Concept Check](/libs/concept_check/): + + + Fewer warnings (includes [#5012](https://svn.boost.org/trac/boost/ticket/5012)). +* [Container](/libs/container/): + + + Added DlMalloc-based Extended Allocators. + + Improved configurability of tree-based ordered associative containers. + AVL, Scapegoat and Splay trees are now available to implement `set`, `multiset`, + `map` and `multimap`. + + Fixed bugs: + + - [#9338: + *"VS2005 compiler errors in swap() definition + after including container/memory\_util.hpp"*](https://svn.boost.org/trac/boost/ticket/9338). + - [#9637: + *"Boost.Container vector::resize() performance + issue"*](https://svn.boost.org/trac/boost/ticket/9637). + - [#9648: + *"string construction optimization - char\_traits::copy + could be used ..."*](https://svn.boost.org/trac/boost/ticket/9648). + - [#9801: + *"I can no longer create and iterator\_range from + a stable\_vector"*](https://svn.boost.org/trac/boost/ticket/9801). + - [#9915: + *"Documentation issues regarding vector constructors + and resize methods - value/default initialization"*](https://svn.boost.org/trac/boost/ticket/9915). + - [#9916: + *"Allocator propagation incorrect in the assignment + operator of most"*](https://svn.boost.org/trac/boost/ticket/9916). + - [#9931: + *"flat\_map::insert(ordered\_unique\_range\_t...) + fails with move\_iterators"*](https://svn.boost.org/trac/boost/ticket/9931). + - [#9955: + *"Using memcpy with overlapped buffers in vector"*](https://svn.boost.org/trac/boost/ticket/9955). +* [Context](/libs/context/): + + + fcontext\_t is opaque pointer to context-data + + changed signature of make\_fcontext() + + [#8826](https://svn.boost.org/trac/boost/ticket/8826) no executable stack + + [#9437](https://svn.boost.org/trac/boost/ticket/9437) catch exceptions on iOS and Windows Phone 8 + + [#9445](https://svn.boost.org/trac/boost/ticket/9445) support for x32 ABIs + + [#9522](https://svn.boost.org/trac/boost/ticket/9522) support for powerpc\_64le + + [#9743](https://svn.boost.org/trac/boost/ticket/9743) bugfix for powerpc\_64 le/be + + [#9774](https://svn.boost.org/trac/boost/ticket/9774) bugfix for x86 on Mac OS X + clang +* [Coroutine](/libs/coroutine/): + + + support of symmetric coroutines + + [#9355](https://svn.boost.org/trac/boost/ticket/9355) fix race condition in protected\_stack\_allocator + + [#9551](https://svn.boost.org/trac/boost/ticket/9551) list of supported architectures + + [#9734](https://svn.boost.org/trac/boost/ticket/9734) wrong check of mmap() return value + + [#9735](https://svn.boost.org/trac/boost/ticket/9735) no memset() for protected\_stack\_allocator + + [#9760](https://svn.boost.org/trac/boost/ticket/9760) coroutine iterator need const operator== + + [#10070](https://svn.boost.org/trac/boost/ticket/10070) mmap() return value + + [#10157](https://svn.boost.org/trac/boost/ticket/10157) file descriptor not required in protected\_stack\_allocator +* [Dynamic Bitset](/libs/dynamic_bitset/): + + + Support for C++11 move constructors + + Warning fixes on MSVC 2013 + + Support for C++11 minimal allocators + + Add noexcept specifications +* [Chrono](/libs/chrono/): + + + [#6918](http://svn.boost.org/trac/boost/ticket/6918) + Boost Chrono compilation failure on HP uX due to undefined pthread\_getcpuclockid + + [#8006](http://svn.boost.org/trac/boost/ticket/8006) + Boost::Chrono Assertion at startup - steady\_clock::now() - Windows + + [#9337](http://svn.boost.org/trac/boost/ticket/9337) + chrono::process\_cpu\_clock time points wrong by factor 1000 on Linux + + [#9342](http://svn.boost.org/trac/boost/ticket/9342) + Regression on process\_cpu\_clock::timepoint io on V2 + + [#9419](http://svn.boost.org/trac/boost/ticket/9419) + boost::chrono::floor()/round() and negative durations is wrong + + [#9698](http://svn.boost.org/trac/boost/ticket/9698) + boost::chrono::thread\_clock not declared in OSX + + [#9720](http://svn.boost.org/trac/boost/ticket/9720) + boost::this\_thread::sleep\_for() sometimes returns immediately on + win32 + + [#9859](http://svn.boost.org/trac/boost/ticket/9859) + Remove references to gcc-mingw + + [#9918](http://svn.boost.org/trac/boost/ticket/9918) + chrono compilation error on Solaris, funciton timegm + + [#9811](http://svn.boost.org/trac/boost/ticket/9811) + boost/boost/chrono/duration.hpp:355:56: error: call to non-constexpr + function 'static std::numeric\_limits::\_Ty std::numeric\_limits::max()' + /home/zosun/input\_service/inputservices-core-service/other/boost/boost/chrono/duration.hpp: + In static member function 'static constexpr double boost::chrono::detail::chrono\_numeric\_limits::lowest()': + + [#10069](http://svn.boost.org/trac/boost/ticket/10069) + Overflow in chrono clocks on 32bit + + [#10151](http://svn.boost.org/trac/boost/ticket/10151) + timegm function not available on QNX +* [Flyweight](/libs/flyweight/index.html): + + + In compilers with variadic template support, `boost::flyweight` now provides a perfectly forwarding + constructor to `T::T` + (previously an emulation was used). + + `flyweight` now replicates + the initializer-list constructors and assignment operators of its + underlying type. + + Fixed intermodule static initialization problem (ticket [#9553](https://svn.boost.org/trac/boost/ticket/9553)). + + Maintenance fixes. +* [Fusion](/libs/fusion/): + + + Fusion is enabled for use on GPU +* [Geometry](/libs/geometry/): + + + Additional functionality + + - New algorithm buffer for inflating/deflating geometries (buffer + itself already existed but that was only to enlarge a box) + - New algorithm remove\_spikes, algorithm to remove spikes from + a ring, polygon or multi\_polygon. + - New algorithm point\_on\_surface, generating a point lying on + the surface (interior) of the polygon + - New algorithm is\_simple, returning true if a geometry is simple + according to the OGC standard + - New algorithm is\_valid, returning true if a geometry is valid + according to the OGC standard + - New algorithm crosses for checking this spatial relation according + to the OGC standard + - The set operation algorithms (difference, intersection, sym\_difference + and union\_) now support as input pairs of pointlike or linear + geometries + - The distance and comparable\_distance algorithms now support + all pairs of geometry combinations + - The spatial relations which didn't support it (covered\_by, + touches, within, etc.) now support as input linear and/or areal + geometries + - The support for boost::variants as input geometries in various + algorithms + - The rtree support for indexing segments + - The rtree nearest() predicate support for arbitrary geometries + + Solved tickets + + - [8310](https://svn.boost.org/trac/boost/ticket/8310) + Wrong results with overlapping polygons (fixed using point\_on\_surface + for disjoint) + - [8375](https://svn.boost.org/trac/boost/ticket/8375) + sym\_difference of non-closed polygons returns closed polygon + - [8376](https://svn.boost.org/trac/boost/ticket/8376) + difference of non-closed polygons returns closed polygon + - [9081](https://svn.boost.org/trac/boost/ticket/9081) + Booleans create self-intersecting polygons from non-self-intersecting + polygons + - [9245](https://svn.boost.org/trac/boost/ticket/9245) + Check for process errors in make\_qbk.py + - [9563](https://svn.boost.org/trac/boost/ticket/9563) + (Sym)difference not successful, fixed by rescaling to robust + type + - [9628](https://svn.boost.org/trac/boost/ticket/9628) + Wrong result of within() due to the winding strategy not working + correctly for nearly-horizontal segments + - [9871](https://svn.boost.org/trac/boost/ticket/9871) + Remove spike in polygon with only a spike + - [9947](https://svn.boost.org/trac/boost/ticket/9947) + Missing info about WKT in documentation + - [9759](https://svn.boost.org/trac/boost/ticket/9759) + Invalid results of R-tree knn queries for non-cartesian coordinate + systems + - [10019](https://svn.boost.org/trac/boost/ticket/10019) + Difference of Linestring and Box returns their intersection + - [10077](https://svn.boost.org/trac/boost/ticket/10077) + Wrong types in concept checks in boost/geometry/arithmetic/arithmetic.hpp + + Bug fixes + + - intersects(polygon) could return a self-intersection-point + for its closing point, fixed + - equals() could return invalid results for non-simple linear + geometries according to the OGC standard, fixed + - touches() didn't work properly for CCW areal geomtries, fixed + - rtree nearest queries returned wrong elements for non-cartesian + coordinate systems, fixed + - rtree crashed in some cases when used with Interprocess allocator, + fixed +* [Hash](/libs/functional/hash/): + + + Removed some Visual C++ 6 workarounds. + + Ongoing work on improving `hash\_combine`, + this changes the previously documented algorithm for the function. +* [Interprocess](/libs/interprocess/): + + + Fixed bugs: + + - [Trac + #9221 (*"message\_queue deadlock on linux"*)](https://svn.boost.org/trac/boost/ticket/9221). + - [Trac + #9226 (*"On some computers, Common Appdata is + empty in registry, so boost interprocess cannot work"*)](https://svn.boost.org/trac/boost/ticket/9226). + - [Trac + #9284 (*"WaitForSingleObject(mutex) must handle + WAIT\_ABANDONED"*)](https://svn.boost.org/trac/boost/ticket/9284). + - [Trac + #9285 (*"CreateMutex returns NULL if fails"*)](https://svn.boost.org/trac/boost/ticket/9285). + - [Trac + #9288 (*"timed\_wait does not check if it has + expired"*)](https://svn.boost.org/trac/boost/ticket/9288). + - [Trac + #9408 (*"Android does not support XSI\_SHARED\_MEMORY\_OBJECTS"*](https://svn.boost.org/trac/boost/ticket/9408)). + - [Trac + #9729 (*"crash on managed\_external\_buffer object + construction"*](https://svn.boost.org/trac/boost/ticket/9729)). + - [Trac + #9767 (*"bootstamp generation causes error in + case of corrupt Windows Event Log"*)](https://svn.boost.org/trac/boost/ticket/9767). + - [Trac + #9835 (*"Boost Interprocess fails to compile + with Android NDK GCC 4.8, -Werror=unused-variable"*)](https://svn.boost.org/trac/boost/ticket/9835). + - [Trac + #9911 (*"get\_tmp\_base\_dir(...) failure"*)](https://svn.boost.org/trac/boost/ticket/9911). + - [Trac + #9946 (*"ret\_ptr uninitialized in init\_atomic\_func, + fini\_atomic\_func"*)](https://svn.boost.org/trac/boost/ticket/9946). + - [Trac + #10011 (*"segment\_manager::find( unique\_instance\_t\* + ) fails to compile"*)](https://svn.boost.org/trac/boost/ticket/10011). + - [Trac + #10021 (*"Interprocess and BOOST\_USE\_WINDOWS\_H"*)](https://svn.boost.org/trac/boost/ticket/10021). + - [GitHub + #2 (*"Provide support for the Cray C++ compiler. + The Cray compiler defines \_\_GNUC\_\_"*)](https://github.com/boostorg/interprocess/pull/2). + - [GitHub + #3 (*"Fix/mingw interprocess\_exception throw + in file\_wrapper::priv\_open\_or\_create"*)](https://github.com/boostorg/interprocess/pull/3). + + **ABI breaking**: [#9221](https://svn.boost.org/trac/boost/ticket/9221) + showed that `BOOST\_INTERPROCESS\_MSG\_QUEUE\_CIRCULAR\_INDEX` + option of message queue, was completely broken so an ABI break was + necessary to have a working implementation. + + Simplified, refactored and unified (timed\_)lock code based on try\_lock(). + There were several bugs when handling timeout expirations. + + Changed the implementation of condition variables' destructors to + allow POSIX semantics (the condition variable can be destroyed after + all waiting threads have been woken up).. + + Added `BOOST\_INTERPROCESS\_SHARED\_DIR\_PATH` + option to define the shared directory used to place shared memory + objects when implemented as memory mapped files. + + Added support for `BOOST\_USE\_WINDOWS\_H`. + When this macro is defined Interprocess does not declare used Windows + API function and types, includes all needed windows SDK headers and + uses types and functions declared by the Windows SDK. + + Added `get\_size` to + `windows\_shared\_memory`. +* [Intrusive](/libs/intrusive/): + + + Improved Doxygen generated reference and updated and fixed forward-declaration + header. + + **ABI breaking**: Fixed ABI regression + introduced in Boost 1.55 version, mainly noticeable on MSVC compilers. + + **Source breaking**: Removed previously + deprecated `xxx\_dont\_splay` + functions from splay containers, `splay\_set\_base\_hook` + and `splay\_set\_member\_hook`from + splay containers and `bool + splay = + true` extra parameter in `splaytree\_algorithms` functions. + + Fixed bugs: + + - [#8468: + Compile error on visual studio 2010/2012 using vector with + custom allocator and aligned types](https://svn.boost.org/trac/boost/ticket/8468) + - [#9332: + *"has\_member\_function\_callable\_with.hpp compile + error on msvc-12.0"*](https://svn.boost.org/trac/boost/ticket/9332). + - [#9650: + *"intrusive list with stateful value traits"*](https://svn.boost.org/trac/boost/ticket/9650). + - [#9746: + Modern Sun CC compiler detects error in intrusive library header](https://svn.boost.org/trac/boost/ticket/9746) + - [#9940: + bad bug in intrusive list with safe\_link (or auto\_unlink) hooks](https://svn.boost.org/trac/boost/ticket/9940) + - [#9948: + remove use of const\_cast in intrusive containers](https://svn.boost.org/trac/boost/ticket/9948) + - [#9949: + clear header node hooks upon intrusive container destruction](https://svn.boost.org/trac/boost/ticket/9949) + - [#9961: + tests for hooks not derived frorm generic\_hook](https://svn.boost.org/trac/boost/ticket/9961) + + Optimized tree rebalancing code to avoid redundant assignments. + + Added 64 bit prime values for `suggested\_upper\_bucket\_count`/`suggested\_lower\_bucket\_count` in + 64 bit platforms. + + Deleted workarounds for old SUN\_CC compilers, those are now unsupported + as modern SunPro compilers are standard-corforming enough. +* [Lexical Cast](/libs/lexical_cast/): + + + Added the `try\_lexical\_convert` + function, that retuns `false` + in case of failed conversion and does not require output parameter + to be Default Constructable ([#6700](https://svn.boost.org/trac/boost/ticket/6700)). + + Fixed conversion of string values with leading zeroes to `bool` ([#9659](https://svn.boost.org/trac/boost/ticket/9659)). + + Code was changed to produce a smaller binaries and simplify compiler's + work ([#9046](https://svn.boost.org/trac/boost/ticket/9046)). + + Boost.LexicalCast library was separated from the Boost.Conversion + library. + + Fixed some warnings ([#8991](https://svn.boost.org/trac/boost/ticket/8991)). +* [Log](/libs/log/index.html): + + + General changes: + + - For Windows targets, the library now compiles for Windows XP + by default. + - Added indexing operators with `attribute\_name` + arguments to `record` + and `record\_view`. + - Added operators for non-const object output to `basic\_formatting\_ostream`. + ([#9389](https://svn.boost.org/trac/boost/ticket/9389)) + - Added support for putting function names and source file names + of named scopes into the formatted strings. ([#9263](https://svn.boost.org/trac/boost/ticket/9263)) + - Added support for incomplete and empty markers to the named + scope formatter. ([#9123](https://svn.boost.org/trac/boost/ticket/9123)) + - The default presentation for incomplete named scope lists has + changed: trailing scope delimiter is omitted. + - Added a support header for `std::regex`. + - By default Boost.Log uses Boost.Regex internally as the regular + expressions backend. The backend can be changed by defining + configuration macros. + + Bug fixes: + + - Fixed `dump` + manipulator output on AVX2-enabled CPUs (e.g. Intel Haswell). + - Fixed compilation of `get\_attribute` + method of loggers. + - Fixed a possible race in `locked\_backend()` function implementation of + synchronous and asynchronous sink frontends. + - Fixed a possible infinite block of the logging threads in the + asynchronous sink enqueue methods when `block\_on\_overflow` + strategy was used. + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Math](/libs/math/index.html): + + + **Breaking change**: moved a number + of non-core headers that are predominantly used for internal maintenance + into `libs/math/include\_private`. The headers effected + are `boost/math/tools/test\_data.hpp`, `boost/math/tools/remez.hpp`, + `boost/math/constants/generate.hpp`, `boost/math/tools/solve.hpp`, + `boost/math/tools/test.hpp`. You can continue to use these + headers by adding `libs/math/include\_private` + to your compiler's include path. + + **Breaking change**: A number of distributions + and special functions were returning the maximum finite value rather + than raising an overflow\_error, this has now been fixed, which means + these functions now behave as documented. However, since the default + behavior on raising an overflow\_error is to throw a `std::overflow\_error` exception, applications + which have come to reply rely on these functions not throwing may + experience exceptions where they did not before. The special functions + involved are gamma\_p\_inva, gamma\_q\_inva, ibeta\_inva, ibetac\_inva, + ibeta\_invb, ibetac\_invb, gamma\_p\_inv, gamma\_q\_inv. The distributions + involved are pareto\_distrib, beta\_distrib, geometric\_distrib, negative\_binomial\_distrib, + binomial\_distrib, chi\_squared\_distrib, gamma\_distrib, inverse\_chi\_squared\_distrib, + inverse\_gamma\_distrib. See [#10111](https://svn.boost.org/trac/boost/ticket/10111). + + Fix round and trunc functions so they can be used with integer arguments, + see [#10066](https://svn.boost.org/trac/boost/ticket/10066). + + Fix Halley iteration to handle zero derivative (with non-zero second + derivative), see [#10046](https://svn.boost.org/trac/boost/ticket/10046). + + Fix Geometric distribution use of Policies, see [#9833](https://svn.boost.org/trac/boost/ticket/9833). + + Fix corner cases in the negative binomial distribution, see [#9834](https://svn.boost.org/trac/boost/ticket/9834). + + Fix compilation failures on Mac OS. + + Added bernoulli\_numbers, changed arbitrary precision tgamma/lgamma + to use Sterling's approximation (from Nikhar Agrawal). + + Added first derivatives of the Bessel functions: cyl\_bessel\_j\_prime, + cyl\_neumann\_prime, cyl\_bessel\_i\_prime, cyl\_bessel\_k\_prime, sph\_bessel\_prime + and sph\_neumann\_prime (from Anton Bikineev). + + Fixed buggy Student's t example code, along with docs for testing + sample means for equivalence. + + Documented `max\_iter` + parameter in root finding code better, see [#9225](https://svn.boost.org/trac/boost/ticket/9225). + + Add option to explicitly enable/disable use of \_\_float128 in constants + code, see [#9240](https://svn.boost.org/trac/boost/ticket/9240). + + Cleaned up handling of negative values in Bessel I0 and I1 code (removed + dead code), see [#9512](https://svn.boost.org/trac/boost/ticket/9512). + + Fixed handling of very small values passed to tgamma and lgamma so + they don't generate spurious overflows (thanks to Rocco Romeo). + + [#9672 PDF + and CDF of a Laplace distribution throwing domain\_error](https://svn.boost.org/trac/boost/ticket/9672) Random + variate can now be infinite. + + Fixed several corner cases in rising\_factorial, falling\_factorial + and tgamma\_delta\_ratio with thanks to Rocco Romeo. + + Removed constant `pow23\_four\_minus\_pi` whose value did not match the name (and was unused by Boost.Math), + see [#9712](https://svn.boost.org/trac/boost/ticket/9712). +* [Move](/libs/move/): + + + Added `BOOST_MOVE_RET`. + + Fixed bug [#9482: + *"MSVC macros not undefined in boost/move/detail/config\_end.hpp"*](https://svn.boost.org/trac/boost/ticket/9482), + [#9045: + *"Wrong macro name on docs"*](https://svn.boost.org/trac/boost/ticket/9045), + [#8420: + *"move's is\_convertible does not compile with aligned + data"*](https://svn.boost.org/trac/boost/ticket/8420). +* [MPL](/libs/mpl/): + + + `boost::mpl::for\_each` is enabled for use on + GPU +* [MultiArray](/libs/multi_array/index.html): + + + [#5664](https://svn.boost.org/trac/boost/ticket/5664) operator() checks for Collection concept but requires RandomAccessCollection + + [#4874](https://svn.boost.org/trac/boost/ticket/4874) compile errors using Visual C++ 2010 in debug mode + + [#3581](https://svn.boost.org/trac/boost/ticket/3581) MultiArray storage order example incorrect for fortran\_storage\_ordering + + [#4032](https://svn.boost.org/trac/boost/ticket/4032) Move MultiArray concepts out of detail namespace + + [#9212](https://svn.boost.org/trac/boost/ticket/9212) Broken links to C++ standard papers + + [#8368](https://svn.boost.org/trac/boost/ticket/8368) GCC -Wundef warning about BOOST\_MULTI\_ARRAY\_NO\_GENERATORS + in multi\_array +* [Multi-index Containers](/libs/multi_index/index.html): + + + The `erase(iterator)` + member function of hashed indices used to have poor performance under + low load conditions due to the requirement that an iterator to the + next element must be returned (see ticket [#4264](https://svn.boost.org/trac/boost/ticket/4264)). In accordance + with the resolution of [LWG + issue #579](http://lwg.github.io/issues/lwg-closed.html#579), this problem has been fixed while maintaining + the interface of `erase`, + at the expense of using one more word of memory per element. In fact, + C++ complexity requirements on unordered associative containers have + been improved for hashed indices so that + + - deletion of a given element is unconditionally constant-time, + - worst-case performance is not `O(n)` but `O(ndist)`, where `ndist` is the number of + non-equivalent elements in the index. + Due to the fact that hashed indices rely on a new data structure, + the internal representation of their iterators and local iterators + have changed, which affects serialization: their corresponding serialization + [class + version](/libs/serialization/doc/tutorial.html#versioning) has been bumped from 0 to 1. Old archives involving + hashed index (local) iterators can be loaded by Boost 1.56 version + of Boost.MultiIndex, but not the other way around. + + Hashed indices now provide `reserve`. + + Hashed indices can now be checked for equality and inequality following + the (suitably adapted) C++ standard specification in **[unord.req]**. + + The public interface of Boost.MultiIndex provide `noexcept` + specifications where appropriate (for compliant compilers). + + Improved performance of failed insertions into a `multi\_index\_container`. + + Much internal code aimed at supporting MSVC++ 7.0 and prior has been + removed. Compilation times without this legacy code might be slightly + faster. + + Fixed a bug with insertion via iterators dereferencing to rvalues + (ticket [#9665](https://svn.boost.org/trac/boost/ticket/9665)). + + Made Boost.MultiIndex compatible with `BOOST\_BIND\_NO\_PLACEHOLDERS` + (ticket [#9798](https://svn.boost.org/trac/boost/ticket/9798)). + + Maintenance fixes. +* [Multiprecision](/libs/multiprecision/): + + + Change floating point to rational conversions to be implicit, see + [10082](https://svn.boost.org/trac/boost/ticket/10082). + + Fix definition of checked\_cpp\_rational typedef. + + Fix bug in assignment from string in cpp\_int, see [9936](https://svn.boost.org/trac/boost/ticket/9936). + + Added new cpp\_bin\_float backend for binary floating point. + + Fix bug in assignment from string in cpp\_int, see [9936](https://svn.boost.org/trac/boost/ticket/9936). + + Added MSVC-specific #include for compiler intrinsics, see [9336](https://svn.boost.org/trac/boost/ticket/9336). + + Fixed various typos in docs, see [9432](https://svn.boost.org/trac/boost/ticket/9432). + + Fixed gmp\_rational to allow move-copy from an already copied-from + object, see [9497](https://svn.boost.org/trac/boost/ticket/9497). + + Added list of values for numeric\_limits. +* [Odeint](/libs/numeric/odeint/): + + + Added algebra and operations dispatcher for automatic detection of + appropriate algebras and operations. + + Added support for Eigen, Boost.Multiarray, Boost.Mpi, Boost.Compute, + Blaze, and NT2. + + Changed algebra interface to use algebra.norm\_inf function. + + Added iterators for iterating through the solution of the ODEs, hence + an alternative to the integrate functions. + + Added the Velocity-Verlet method. + + Minor bug fixes. +* [Optional](/libs/optional/): + + + Added support for rvalue references. Now `optional` works with moveable but non-copyable + `T`'s. + + Improved `swap` (now + uses move operations). + + Added function `emplace()`. This is the last of the requests + from [#1841](https://svn.boost.org/trac/boost/ticket/1841). + + `optional` is moveable, + including conditional `noexcept` + specifications, which make it `move\_if\_noexcept`-friendly. + + Using explicit operator bool() on platforms that support it ([#4227](https://svn.boost.org/trac/boost/ticket/4227)) + (breaking change). + + Forward declaration of `operator<<(ostream&, optional + const&)` + to prevent inadvertent incorrect serialization of optional objects. + + Removed depprecated function `reset()` from examples ([#9005](https://svn.boost.org/trac/boost/ticket/9005)). + + Equality comparison with `boost::none` + does not require that `T` + be EqualityComparable. + + Optional rvalue references are explicitly disallowed. + + Binding temporaries to optional references is explicitly disallowed + (breaking change). + + More ways to access the contained value, functions `value()`, + `value\_or()`, + `value\_or\_eval()`. + + Updated and reorganized documentation, added tutorial and quick guide + sections. +* [Predef](/libs/predef/): + + + Addition of `BOOST\_PLAT\_\*` platform definitions for MinGW and + Windows platform variants. + + Detection of ARM architecture for Windows compilers to target mobile + devices of Windows 8. + + Improved ARM detection for 64 bit ARM. + + Added detection of iOS as an operating system. + + Improved detection of endianess on some platforms. + + Addition of exclusive plus emulated definitions for platform and + compiler detection. +* [Preprocessor](/libs/preprocessor/): + + + When using variadic macros tuple functionality was added to match + all the array functionality. +* [Program Options](/libs/program_options/): + + + Columns in the `--help` + output are now aligned across all option groups ([#6114](https://svn.boost.org/trac/boost/ticket/6114)). + + Option names with dashes are no longer truncated in error messages + ([#8009](https://svn.boost.org/trac/boost/ticket/8009)). +* [Regex](/libs/regex/index.html): + + + **Breaking change:** corrected behavior + of `basic\_regex<>::mark\_count()` + to match existing documentation, `basic\_regex<>::subexpression(n)` changed to match, see [#9227](https://svn.boost.org/trac/boost/ticket/9227) + + Fixed issue [#8903](https://svn.boost.org/trac/boost/ticket/8903). + + Fixed documentation typos from [#9283](https://svn.boost.org/trac/boost/ticket/9283). + + Fixed bug in collation code that failed if the locale generated collation + strings with embedded nul's, see [#9451](https://svn.boost.org/trac/boost/ticket/9451). + + Apply patch for unusual thread usage (no statically initiallized + mutexes), see [#9461](https://svn.boost.org/trac/boost/ticket/9461). + + Added better checks for invalid UTF-8 sequences, see [#9473](https://svn.boost.org/trac/boost/ticket/9473). +* [Smart Pointers](/libs/smart_ptr/): + + + Updated the overloads of [make\_shared](/libs/smart_ptr/make_shared_array.html) + and [allocate\_shared](/libs/smart_ptr/make_shared_array.html) + of array types (`T[]` or `T[N]`) to conform to the specification + in C++ standard paper [N3939](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3939.html) + and significantly reduced the spatial overhead of the internal bookkeeping + structures. + + Updated the implementations of make\_shared and allocate\_shared for + scalar types and array types, respectively, to resolve C++ standard + library defect report [#2070](http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2070). +* [Thread](/libs/thread/): + + + *New Experimental Features:* + + - [#7446](http://svn.boost.org/trac/boost/ticket/7446) + Async: Add when\_any. + - [#7447](http://svn.boost.org/trac/boost/ticket/7447) + Async: Add when\_all. + - [#7448](http://svn.boost.org/trac/boost/ticket/7448) + Async: Add async taking a scheduler parameter. + - [#8274](http://svn.boost.org/trac/boost/ticket/8274) + Synchro: Add concurrent queue + - [#8513](http://svn.boost.org/trac/boost/ticket/8513) + Async: Add a basic thread\_pool executor. + - [#8518](http://svn.boost.org/trac/boost/ticket/8518) + Synchro: Add a latch class. + - [#8516](http://svn.boost.org/trac/boost/ticket/8516) + Async: Add future/shared\_future::then taking a scheduler as + parameter. + - [#9058](http://svn.boost.org/trac/boost/ticket/9058) + with\_lock\_guard function + - [#9571](http://svn.boost.org/trac/boost/ticket/9571) + Add a dynamic executor and an executor adaptor + + *Fixed Bugs:* + + - [#8070](http://svn.boost.org/trac/boost/ticket/8070) + prefer GetTickCount64 over GetTickCount + - [#9333](http://svn.boost.org/trac/boost/ticket/9333) + ex\_scoped\_thread compile fails on msvc-12.0 + - [#9341](http://svn.boost.org/trac/boost/ticket/9341) + compile error scoped\_thread(move semantics) intel-linux-14.0.1 + - [#9366](http://svn.boost.org/trac/boost/ticket/9366) + async(Executor, ...) fails to compile with msvc-10,11,12 + - [#9402](http://svn.boost.org/trac/boost/ticket/9402) + test\_excutor regression on msvc-10,11,12 + - [#9404](http://svn.boost.org/trac/boost/ticket/9404) + ex\_make\_future regression error + - [#9471](http://svn.boost.org/trac/boost/ticket/9471) + Synchronization documentation nits + - [#9535](http://svn.boost.org/trac/boost/ticket/9535) + Missing exception safety might result in crash + - [#9618](http://svn.boost.org/trac/boost/ticket/9618) + try\_join\_for problem: program is not terminate. + - [#9625](http://svn.boost.org/trac/boost/ticket/9625) + Please rewrite boost::thread::~thread() reference section + - [#9632](http://svn.boost.org/trac/boost/ticket/9632) + public method start\_thread in boost::thread class + - [#9673](http://svn.boost.org/trac/boost/ticket/9673) + thread compilation with MingW/gcc on Windows gives errors + - [#9708](http://svn.boost.org/trac/boost/ticket/9708) + boost::condition\_variable::timed\_wait unexpectedly wakes up + while should wait infinite + - [#9711](http://svn.boost.org/trac/boost/ticket/9711) + future continuation called twice + - [#9867](http://svn.boost.org/trac/boost/ticket/9867) + Remove references to gcc-mingw + - [#10008](http://svn.boost.org/trac/boost/ticket/10008) + Boost Synchronization documentation typos (futures) + - [#10058](http://svn.boost.org/trac/boost/ticket/10058) + Null pointer access in once + - [#10125](http://svn.boost.org/trac/boost/ticket/10125) + call\_once: compile errors in variadic version with rvalue reference + emulation + - [#10126](http://svn.boost.org/trac/boost/ticket/10126) + call\_once: deprecate (Function, once\_flag&) overload + - [#10147](http://svn.boost.org/trac/boost/ticket/10147) + pthread\_delay\_np() parameters different on AIX even with gcc + - [#10155](http://svn.boost.org/trac/boost/ticket/10155) + thread::physical\_concurrency() always returns 0 on PowerPC + - [#10184](http://svn.boost.org/trac/boost/ticket/10184) + Future: multiply defined symbols +* [TR1](/libs/tr1/index.html): + + + This library is now deprecated. +* [TTI](/libs/tti/): + + + Ticket [#9441](https://svn.boost.org/trac/boost/ticket/9441): Added better support for Sun Solaris Studio C++ + compiler. + + Ticket [#9444](https://svn.boost.org/trac/boost/ticket/9444): Handle all situations where the enclosing class + is not a class type. +* [Unordered](/libs/unordered/): + + + Minor documentation and warning fixes ([#9377](https://svn.boost.org/trac/boost/ticket/9377), [#9719](https://svn.boost.org/trac/boost/ticket/9719)). + + Always use prime number of buckets for integers. Fixes performance + regression when inserting consecutive integers ([#9282](https://svn.boost.org/trac/boost/ticket/9282)). + + Only construct elements using allocators, as specified in C++11 standard. +* [Utility](/libs/utility/index.html): + + + Some components were moved to the new Boost.Core library. + + `empty\_deleter` is + deprecated in favor of `null\_deleter` + from Boost.Core. `empty\_deleter` + is an alias for `null\_deleter`, + it will be removed in future releases. + + `base\_from\_member` + utility now supports lvalue reference member types. ([#7577](https://svn.boost.org/trac/boost/ticket/7577)) +* [UUID](/libs/uuid/index.html): + + + Added basic support for C++11 features. + + Implemented SSE-optimized versions of some functions of `uuid`, including comparison operators + and `swap`. The support + for different versions of SSE is automatically detected at compile + time for most compilers, but can also be explicitly enabled or disabled + with [configuration + macros](/libs/uuid/uuid.html#Configuration). ([#8509](https://svn.boost.org/trac/boost/ticket/8509)) + + Silenced some compiler warnings. ([#8495](https://svn.boost.org/trac/boost/ticket/8495), [#8697](https://svn.boost.org/trac/boost/ticket/8697)) +* [Variant](/libs/variant/): + + + **Breaking change:** Variant now uses + variadic templates if they are supported by compiler. This leads + to smaller binaries and better compilation times but in some cases + may break metaprogramming functions, especially if [BOOST\_VARIANT\_ENUM\_PARAMS](/libs/variant/doc/html/variant/BOOST_VARIANT_ENUM_PARAMS.html) + and [BOOST\_VARIANT\_ENUM\_SHIFTED\_PARAMS](/libs/variant/doc/html/variant/BOOST_VARIANT_ENUM_SHIFTED_PARAMS.html) + are not used. Usage of variadic templates [may + be disabled](/libs/variant/doc/html/variant/BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES.html). + + [Added](/libs/variant/doc/html/variant/reference.html#header.boost.variant.polymorphic_get_hpp) + `polymorphic\_get` function + [#9479](https://svn.boost.org/trac/boost/ticket/9479). + + Move-only classes now can be returned by visitors. + + Optimized variant::swap() and fixed ambiguity in `move\_swap` + [#2839](https://svn.boost.org/trac/boost/ticket/2839). + + Added conditional noexcepts to move assignments, default and move + constructors making `boost::variant` + `move\_if\_noexcept`-friendly + ([#7911](https://svn.boost.org/trac/boost/ticket/7911)). + + Exceptions are now visible across modules even with -fvisibility=hidden + flags. + + Dropped support of antique compilers. + + Fixed some warnings ([#3020](https://svn.boost.org/trac/boost/ticket/3020)). + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.4, 3.3, 3.2, 3.1, 3.0 + + Clang, C++98: 3.3.16 + + Clang, C++11, libc++: 3.4.2 + + Clang, C++1y: 3.3.16 + + GCC: 4.8.2, 4.8.1, 4.7.3, 4.6.4, 4.4.7 + + GCC, C++98: 4.9.0 + + GCC, C++11: 4.8.2 + + GCC, C++1y: 4.9.0 + + Intel: 13.1 +* OS X: + + + Apple Clang: 5.1 + + Apple Clang, C++11: 5.1 + + GCC: 4.2.1 + + Intel: 12.0 +* Windows: + + + GCC, mingw: 4.9.0, 4.8.2, 4.7.3, 4.7.2, 4.6.3, 4.5.4, 4.4.7 + + Visual C++: 12.0, 11.0, 10.0, 9.0 +* FreeBSD: + + + GCC: 4.2.1 +* QNX: + + + QCC: 4.4.2 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.4, 3.3, 3.2, 3.1, 3.0 + + Clang, C++98: 3.3.16 + + Clang, C++11, libc++: 3.4.2 + + Clang, C++1y: 3.3.16 + + Clang, C++14, libc++: trunk + + GCC: 4.8.2, 4.8.1, 4.7.3, 4.6.4, 4.4.7 + + GCC, C++98: 4.9.0 + + GCC, C++11: 4.9.0, 4.8.2 + + GCC, C++1y: 4.9.0 + + Intel: 13.1, 13.0, 12.1, 11.1 +* OS X: + + + Apple Clang: 5.1 + + Apple Clang, C++11: + + Clang: trunk + + Clang, C++11: trunk + + GCC: 4.2.1 + + Intel: 12.0 +* Windows: + + + GCC, mingw: 4.9.0, 4.8.2, 4.7.2, 4.6.3, 4.5.4, 4.4.7 + + Visual C++: 12.0, 11.0, 10.0, 9.0 +* FreeBSD: + + + GCC: 4.2.1 +* QNX: + + + QCC, ARM: 4.4.2 + + QCC, x86: 4.4.2 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_57_0.html b/users/history/version_1_57_0.html new file mode 100644 index 0000000..6257ade --- /dev/null +++ b/users/history/version_1_57_0.html @@ -0,0 +1,455 @@ +--- +title: Version 1.57.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.57.0 + +/\*\*/ + + + + + + + +Version 1.57.0 +============== + +Version 1.57.0 +-------------- + + +November 3rd, 2014 21:55 GMT + + +[Documentation](/doc/libs/1_57_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_57\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.57.0/boost_1_57_0.tar.bz2) | +| [boost\_1\_57\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.57.0/boost_1_57_0.tar.gz) | +| windows | [boost\_1\_57\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.57.0/boost_1_57_0.7z) | +| [boost\_1\_57\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.57.0/boost_1_57_0.zip) | + + +### Updated Libraries + + +* [Any](/libs/any/): + + + RTTI is not required any more ([TypeIndex](/libs/type_index) + library is used for RTTI emulation) + + Fixed [#8958](https://svn.boost.org/trac/boost/ticket/8958) +* [Asio](/libs/asio/): + + + Fixed the kqueue reactor so that it works on FreeBSD + ([#10606](https://svn.boost.org/trac/boost/ticket/10606)). + + Fixed an issue in the kqueue reactor which resulted + in spinning when using serial ports on Mac OS ([#10496](https://svn.boost.org/trac/boost/ticket/10496)). + + Fixed kqueue reactor support for read-only file + descriptors ([#10367](https://svn.boost.org/trac/boost/ticket/10367)). + + Fixed a compile error when using the /dev/poll + reactor ([#10350](https://svn.boost.org/trac/boost/ticket/10350), [#10572](https://svn.boost.org/trac/boost/ticket/10572)). + + Changed the Windows backend to use `WSASocketW`, + as `WSASocketA` has + been deprecated ([#10534](https://svn.boost.org/trac/boost/ticket/10534)). + + Fixed some warnings reported by Visual C++ 2013 ([#10376](https://svn.boost.org/trac/boost/ticket/10376)). + + Fixed integer type used in the WinRT version of the byte-order conversion + functions ([#10539](https://svn.boost.org/trac/boost/ticket/10539)). + + Changed documentation to indicate that `use\_future` + and `spawn()` + are not made available when including the `asio.hpp` + convenience header ([#10567](https://svn.boost.org/trac/boost/ticket/10567)). + + Explicitly marked `asio::strand` + as deprecated. Use `asio::io\_service::strand` + instead. +* [Circular Buffer](/libs/circular_buffer/): + + + Fixed some warnings and `move\_if\_noexcept` + from Boost.Move is used [#7888](https://svn.boost.org/trac/boost/ticket/7888) +* [Config](/libs/config/): + + + `BOOST\_HAS\_PRAGMA\_DETECT\_MISMATCH` + macro was added +* [Container](/libs/container/): + + + Added support for `initializer\_list`. + Contributed by Robert Matusewicz. + + Fixed double destruction bugs in vector and backward expansion capable + allocators. + + Fixed bugs: + + - [Trac + #10263 (*"AIX 6.1 bug with sched\_yield() function + out of scope"*)](https://svn.boost.org/trac/boost/ticket/10263). + - [GitHub + #16: *Fix iterators of incomplete type containers*](https://github.com/boostorg/container/pull/16). + Thanks to Mikael Persson. +* [Coroutine](/libs/coroutine/): + + + optionally register stacks with valgrind + + [#10386](https://svn.boost.org/trac/boost/ticket/10386) MSVC link error in asymmetric\_coroutine.hpp: symbol already + defined + + [#10536](https://svn.boost.org/trac/boost/ticket/10536) call to 'begin(...pull\_coroutine< R > & c)' + is ambiguous +* [Flyweight](/libs/flyweight/): + + + Added serialization support via [Boost + Serialization](/libs/serialization/). + + `flyweight` default + constructor was made explicit in Boost 1.56, which introduces a regression + in some initialization scenarios. The former non-explicit default + constructor has been restored (ticket [#10439](https://svn.boost.org/trac/boost/ticket/10439)). +* [Geometry](/libs/geometry/): + + + *Improvements* + + - The support of parameters convertible to value\_type in rtree + insert(), remove() and count() functions + + *Solved tickets* + + - [8402](https://svn.boost.org/trac/boost/ticket/8402) + Implicit conversion warnings + - [9354](https://svn.boost.org/trac/boost/ticket/9354) + Bug in winding strategy affecting within() and covered\_by() + for non-cartesian coordinate systems + - [10177](https://svn.boost.org/trac/boost/ticket/10177) + Missing include + - [10345](https://svn.boost.org/trac/boost/ticket/10345) + Distance fails to compile for some coordinate types + - [10398](https://svn.boost.org/trac/boost/ticket/10398) + Wrong neighbour check in buffer, calculating turns + - [10421](https://svn.boost.org/trac/boost/ticket/10421) + Invalid Point-Box distance for spherical CS + - [10615](https://svn.boost.org/trac/boost/ticket/10615) + Rtree constructor feature request + - [10643](https://svn.boost.org/trac/boost/ticket/10643) + Invalid point\_on\_surface() result for big coordinates + - [10668](https://svn.boost.org/trac/boost/ticket/10668) + Implicit conversion warnings (duplicated 8402) + + *Bugfixes* + + - Several fixes of bugs in algorithm buffer + - Bug in point\_on\_surface() for CCW Polygons (extreme\_points()) + and numerical issue (thanks to Matt Amos) + - Bug in disjoint() for A/A fixed by replacement of point\_on\_surface() + with point\_on\_border() (thanks to Matt Amos) + - The result of convex\_hull(), duplicated Point in open output, + too small number of Points for 1- and 2-Point input + - Imprecision for big coordinates in centroid(), fixed by Points + translation (related with ticket 10643) + - for\_each\_segment() not taking into account the last segment + of open Geometry +* [Interprocess](/libs/interprocess/): + + + Removed `unique\_ptr`, + now forwards boost::interprocess::unique\_ptr to the general purpose + `boost::movelib::unique\_ptr` class from **Boost.Move**. This implementation is closer + to the standard `std::unique\_ptr` + implementation and it's better maintained. + + Fixed bugs: + + - [Trac + #10262 (*"AIX 6.1 bug with variable definition + hz"*)](https://svn.boost.org/trac/boost/ticket/10262). + - [Trac + #10229 (*"Compiling errors in interprocess\detail\os\_file\_functions.hpp"*)](https://svn.boost.org/trac/boost/ticket/10229). + - [Trac + #10506 (*"Infinite loop in create\_or\_open\_file"*)](https://svn.boost.org/trac/boost/ticket/10506). + - [GitHub + Pull #11 (*"Compile fix for BOOST\_USE\_WINDOWS\_H"*)](https://github.com/boostorg/interprocess/pull/11). + + Reorganized Doxygen marks to obtain a better header reference. +* [Intrusive](/libs/intrusive/): + + + Experimental version of node checkers, contributed by Matei David. + Many thanks! + + Implemented [N3644: + Null Forward Iterators](http://www.open-std.org/JTC1/sc22/WG21/docs/papers/2013/n3644.pdf) from C++14. + + Fixed bugs: + + - [GitHub + Pull #12: *Fix MSVC14 warning C4456: declaration of + 'x\_parent\_right' hides previous local declaration*](https://github.com/boostorg/intrusive/pull/12) + - [Boost + Trac #10520: *Conversion warning in intrusive/detail/utilities.hpp*](https://svn.boost.org/trac/boost/ticket/10520) + - [Boost + Trac #10469: *Erasing from intrusive unordered\_multiset + with optimize\_multikey goes into an infinite loop*](https://svn.boost.org/trac/boost/ticket/10469) +* [Iterator](/libs/iterator/): + + + Most components of the library were moved into the `boost::iterators` namespace. For backward + compatibility the components are also accessible in the `boost` namespace. + + Iterator operators are now conditionally defined based on the iterator + category. + + Some of the internal components of the library were made public (`minimum\_category`, for example). +* [Lexical Cast](/libs/lexical_cast/): + + + Some internal changes, library now consist of multiple headers instead + of a single one [#10391](https://svn.boost.org/trac/boost/ticket/10391), [#10173](https://svn.boost.org/trac/boost/ticket/10173) +* [Math](/libs/math/): + + + Added Hyperexponential Distribution. + + Fix some spurious overflows in the incomplete gamma functions (with + thanks to Rocco Romeo). + + Fix bug in derivative of incomplete beta when a = b = 0.5 - this + also effects several non-central distributions, see issue 10480. + + Fixed some corner cases in function round. + + Don't support 80-bit floats in cstdfloat.hpp if standard library + support is broken. +* [Move](/libs/move/): +* Added `unique\_ptr` smart + pointer. Thanks to Howard Hinnant for his excellent unique\_ptr emulation + code and testsuite. +* Added `move\_if\_noexcept` + utility. Thanks to Antony Polukhin for the implementation. +* Fixed bugs: + + + [Trac #9785: + *"Compiler warning with intel icc in boost/move/core.hpp"*](https://svn.boost.org/trac/boost/ticket/9785), + + [Trac #10460: + *"Compiler error due to looser throw specifier"*](https://svn.boost.org/trac/boost/ticket/10460), + + [Git Pull #3: + *"Don't delete copy constructor when rvalue references + are disabled"*](https://github.com/boostorg/move/pull/3), +* [MultiArray](/libs/multi_array/): + + + Fixed a friend-declaration related warning for clang (thanks to Marcel + Raad). +* [Multiprecision](/libs/multiprecision/): + + + Changed rational to float conversions to exactly round to nearest. + + Added improved generic float to rational conversions. + + Fixed rare bug in exponent function for cpp\_bin\_float. + + Fixed various minor documentation issues. +* [Multi-index Containers](/libs/multi_index/): + + + When `std::tuple`s are available, these can + be used for lookup operations in indices equipped with composite + keys. `boost::tuple`s are also supported for backwards + compatibility. +* [Preprocessor](/libs/preprocessor/): + + + Added is\_begin\_parens and remove\_parens. + + Added tuple functionality to parallel all array functionality. + + Fixed VC++ problems with empty tuple data. + + Updated internal is\_empty to use superior variadic version when variadic + macros are supported. + + Updated clang to have same variadic support as gcc. + + Updated doc for new functionality. +* [Thread](/libs/thread/): + + + *New Experimental Features:* + + - [#6227](http://svn.boost.org/trac/boost/ticket/6227) + Synchro: Use of variadic templates on Generic Locking Algorithms + on compilers providing them + - [#10298](http://svn.boost.org/trac/boost/ticket/10298) + Synchro: Added queue views. + - [#10300](http://svn.boost.org/trac/boost/ticket/10300) + Async: Added generic\_executor\_ref. + - [#10552](http://svn.boost.org/trac/boost/ticket/10552) + Add make\_valid\_future + + *Fixed Bugs:* + + - [#6782](http://svn.boost.org/trac/boost/ticket/6782) + call\_once uses incorrect barrier intrinsic on Visual Studio + - [#6787](http://svn.boost.org/trac/boost/ticket/6787) + boost::thread::sleep() hangs if system time is rolled back + - [#7665](http://svn.boost.org/trac/boost/ticket/7665) + this\_thread::sleep\_for no longer uses steady\_clock in thread + - [#9307](http://svn.boost.org/trac/boost/ticket/9307) + future::fallback\_to assert with ERRORRRRR boost: mutex lock + failed in pthread\_mutex\_lock: Invalid argument + - [#9308](http://svn.boost.org/trac/boost/ticket/9308) + future::async fails with terminate called throwing an exception + when called with a lambda - clang-darwin-asan11 + - [#9310](http://svn.boost.org/trac/boost/ticket/9310) + test\_4648\_lib fails on clang-darwin-asan11 + - [#9425](http://svn.boost.org/trac/boost/ticket/9425) + Boost promise & future does not use supplied allocator + for value storage + - [#9558](http://svn.boost.org/trac/boost/ticket/9558) + future continuations unit test hangs in get()/pthread\_cond\_wait() + on Mac 10.7/32-bit/x86/darwin-4.2.1 + - [#9787](http://svn.boost.org/trac/boost/ticket/9787) + [windows] Small duration value passed down to basic\_timed\_mutex::try\_lock\_until + and condition\_variable::wait\_until can cause infinite or near + infinite wait for win32 + - [#9880](http://svn.boost.org/trac/boost/ticket/9880) + [windows] boost::condition\_variable.timed\_wait() exception + if system time < 1970 + - [#10159](http://svn.boost.org/trac/boost/ticket/10159) + GCC 4.4 error sorry, unimplemented + - [#10196](http://svn.boost.org/trac/boost/ticket/10196) + thread\_specific\_ptr does not support void\* + - [#10296](http://svn.boost.org/trac/boost/ticket/10296) + Boost.Thread 1.56 rc1 does not compile on Mingw + - [#10297](http://svn.boost.org/trac/boost/ticket/10297) + Boost.Thread 1.56 rc1 hangs when built with clang on armhf + - [#10340](http://svn.boost.org/trac/boost/ticket/10340) + No boost::promise::set\_value(const T&) overload + present in C++03 mode + - [#10425](http://svn.boost.org/trac/boost/ticket/10425) + Missing documentation for when\_all/when\_any. + - [#10426](http://svn.boost.org/trac/boost/ticket/10426) + Take in account the deferred futures in when\_all. + - [#10427](http://svn.boost.org/trac/boost/ticket/10427) + Take in account the deferred and ready futures in when\_any. + - [#10428](http://svn.boost.org/trac/boost/ticket/10428) + Adapt to new unique\_ptr interface in Boost.Move + - [#10465](http://svn.boost.org/trac/boost/ticket/10465) + Missing implementation of when\_all/when\_any when the result + is a tuple. + - [#10476](http://svn.boost.org/trac/boost/ticket/10476) + classes using BOOST\_THREAD\_MOVABLE\_ONLY dont satisfy + is\_copy\_constructible::value == false + - [#10478](http://svn.boost.org/trac/boost/ticket/10478) + Data race in boost/thread/future.hpp + - [#10529](http://svn.boost.org/trac/boost/ticket/10529) + The pthread/condition\_variable\_any constructor reports incorrect + error code for pthread\_cond\_init + - [#10563](http://svn.boost.org/trac/boost/ticket/10563) + shared\_future::then should be const +* [TypeIndex](/libs/type_index/): + + + `BOOST\_HAS\_PRAGMA\_DETECT\_MISMATCH` + is now used to detect ODR violations [#10404](https://svn.boost.org/trac/boost/ticket/10404) + + Typos fixed [#10294](https://svn.boost.org/trac/boost/ticket/10294) +* [TypeTraits](/libs/type_traits/): + + + Added new traits is\_copy\_assignable and is\_final. +* [Units](/libs/units/): + + + New unit system units + for: bit, byte, nat, hartley and shannon, + + Add scale units for binary prefixes kibi, mebi, gibi, tebi, pebi, + zebi and yobi IEC prefixes + + Fix output of NaN on msvc-14 + + Add support for C++11 numeric\_limits::max\_digits10 and ::lowest + + warning fixes +* [Unordered](/libs/unordered/): + + + Fix the `pointer` typedef + in iterators ([#10672](https://svn.boost.org/trac/boost/ticket/10672)). + + Fix Coverity warning ([GitHub + #2](https://github.com/boostorg/unordered/pull/2)). +* [Utility](/libs/utility/): + + + The `next()` + and `prior()` + functions taking distance arguments were reworked. The code now work + correctly when the distance is unsigned or both arguments are integers. + The new code relies on the availability of operators supported by + the first argument to select the correct implementation. +* [uBLAS](/libs/numeric/ublas/): + + + added two new types: matrix\_row and matrix\_column facades . With + them, it is possible to access to the matrices as an array of rows + and an array of columns, respectively. + + added fixed\_vector/fixed\_matrix classes to represent small - fixed + size containers. Requires c++11 because it is using std::array + + fixed the long standing banded matrix bug (https://svn.boost.org/trac/boost/ticket/7549). + + the interface of matrices and vectors has been extended with cbegin, + cend, crbegin and crend member functions, as defined in c++11. + + removed doxygen documentation to make the distribution lighter + + removed warnings with MSVC for unused parameters + + changed the uBlas development folder structure (will not affect users + of the library) + + performed a very large overhaul with respect to warnings and errors + on various compilers. Apart for some hard to resolve warnings and + older compiler incompatibilities, compilations with uBlas will be + much cleaner now. + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 3.1, 3.2, 3.3, 3.4 + + Clang, C++14: 3.5 + + GCC: 4.4.7, 4.5.3, 4.6.4, 4.7.3, 4.8.1, 4.8.2 + + GCC, C++98: 4.9.1 + + GCC, C++11: 4.4.7, 4.8.2, 4.8.3, 4.9.1 + + GCC, C++14: 4.9.1 + + Intel: 13.1, 14.0 + + Intel, C++11: 13.1, 14.0 + + QCC: 4.4.2 +* OS X: + + + Apple Clang: 6.0 + + Apple Clang, C++11: 6.0 + + Apple Clang, C++14: 6.0 + + GCC: 4.2.1, 4.9.1 + + Intel: 12.0 +* Windows: + + + GCC, mingw: 4.4.0, 4.4.7. 4.5.4, 4.6.3, 4.7.2, 4.7.3, 4.8.0, 4.8.2, + 4.9.0 + + Visual C++: 8.0, 9.0, 10.0, 11.0, 12.0 +* FreeBSD: + + + GCC: 4.2.1 +* QNX: + + + QCC: 4.4.2 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.1, 3.2, 3.3, 3.4.2 + + Clang, C++14: 3.5.0, trunk + + GCC: 4.4.7, 4.6.4, 4.7.3, 4.8.1, 4.8.2, 5.0 *(experimental)* + + GCC, C++11: 4.4.7, 4.8.2, 4.8.3, 4.9.1 + + GCC, C++14: 4.9.1 + + Intel: 11.1, 12.1, 13.0, 13.1, 14.0 + + Intel, C++11: 13.1, 14.0 +* OS X: + + + Apple Clang: 6.0 + + Apple Clang, C++11: 6.0 + + Apple Clang, C++14: 6.0 + + Clang: trunk + + Clang, C++11: trunk + + GCC: 4.2.1, 4.9.1 + + Intel: 12.0 +* Windows: + + + GCC, mingw: 4.4.0, 4.4.7, 4.5.4, 4.6.3, 4.7.3, 4.8.0, 4.8.2, 4.9.0 + + Visual C++: 8.0, 9.0, 10.0, 11.0, 12.0 +* FreeBSD: + + + GCC: 4.2.1 +* QNX: + + + QCC: 4.4.2 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_58_0.html b/users/history/version_1_58_0.html new file mode 100644 index 0000000..1be513e --- /dev/null +++ b/users/history/version_1_58_0.html @@ -0,0 +1,692 @@ +--- +title: Version 1.58.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.58.0 + +/\*\*/ + + + + + + + +Version 1.58.0 +============== + +Version 1.58.0 +-------------- + + +April 17th, 2015 07:53 GMT + + +[Documentation](/doc/libs/1_58_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_58\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.58.0/boost_1_58_0.tar.bz2) | +| [boost\_1\_58\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.58.0/boost_1_58_0.tar.gz) | +| windows | [boost\_1\_58\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.58.0/boost_1_58_0.7z) | +| [boost\_1\_58\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.58.0/boost_1_58_0.zip) | + + +### Known Issue + + +* Boost.Python will fail to build if it is compiled against a version of + python that is one of: 3.0.X, 3.1.X, 3.2.X, 3.3.X. Versions 2.X and 3.4+ + are not affected. This is fixed in [git](https://github.com/boostorg/python/commit/3e405b6fd5db5615bbef241763de070118222ca7). +* Boost.Fusion has a regression with non-constexpr types. [#11211](https://svn.boost.org/trac/boost/ticket/11211) + This + is fixed in some PRs: [Github + PR #70](https://github.com/boostorg/fusion/pull/70), [Github + PR #71](https://github.com/boostorg/fusion/pull/71), [Github + PR #72](https://github.com/boostorg/fusion/pull/72) + Patches: + + + +* [0001-Fix-exec\_file-for-Python-3-3.4.patch](/patches/1_58_0/0001-Fix-exec_file-for-Python-3-3.4.patch) + (for libs/python). +* [0002-Fix-a-regression-with-non-constexpr-types.patch](/patches/1_58_0/0002-Fix-a-regression-with-non-constexpr-types.patch) + (for libs/fusion). + +### New Libraries + + +* [Endian](/libs/endian): + Types and conversion functions + for correct byte ordering and more regardless of processor endianness. +* [Sort](/libs/sort/): + Includes spreadsort, a general-case + hybrid radix sort that is faster than O(n\*log(n)) + +### Updated Libraries + + +* [Asio](/libs/asio/): + + + Ensured errors generated by Windows' `ConnectEx` + function are mapped to their portable equivalents ([#10744](https://svn.boost.org/trac/boost/ticket/10744)). + + Added new macro `BOOST\_ASIO\_DISABLE\_CONNECTEX` + to allow use of `ConnectEx` + to be explicitly disabled. + + Fixed a race condition in `windows::object\_handle` + when there are pending wait operations on destruction ([#10624](https://svn.boost.org/trac/boost/ticket/10624)). + + Fixed IPv6 address parsing on FreeBSD, where a trailing scope ID + would cause conversion to fail with `EINVAL`. + + Worked around shared library visibility issues by ensuring Asio types + use default visibility ([#9465](https://svn.boost.org/trac/boost/ticket/9465), [#11070](https://svn.boost.org/trac/boost/ticket/11070)). + + Changed the SSL wrapper to call the password callback when loading + an in-memory key ([#10828](https://svn.boost.org/trac/boost/ticket/10828)). + + Fixed false SSL error reports by ensuring that the SSL error queue + is cleared prior to each operation. + + Fixed an `ssl::stream<>` + bug that may result in spurious 'short read' errors. + + Removed a redundant null pointer check in the SSL engine ([#10088](https://svn.boost.org/trac/boost/ticket/10088)). + + Added options for disabling TLS v1.1 and v1.2 ([#10690](https://svn.boost.org/trac/boost/ticket/10690)). + + Removed use of deprecated OpenSSL function `ERR\_remove\_state`. + + Fixed detection of various C++11 features with Clang ([#8835](https://svn.boost.org/trac/boost/ticket/8835), + [#10884](https://svn.boost.org/trac/boost/ticket/10884)). + + Fixed detection of C++11 `std::addressof` + with g++ ([#10982](https://svn.boost.org/trac/boost/ticket/10982)). + + Changed multicast test to treat certain `join\_group` + failures as non-fatal. + + Decoupled Asio unit tests from Boost.Test ([#11116](https://svn.boost.org/trac/boost/ticket/11116)). + + Changed the tutorial to use `std::endl` + to ensure output is flushed. + + Fixed an unsigned integer overflow reported by Clang's integer sanitizer. + + Added support for move-only return types when using a `yield\_context` object with asynchronous + operations. + + Changed `yield\_context` + to allow reentrant calls to the completion handler from an initiating + function. + + Updated detection of Windows Runtime to work with latest Windows + SDK. +* [Chrono](/libs/chrono/): + + + *Version* 2.0.5 + + *Fixes:* + + - [#10778](http://svn.boost.org/trac/boost/ticket/10778) + VC14 CTP4 Atomic don't compile with boost::chrono durations + which are not TriviallyCopyable + - [#10840](http://svn.boost.org/trac/boost/ticket/10840) + Missing std:: qualifier for puts call in test\_7868.cpp + - [#10851](http://svn.boost.org/trac/boost/ticket/10851) + Missing std:: qualifier for puts call in time\_point\_output.cpp + - [#10893](http://svn.boost.org/trac/boost/ticket/10893) + Minor doc typo in Boost.Chrono + - [#10992](http://svn.boost.org/trac/boost/ticket/10992) + Chrono IO state savers inconsistent with Boost.IO state savers + - [#10995](http://svn.boost.org/trac/boost/ticket/10995) + duration\_put::put\_value truncates fractional part + - [#11006](http://svn.boost.org/trac/boost/ticket/11006) + Impossible to instantiate time\_fmt\_io\_saver due to several + errors. + - [#11012](http://svn.boost.org/trac/boost/ticket/11012) + chrono\_io v2 fail to compile with boost::chrono::duration< + boost::rational > +* [Container](/libs/container/): + + + Experimental `small\_vector` + container. + + Massive dependency reorganization. Now *Boost.Container* + depends on very basic utilities like Boost.Core and *Boost.Intrusive*. + Preprocessed code size have decreased considerably and compilation + times have improved. + + Added `nth` and `index\_of` functions to containers + with random-access iterators (except `basic\_string`). + + Added C++17's `allocator\_traits::is\_always\_equal`. + + Updated containers to implement new constructors as specified in + [2210. + Missing allocator-extended constructor for allocator-aware containers](http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2210). + + Fixed bugs: + + - [#9931: + *"flat\_map::insert(ordered\_unique\_range\_t...) + fails with move\_iterators"*](https://svn.boost.org/trac/boost/ticket/9931) (reopened). + - [#11076: + *"Unqualified calls to memmove/memcpy in container/detail/copy\_move\_algo.hpp"*](https://svn.boost.org/trac/boost/ticket/11076). + - [Trac + #10790 (*long long errors from container"*)](https://svn.boost.org/trac/boost/ticket/10790). + - [Trac + #10808 (*compare equal operator of vector is broken"*)](https://svn.boost.org/trac/boost/ticket/10808). + + *Source Breaking*: `scoped\_allocator\_adaptor`'s + `propagate\_on\_container\_copy\_assignment`, + `propagate\_on\_container\_move\_assignment` + and `propagate\_on\_container\_swap` + are no longer `::boost::integral\_constant` types. The dependency reorganization + needed to break with those classes to avoid MPL dependencies, and + interoperability with `std::integral\_constant` + was not guaranteed. Code assumming `boost::true\_type/boost::false\_type` + on this will not compile. As a workaround, use the guaranteed internal + `::value` + constant: `::boost::integral\_constant::propagate\_on\_container\_move\_assignment::value>`. +* [Context](/libs/context/): + + + support for ARM/iOS (32+64 bit) + + class execution\_context (C++14) +* [Conversion](/libs/conversion/): + + + `polymorphic\_pointer\_downcast` + and `polymorphic\_pointer\_cast` + functions were added (thanks to Boris Rasin) [#10780](https://svn.boost.org/trac/boost/ticket/10780) + + All the functions now throw exceptions using `boost::throw\_exception` + + Documnetation update +* [DateTime](/libs/date_time/): + + + Restored `to\_time\_t` + function. + + Renamed variable v\_type to var\_type so it longer conflicts with an + AIX system variable. + + Documnetation fixes. +* [Flyweight](/libs/flyweight/): + + + Added hash support both with `std::hash` + and [`boost::hash`](/doc/html/hash.html). + This can be optionally [disabled](/libs/flyweight/doc/reference/flyweight.html#disable_hash_support) + to avoid clashes with legacy code where this support has already + been defined by the user. + + Maintenance fixes. +* [Function](/libs/function/): + + + Added support for functions accepting C++11 rvalues and Boost.Move + rvalues [#10585](https://svn.boost.org/trac/boost/ticket/10585). +* [Functional/Factory](/libs/functional/factory/): + + + Minor breaking change: the default template parameter to indicate + that it shouldn't use an allocator is now `void`, + instead of `boost::none\_t`. + For details, see the [changelog](/libs/functional/factory/doc/html/#boost_functional_factory.changes). +* [Fusion](/libs/fusion/): + + + Automatic hash creation function ([Github + PR #12](https://github.com/boostorg/fusion/pull/12)) + + New ADAPT\_STRUCT, ADAPT\_ADT, ADAPT\_ASSOC\_ that deduce the members + types ([#9516](https://svn.boost.org/trac/boost/ticket/9516)). + + Add convert implementation for Boost.Tuple and std::tuple. + + Add mpl::clear implementation for Boost.Tuple and std::tuple. + + Use boost::declval instead of std::declval, ([#10190](https://svn.boost.org/trac/boost/ticket/10190)). + + Remove use of `boost::blank` + ([#8622](https://svn.boost.org/trac/boost/ticket/8622)). + + Add result\_of::{copy,move} ([#5886](https://svn.boost.org/trac/boost/ticket/5886)). + + Better constexpr and noexcept support. + + Improved SFINAE Friendliness of many metafunctions ([#10676](https://svn.boost.org/trac/boost/ticket/10676), + [#10443](https://svn.boost.org/trac/boost/ticket/10443)). + + result\_of::size::value and result\_of::size::type::value are the same + type now ([#7304](https://svn.boost.org/trac/boost/ticket/7304)) + + result\_of::at::type is now defined when sizeof of sequence + is less than N ([#6507](https://svn.boost.org/trac/boost/ticket/6507), [#7651](https://svn.boost.org/trac/boost/ticket/7651)) + + Fix missing includes ([#8457](https://svn.boost.org/trac/boost/ticket/8457)). + + Many documentation fixes & improvements ([#6090](https://svn.boost.org/trac/boost/ticket/6090), [#5324](https://svn.boost.org/trac/boost/ticket/5324), + [GitHub PR + #33](https://github.com/boostorg/fusion/pull/33), [GitHub + PR #53](https://github.com/boostorg/fusion/pull/53), [GitHub + PR #56](https://github.com/boostorg/fusion/pull/56)) +* [Geometry](/libs/geometry/): + + + *Additional functionality:* + + - New algorithm num\_segments, returning the number of segments + of a geometry + - New overload for is\_valid algorithm, that takes a string reference + as a second argument and fills it with a message related to + the validity or invalidity of the geometry + - New overload for is\_valid algorithm, that takes an enum reference + as a second argument and fills it with a value related to the + validity or invalidity of the geometry + - Disjoint and intersects support the following geometry combinations: + point/multipoint, multipoint/multipoint, multipoint/segment, + multipoint/box + + *Improvements:* + + - Buffer now supports flat-ends for linestrings with a bend close + to the start (such that buffered segment crosses flat-end). + - Buffer performance is improved significantly + - Partition performance is improved significantly for polygons, + potentially enhancing all overlay operations + + *Solved tickets:* + + - [#8379](https://svn.boost.org/trac/boost/ticket/8379) + Invalid comparison of the result of determinant + - [#10108](https://svn.boost.org/trac/boost/ticket/10108) + Error in overlay operations in specific cases where geometries + touch at one point + - [#10201](https://svn.boost.org/trac/boost/ticket/10201) + Suggestion to use different function to compare coordinates + [wontfix] + - [#10467](https://svn.boost.org/trac/boost/ticket/10467) + Template parameter name coliding with B0 macro name defined + in termios.h + - [#10640](https://svn.boost.org/trac/boost/ticket/10640) + Invalid result of buffer() for CCW Polygons. + - [#10666](https://svn.boost.org/trac/boost/ticket/10666) + MSVC compiler warning C4127: conditional expression is constant + - [#10747](https://svn.boost.org/trac/boost/ticket/10747) + Error in rescaling causing errors in areal/areal set operations + - [#10770](https://svn.boost.org/trac/boost/ticket/10770) + Buffer fails for large distances, or rough round joins, where + concavities where not intersected properly + - [#10658](https://svn.boost.org/trac/boost/ticket/10658) + sym\_difference yields bad result for int polygons + - [#10835](https://svn.boost.org/trac/boost/ticket/10835) + Difference of multilinestring and polygon yields wrong result + - [#10861](https://svn.boost.org/trac/boost/ticket/10861) + Rtree failing to compile for Value being a pair or a tuple + containing pointer to Geometry and the default equal\_to<> + used + - [#10863](https://svn.boost.org/trac/boost/ticket/10863) + Template parameter name coliding with B0 macro name defined + in termios.h (duplicate of 10467) + - [#10887](https://svn.boost.org/trac/boost/ticket/10887) + Invalid result of within() and relate() for Linear/MultiPolygon + - [#10890](https://svn.boost.org/trac/boost/ticket/10890) + Invalid result of disjoint() for Point/Segment. + - [#10904](https://svn.boost.org/trac/boost/ticket/10904) + Invalid calculation of most significant Dimension of a segment + in relate\_cartesian\_segments strategy + - [#10912](https://svn.boost.org/trac/boost/ticket/10912) + Invalid result of within() and relate() for Areal/Areal + - [#10951](https://svn.boost.org/trac/boost/ticket/10951) + Tests failing on windows with intel compiler due to lack of + /bigobj flag. + - [#10957](https://svn.boost.org/trac/boost/ticket/10957) + Assertion failure and invalid results of various relational + operations. + - [#10958](https://svn.boost.org/trac/boost/ticket/10958) + Invalid results of disjoint() L/L and L/A. + - [#10959](https://svn.boost.org/trac/boost/ticket/10959) + Assertion failure in get\_turns() used with no\_rescale\_policy. + - [#10960](https://svn.boost.org/trac/boost/ticket/10960) + Invalid result of get\_turns() for L/A, missing turn. + - [#10961](https://svn.boost.org/trac/boost/ticket/10961) + Invalid result of get\_turns() for L/A, invalid turn for a Linear + spike. + - [#11112](https://svn.boost.org/trac/boost/ticket/11112) + Compilation failure on Solaris due to a CS name clash (used + for a macro on this platform) + - [#11121](https://svn.boost.org/trac/boost/ticket/11121) + Invalid result of difference() for integral coordinates + + *Bugfixes:* + + - Bug in multipoint/polygon multipoint/multipolygon distance + computation (wrong detection of points inside the areal geometry) + - Bug in flatten\_iterator's assignment operator causing an access + violation + - Bug in Cartesian segment-segment intersection strategy when + one segment degenerates to a point and is collinear to the + other non-degenerate segment + - Bug in centroid(), non-deterministic result if calculated for + e.g. a Polygon with zero-area. + - Bug in buffers for joins with a limited number of points + - Bug in buffers for round joins with limited number of points + around sharp corners + - Bug in buffers for joins with large buffer distances + - Bug in buffers for round ends with an odd number of points + - Bug in buffers for flat ends with large buffer distances + - Bug in buffers for interior rings with large negative buffer + distances + - Bug in closing\_iterator not working properly when the input + range is empty + - Bug in is\_simple, not handling properly closed simple linestrings + within multilinestrings + - Bug in rtree constructors taking a pair of Iterators or a Range + (packing algorithm), the use of reference to destroyed temporary + when Iterator's reference is not true reference, e.g. for some + of the Range Adaptors. It also affects distance() and comparable\_distance(). + This bug may cause unexpected behavior of the rtree or distance() + algorithm, e.g. an assertion failure or a SEGFAULT. + - Bug in rtree count() member function, the use of reference + to destroyed temporary when object of type convertible but + not the same as value\_type or indexable\_type is passed. If + this happens, wrong result may be returned, in most cases 0. + - Bugs related to the handling of Ranges, preventing compilation + of Geometries using non-Container Ranges in some algorithms + (thanks to Samuel Debionne) +* [Hash](/libs/functional/hash/): + + + Fixed strict aliasing violation ([GitHub + #3](https://github.com/boostorg/functional/pull/3)). +* [Interprocess](/libs/interprocess/): + + + Reduced some compile-time dependencies. Updated to Boost.Container + changes. + + Fixed bugs: + + - [GitHub + Pull #13 (*"haiku: we don't have XSI shared memory, + so don't try to use it"*)](https://github.com/boostorg/interprocess/pull/13). +* [Intrusive](/libs/intrusive/): + + + Reduced compile-time dependencies, headers, and the use of Boost.Preprocessor, + specially for hooks and iterators. + + Fixed bugs: + + - [Boost + Trac #6720: *intrusive::unordered\_set::clear\_and\_dispose + does not compile on VC11 Beta when passed a stateless lambda*](https://svn.boost.org/trac/boost/ticket/6720) + - [Boost + Trac #10771: *remove\_if is broken for slist*](https://svn.boost.org/trac/boost/ticket/10771) + - [Boost + Trac #10853: *problem with detection of const\_cast\_from*](https://svn.boost.org/trac/boost/ticket/10853) + - [Boost + Trac #10987: *bug in any\_xxx\_node\_traits, returning + by reference*](https://svn.boost.org/trac/boost/ticket/10987) +* [Lexical Cast](/libs/lexical_cast/): + + + Now std::stream is used for conversions to float numbers [#5660](https://svn.boost.org/trac/boost/ticket/5660), + [#6975](https://svn.boost.org/trac/boost/ticket/6975), [#10639](https://svn.boost.org/trac/boost/ticket/10639) +* [Log](/libs/log/): + + + Bug fixes: + + - Fixed thread id formatting. + - Fixed process id formatting. ([#10926](https://svn.boost.org/trac/boost/ticket/10926)) + - Fixed build failure on GNU Hurd. + - Fixed incorrect behavior of text file sink backend in case + if free space on the file system gets exhausted. The sink will + no longer create lots of empty files in attempt to recover. + ([#11016](https://svn.boost.org/trac/boost/ticket/11016)) + - Fixed incorrect behavior of `attribute\_set::insert()` in some cases. The inserted + elements could have made some previously inserted elements + not findable. ([#11106](https://svn.boost.org/trac/boost/ticket/11106)) + - Fixed incorrect behavior of `attribute\_value\_set::size()` if a large number of attribute + values are inserted into the set. ([#11148](https://svn.boost.org/trac/boost/ticket/11148)) + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Math](/libs/math/): + + + Added two new special functions - trigamma and polygamma. + + Large update to the Elliptic integral code to use Carlson's latest + algorithms - these should be more stable, more accurate and slightly + faster than before. Also added support for Carlson's RG integral. + + Added ellint\_d, jacobi\_zeta and heuman\_lambda elliptic integrals. + + Fixed namespace scope constants so they are constexpr on conforming + compilers, see [#10901](https://svn.boost.org/trac/boost/ticket/10901). + + Fixed various cases of spurious under/overflow in the incomplete + beta and gamma functions, plus the elliptic integrals, with thanks + to Rocco Romeo. + + Fix 3-arg legendre\_p and legendre\_q functions to not call the policy + based overload if the final argument is not actually a policy. + + Cleaned up some dead code in the incomplete beta function, see [#10985](https://svn.boost.org/trac/boost/ticket/10985). + + Fixed extreme-value pdf for large valued inputs, see [#10938](https://svn.boost.org/trac/boost/ticket/10938). + + Switched documentation to use SVG rather than PNG graphs and equations + - browsers seem to have finally caught up! +* [Move](/libs/move/): + + + Added `BOOST\_MOVE\_BASE` + utility. + + Added `adl\_move\_swap` + utility. + + Reduced dependencies on other Boost libraries to make the library + a bit more lightweight. + + Fixed bugs: + + - [Trac + #11044: *"boost::rv inherits off union, when + such passed as template argument"*](https://svn.boost.org/trac/boost/ticket/11044). +* [Multi-index Containers](/libs/multi_index/index.html): + + + The efficiency of lookup operations has improved in situations where + they involve the generation of temporary values of `key\_type`. Consider for instance + the following code: + + + ``` + typedef multi\_index\_container< + std::string, + indexed\_by< + ordered\_unique > + > + > multi\_t; + ... + multi\_t m=...; + m.find("boost"); // passed a const char\*, not a std::string + + ``` + + + In previous versions of the library, the `find` + operation generates several temporary `std::string`s + (one every time an internal comparison is made). In sufficiently + advanced compilers, this is now avoided so that only one temporary + is created. + + Maintenance fixes. +* [Multiprecision](/libs/multiprecision/): + + + Changed `frexp` to + always be non-expression template generating, see: [10993](https://svn.boost.org/trac/boost/ticket/10993). + + Improved support of cpp\_dec\_float on Cygwin and other platforms with + missing long double support, see [10924](https://svn.boost.org/trac/boost/ticket/10924). + + Improved noexcept support and added some more tests, see [10990](https://svn.boost.org/trac/boost/ticket/10990). + + Various workarounds applied for Intel-15.0 and Solaris-12.4 compilers. +* [Optional](/libs/optional/): + + + Improved documentation; documented IO operations and header files. + + *Fixed Bugs:* + + - `boost::none\_t` is no longer convertible + from literal 0. This avoids a bug where `optional> oi + = 0;` would initialize an optional + object with no contained value. + - Added a way to manually disable move semantics: just define + macro `BOOST\_OPTIONAL\_CONFIG\_NO\_RVALUE\_REFERENCES`. + This can be used to work around [#10399](http://svn.boost.org/trac/boost/ticket/10399). + - [#10825](http://svn.boost.org/trac/boost/ticket/10825) + Improved the trick that prevents streaming out `optional` without header + `optional\_io.hpp` + by using safe-bool idiom. + - [#11087](http://svn.boost.org/trac/boost/ticket/11087) + It is no longer possible to assign `optional` to `optional` when `U` + is not assignable or convertible to `T`. + - [#10839](http://svn.boost.org/trac/boost/ticket/10839) + Value accessors now work correctly on rvalues of `optional`. +* [Phoenix](/libs/phoenix/): + + + Version 3.2.0 + + *New Features:* + + - Phoenix now has a *lazy list* implementation + as an optional extension. + + *New Example:* + + - A new example *bind\_goose* shows the compatibility + between *boost bind* and *boost + phoenix bind*. + + *Fixed Bugs:* + + - [#10927](http://svn.boost.org/trac/boost/ticket/10927) + Missing `std::` qualifier for `fabs` in `phoenix/test/stdlib/cmath.cpp` + - [#11085](http://svn.boost.org/trac/boost/ticket/11085) + Missing qualifier for pow call in `phoenix/test/function/function\_tests.cpp` + - Fixes for a number of cases failing with *bind*, + *lambda* and *let*. +* [Predef](/libs/predef/): + + + Version 1.2 + + Added Visual Studio 2015 detection. + + Added detection of Haiku OS. + + Fix Android endian detection. + + Added `predef\_check` + program and BBv2 integration for build configuration checks. +* [Random](/libs/random/): + + + Added non\_central\_chi\_squared\_distribution. +* [Thread](/libs/thread/): + + + *Version* 4.5.0 + + *New Experimental Features:* + + - [#9600](http://svn.boost.org/trac/boost/ticket/9600) + Async: Add task\_region + - [#10611](http://svn.boost.org/trac/boost/ticket/10611) + Add emplace promise::set\_value and emplace make\_ready\_future + - [#10826](http://svn.boost.org/trac/boost/ticket/10826) + Add scheduled executor operations + - [#11048](http://svn.boost.org/trac/boost/ticket/11048) + Add a serial\_executor based on continuations + + *Fixed Bugs:* + + - [#6787](http://svn.boost.org/trac/boost/ticket/6787) + boost::thread::sleep() hangs if system time is rolled back + - [#10734](http://svn.boost.org/trac/boost/ticket/10734) + Submit method work differently on different executors, some + throw exception and some silently ignore error (thread\_executor + and inline\_executor) + - [#10736](http://svn.boost.org/trac/boost/ticket/10736) + Task exceptions silently ignored. I think std::terminate solution + from N3785 and std::thread is better choice and more consistent. + - [#10737](http://svn.boost.org/trac/boost/ticket/10737) + In serial\_executor we have infinite wait if task throw exception. + - [#10822](http://svn.boost.org/trac/boost/ticket/10822) + Boost.Thread fails to compile on Android + - [#10824](http://svn.boost.org/trac/boost/ticket/10824) + Boost.Thread 1.57 breaks Windows XP compatibility for SP2 and + below. + - [#10963](http://svn.boost.org/trac/boost/ticket/10963) + future>::then Has No Implementation + - [#10964](http://svn.boost.org/trac/boost/ticket/10964) + future>::unwrap().then() Deadlocks + - [#10968](http://svn.boost.org/trac/boost/ticket/10968) + The futures returned by async() and future::then() are not + blocking. + - [#10971](http://svn.boost.org/trac/boost/ticket/10971) + shared\_future::get()/get\_or() must be const + - [#10972](http://svn.boost.org/trac/boost/ticket/10972) + shared\_future::then() can be called multiple times. + - [#10979](http://svn.boost.org/trac/boost/ticket/10979) + Support T& type deduction when the make\_ready\_future parameter + is reference\_wrapper + - [#10996](http://svn.boost.org/trac/boost/ticket/10996) + Thread physical\_concurrency() is failing on Windows + - [#11035](http://svn.boost.org/trac/boost/ticket/11035) + BOOST\_HAS\_PTHREAD\_MUTEXATTR\_SETTYPE not defined for Android + - [#11053](http://svn.boost.org/trac/boost/ticket/11053) + The attached code results in a R6025 - pure virtual function + call in run\_thread\_exit\_callbacks +* [TypeErasure](/libs/type_erasure/): + + + Fixed compilation with MSVC 12. +* [TypeIndex](/libs/type_index/): + + + Link time assertions added on platforms that support it +* [Units](/libs/units): + + + Fix for base units with arbitrary dimensions. +* [Unordered](/libs/unordered): + + + Fix move assignment with stateful, propagate\_on\_container\_move\_assign + allocators ([#10777](https://svn.boost.org/trac/boost/ticket/10777)). + + Fix potential overflow when calculating number of buckets to allocate + ([GitHub + #4](https://github.com/boostorg/unordered/pull/4)). + + Other minor changes, see [changelog](/doc/html/unordered/changes.html). +* [Variant](/libs/variant/): + + + **Breaking change:** Compile time checked + getter is now used by default in `boost::get(VariantT)` and `boost::polymorphic\_get(VariantT)`. New getter asserts that type `U` is one of the types that can + be stored in `VariantT`. + Define `BOOST\_VARIANT\_USE\_RELAXED\_GET\_BY\_DEFAULT` + to change default behavior. See [get.hpp](/doc/html/variant/reference.html#header.boost.variant.get_hpp) + and [polymorphic\_get.hpp](/doc/html/variant/reference.html#header.boost.variant.polymorphic_get_hpp) + descriptions for more info [#547](https://svn.boost.org/trac/boost/ticket/547). + + Added missing comparison operators to variant [#8620](https://svn.boost.org/trac/boost/ticket/8620), [#10811](https://svn.boost.org/trac/boost/ticket/10811) + + Multiple documentations fixes [#10273](https://svn.boost.org/trac/boost/ticket/10273), [#10653](https://svn.boost.org/trac/boost/ticket/10653) + + Variadic templats enabled on Clang [#10832](https://svn.boost.org/trac/boost/ticket/10832) + + Autodetection of return types for visitors in C++14, which makes + it possible to use `boost::apply\_visitor` + with generic lambdas [#10837](https://svn.boost.org/trac/boost/ticket/10837): + + + ``` + auto str = boost::apply\_visitor( + [](auto v) { + return boost::lexical\_cast(v); + }, + variant\_instance + ); + + ``` + + Improved swap functions [#10882](https://svn.boost.org/trac/boost/ticket/10882) + + Many improvements to variadic templates, even more methods support + variadics. + + Multiple bugfixes and testing improvements including Coveralls integration + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.4 + + Clang, C++14: 3.5, 3.6 + + GCC: 4.4.7, 4.9.2 + + GCC, C++98: 4.8.1, 4.8.2 + + GCC, C++11: 4.4.7, 4.8.4, 4.9.2 + + GCC, C++14: 4.9.2 +* Windows: + + + GCC, mingw: 4.4.7, 4.5.4, 4.6.3, 4.7.3, 4.8.2 + + Visual C++: 8.0, 9.0, 10.0, 11.0, 12.0 +* FreeBSD: + + + GCC: 4.2.1 +* QNX: + + + QCC: 4.4.2 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.1, 3.2, 3.3, 3.4 + + Clang, C++14: 3.5, 3.6 + + GCC: 4.4.7, 4.6.4, 4.7.3, 4.8.1, 4.9.2, 5.0.0 (experimental) + + GCC, C++11: 4.4.7, 4.8.4, 4.9.2 + + GCC, C++14: 4.9.2 +* Windows: + + + GCC, mingw: 4.4.7, 4.5.4, 4.6.4, 4.7.3 + + Visual C++: 8.0, 9.0, 10.0, 11.0, 12.0, 14.0 +* Android + + + Clang: 3.4, 3.5 + + GCC: 4.8, 4.9 +* FreeBSD: + + + GCC: 4.2.1 +* QNX: + + + QCC: 4.4.2 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_59_0.html b/users/history/version_1_59_0.html new file mode 100644 index 0000000..a630a89 --- /dev/null +++ b/users/history/version_1_59_0.html @@ -0,0 +1,382 @@ +--- +title: Version 1.59.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.59.0 + +/\*\*/ + + + + + + + +Version 1.59.0 +============== + +Version 1.59.0 +-------------- + + +August 13th, 2015 15:23 GMT + + +[Documentation](/doc/libs/1_59_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_59\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.59.0/boost_1_59_0.tar.bz2) | +| [boost\_1\_59\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.59.0/boost_1_59_0.tar.gz) | +| windows | [boost\_1\_59\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.59.0/boost_1_59_0.7z) | +| [boost\_1\_59\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.59.0/boost_1_59_0.zip) | + + +### Known Issue + + +* Boost.Log contains has a regression that prevents some of the logging statements + from compiling ([#11549](https://svn.boost.org/trac/boost/ticket/11549)). This is fixed in [git](https://github.com/boostorg/log/commit/7da193fde1a9c1bc925ee980339f4df2e1a66fa7). + +### New Libraries + + +* [Convert](/libs/convert/): + An extendible and configurable + type-conversion framework, from Vladimir Batov. +* [Coroutine2](/libs/coroutine2/): + (C++14) Coroutine + library, from Oliver Kowalke. + +### Updated Libraries + + +* [Container](/libs/container/): + + + [GitHub + #26: *Fix bug in stable\_vector::capacity()*](https://github.com/boostorg/container/pull/26). + Thanks to timsong-cpp/Arindam Mukerjee. + + [GitHub + #27: *fix stable\_vector's index\_of's doxygen comment*](https://github.com/boostorg/container/pull/27). + Thanks to kariya-mitsuru. + + [Trac #11380: + *"Container library std forward declarations incorrect + in std\_fwd.hpp on libc++ with gcc"*](https://svn.boost.org/trac/boost/ticket/11380). + + [Trac #11388: + *"boost::container::list::emplace\_back broken on Visual + Studio 2010"*](https://svn.boost.org/trac/boost/ticket/11388). + + [Trac #11339: + *"VC12 LNK2005 error with boost::container::adaptive\_pool"*](https://svn.boost.org/trac/boost/ticket/11339). +* [Context](/libs/context/): + + + [#11223](https://svn.boost.org/trac/boost/ticket/11223) check support for std::integer\_sequence + + execution\_context uses internally Windows Fibers with BOOST\_USE\_WINFIBERS + + support of assember for MinGW on Windows (32bit) +* [Coroutine](/libs/coroutine/): + + + [#10978](https://svn.boost.org/trac/boost/ticket/10978) remove additional semicolons + + [#11230](https://svn.boost.org/trac/boost/ticket/11230) coroutine\_error returns dangling exception message pointer + + [#11234](https://svn.boost.org/trac/boost/ticket/11234) doesn't compile when used with boost::range::algorithms + + [#11356](https://svn.boost.org/trac/boost/ticket/11356) coroutines segfaults with BOOST\_USE\_SEGMENTED\_STACKS +* [Fusion](/libs/fusion/): + + + Add a new concept, `Unbounded + Sequence` for sequence and + `Unbounded Iterator` + for iterator. Currently, `Unbounded + Sequence` affects the behaviour + of `fusion::(value\_)at(\_c)` + and `fusion::(value\_)at\_key`. `Unbounded + Iterator` has no effect + (reserved for future release). For more details, see [Unbounded + Sequence](libs/fusion/doc/html/fusion/sequence/concepts/unbounded_sequence.html) and [Unbounded + Iterator](/libs/fusion/doc/html/fusion/iterator/concepts/unbounded_iterator.html). ([pull-request + 85](https://github.com/boostorg/fusion/pull/85)) + + Support C++11 variadic templates for `fusion::list`. + ([pull-request + 84](https://github.com/boostorg/fusion/pull/84)) + + *Fixed bugs:* + + - Fix missing include ``. + ([#11161](https://svn.boost.org/trac/boost/ticket/11161)) + - Revert some constexpr support, regression in 1.58.0. ([#11211](https://svn.boost.org/trac/boost/ticket/11211), + [#11267](https://svn.boost.org/trac/boost/ticket/11267)) + - Fix compile error with fold due to missing include. ([#11249](https://svn.boost.org/trac/boost/ticket/11249)) + - Fix compile error with adapting an empty struct, regression + in 1.58.0. ([#11269](https://svn.boost.org/trac/boost/ticket/11269)) + - Remove use of obsolete (and incorrect) workaround for sequence + comparison, it affects MSVC-8 and earlier. ([pull-request + 78](https://github.com/boostorg/fusion/pull/78)) + - Fix compile error while copying a sequece which derived from + fusion::list, regression in 1.58.0. ([pull-request + 87](https://github.com/boostorg/fusion/pull/87)) + - Fix compile error on copying a fusion::tuple. ([#11140](https://svn.boost.org/trac/boost/ticket/11140)) + - Add workarounds for GCC 4.6 with constexpr. ([#11517](https://svn.boost.org/trac/boost/ticket/11517)) +* [Geometry](/libs/geometry/): + + + *Additional functionality:* + + - Added rtree const\_iterator, begin(), end() and the support + for Boost.Range. + - The support for C++11 `std::initializer\_list` + in geometries models. + - Disjoint and intersects support the following geometry combinations: + multipoint/linestring, multipoint/multilinestring. + - Added relate() and relation() algorithms. + - Intersection has been implemented for combinations of pointlike + and linear geometries + - Added implementation for difference(pointlike, linear) + - New algorithm is\_empty, returning true if the geometry represents + the empty set + - The envelope algorithm supports pointlike and linear geometries + in the spherical equatorial coordinate system + - The envelope algorithm supports pointlike geometries in the + geographic coordinate system + + *Improvements:* + + - Upgraded rtree const\_query\_iterator category to ForwardIterator. + - Buffer performance of buffers around multi-points is improved + significantly + + *Breaking changes:* + + - buffer side strategy now returns error\_code instead of bool. + If you have your own custom side strategy, it should be adapted + + *Solved tickets:* + + - [#11113](https://svn.boost.org/trac/boost/ticket/11113) + Support easy enumeration of all elements with BOOST\_FOREACH + - [#11232](https://svn.boost.org/trac/boost/ticket/11232) + Feature request - relate() + - [#11236](https://svn.boost.org/trac/boost/ticket/11236) + Invalid result of centroid() for integer coordinate type + - [#11268](https://svn.boost.org/trac/boost/ticket/11268) + Regression in boost::geometry::intersection interface with + multi\_linestring and box -- does not compile on 1.57 VS 1.55 + - [#11332](https://svn.boost.org/trac/boost/ticket/11332) + Assertion failure in buffer for extreme coordinate differences + - [#11346](https://svn.boost.org/trac/boost/ticket/11346) + Segment iterator does not work with ranges returning values + instead of references + - [#11436](https://svn.boost.org/trac/boost/ticket/11436) + sym\_difference(py1, py2, mpy) returns invalid multipolygon + + *Bugfixes:* + + - Buffer: use a more robust way to calculate the side of an intersection, + this fixes several errors in buffer generation + - Fix in selection of segment to which calculate from IP from, + in intersection of two segments. Now is selected the one close + to a segment-point point, or else the one on the shortest segment. + This avoids (rarely occuring) generation of tiny triangles + making output polygons invalid + - In rescaling round instead of truncate to the integer grid + (this fix and the previous mentioned can have some impact on + output geometries) + - Fix potential infinite loop in detail::has\_spikes (the loop + can happen if the points passed have NaN coordinates) +* [Interprocess](/libs/interprocess/): + + + [( Trac + #5139 ( (*"Initial Stream Position in Boost.Interprocess.Vectorstream"*)](https://svn.boost.org/trac/boost/ticket/5139). + + [GitHub + Pull #19 (*"Fix exception visibility"*)](https://github.com/boostorg/interprocess/pull/19). + Thanks to Romain-Geissler. +* [Intrusive](/libs/intrusive/): + + + Implemented map and multimap-like + interfaces. + + Refactored hashtable containers to reduce template instantiations. +* [Lexical Cast](/libs/lexical_cast/): + + + Fixed warnings + + Simplified metaprogramming (thanks to Edward Diener) +* [Log](/libs/log/): + + + General changes: + + - On systems with [symbol + visibility](https://gcc.gnu.org/wiki/Visibility) support (e.g. Linux) the library is now + built with all internal symbols hidden. + - **Breaking change:** The library + has been ported to Boost.TypeIndex for its underlying type + info management tool. This affected the following public interfaces: + + * `invalid\_type` + exceptions thrown by the library now have `typeindex::type\_index` attached + as the description of the offending type. The type was + previously identified by `type\_info\_wrapper`. + * Boost.Exception `type\_info\_info` + error information now contains `typeindex::type\_index` + instead of `type\_info\_wrapper`. + * `attribute\_value::get\_type()` now returns `typeindex::type\_index` instead + of `type\_info\_wrapper`. + User-defined attribute value implementations should be + similarly changed (the `attribute\_value::impl::get\_type()` virtual method now + also returns `typeindex::type\_index`). + - `type\_info\_wrapper` + component has been deprecated and will be removed in future + releases. Boost.TypeIndex is recommended as a replacement. + - Removed the previously deprecated headers: `boost/log/utility/intrusive\_ref\_counter.hpp`, + `boost/log/utility/explicit\_operator\_bool.hpp`, `boost/log/utility/empty\_deleter.hpp`. + - Added support for building the library for OpenBSD. ([#11446](https://svn.boost.org/trac/boost/ticket/11446)) + - Improved internal implementation of the event synchronization + primitive used for asynchronous logging. ([#11398](https://svn.boost.org/trac/boost/ticket/11398)) + + Bug fixes: + + - Fixed incorrect behavior of `attribute\_value\_set::insert()` and `attribute\_value\_set` + constructor in some cases. ([#11190](https://svn.boost.org/trac/boost/ticket/11190)) + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Move](/libs/move/): + + + Changed `unique\_ptr`'s + converting constructor taking the source by value in C++03 compilers + to allow simple conversions from convertible types returned by value. + + [Trac #11229: + *"vector incorrectly copies move-only objects using + memcpy"*](https://svn.boost.org/trac/boost/ticket/11229), +* [Multi-index Containers](/libs/multi_index/index.html): + + + Added [ranked + indices](/libs/multi_index/doc/tutorial/indices.html#rnk_indices). + + Maintenance fixes. +* [Predef](/libs/predef/): + + + Fix many problems with `predef\_check` + functionality. + + Update SunPro detection to accomodate latest version of compiler + from Oracle. + + Add `and` and `or` logical operators for `predef\_check` expression on the + Boost Build side. + + Fix `BOOST\_ARCH\_PARISC` + to correctly spelled name. + + Fix `MAKE\_YYYYM` macros + to correctly limit the month. +* [Program Options](/libs/program_options/): + + + Fix compilation errors, missing dllexport and warnings with MSVC + and MinGW (Daniela Engert, Marcel Raad). + + Fix unintialized fields (Zoey Greer). + + Stop options with implicit value from consuming separate tokens (Michael + John Decker). + + Make multitoken limit be max int, not 32K (Hans Hohenfeld). + + Code formatting and documentation fixes (Jurko Gospodnetić, Lauri + Nurmi). + + Minimal support for no-rtti build (Minmin Gong) + + Don't increment environment pointer past the end (Vladimir Prus) +* [Property Tree](/libs/property_tree/): + + + A new JSON parser with full Unicode support. + + **Breaking change:** The new parser + does not support comments or string concatenation in JSON files. + These features were non-standard extensions of the old parser but + their removal could break code which was relying on them. +* [Boost.Test v3](/libs/test/): + + + Major new features + + - `BOOST\_TEST` + generic assertion + - data driven test cases + - test units can now have *attributes* for + finer control over tests behavior (logical grouping, test dependencies, + test enabling/disabling) + - CLI learned `colour\_output` + and `list\_content`, + extended unit test filtering (negation, labels) + - refactored and rewritten documentation using quickbook + + Addressed issues: + + - [#2018](https://svn.boost.org/trac/boost/ticket/2018) [#2450](https://svn.boost.org/trac/boost/ticket/2450) [#2600](https://svn.boost.org/trac/boost/ticket/2600) [#2717](https://svn.boost.org/trac/boost/ticket/2717) [#2759](https://svn.boost.org/trac/boost/ticket/2759) [#3182](https://svn.boost.org/trac/boost/ticket/3182) [#3316](https://svn.boost.org/trac/boost/ticket/3316) [#3392](https://svn.boost.org/trac/boost/ticket/3392) [#3402](https://svn.boost.org/trac/boost/ticket/3402) [#3445](https://svn.boost.org/trac/boost/ticket/3445) + - [#3463](https://svn.boost.org/trac/boost/ticket/3463) [#3542](https://svn.boost.org/trac/boost/ticket/3542) [#3481](https://svn.boost.org/trac/boost/ticket/3481) [#3495](https://svn.boost.org/trac/boost/ticket/3495) [#3592](https://svn.boost.org/trac/boost/ticket/3592) [#3595](https://svn.boost.org/trac/boost/ticket/3595) [#3623](https://svn.boost.org/trac/boost/ticket/3623) [#3664](https://svn.boost.org/trac/boost/ticket/3664) [#3784](https://svn.boost.org/trac/boost/ticket/3784) [#3785](https://svn.boost.org/trac/boost/ticket/3785) + - [#3811](https://svn.boost.org/trac/boost/ticket/3811) [#3834](https://svn.boost.org/trac/boost/ticket/3834) [#3896](https://svn.boost.org/trac/boost/ticket/3896) [#3932](https://svn.boost.org/trac/boost/ticket/3932) [#3938](https://svn.boost.org/trac/boost/ticket/3938) [#3964](https://svn.boost.org/trac/boost/ticket/3964) [#3978](https://svn.boost.org/trac/boost/ticket/3978) [#3979](https://svn.boost.org/trac/boost/ticket/3979) [#4161](https://svn.boost.org/trac/boost/ticket/4161) [#4275](https://svn.boost.org/trac/boost/ticket/4275) + - [#4389](https://svn.boost.org/trac/boost/ticket/4389) [#4434](https://svn.boost.org/trac/boost/ticket/4434) [#4587](https://svn.boost.org/trac/boost/ticket/4587) [#4806](https://svn.boost.org/trac/boost/ticket/4806) [#4911](https://svn.boost.org/trac/boost/ticket/4911) [#4923](https://svn.boost.org/trac/boost/ticket/4923) [#4924](https://svn.boost.org/trac/boost/ticket/4924) [#4982](https://svn.boost.org/trac/boost/ticket/4982) [#5008](https://svn.boost.org/trac/boost/ticket/5008) [#5036](https://svn.boost.org/trac/boost/ticket/5036) + - [#5262](https://svn.boost.org/trac/boost/ticket/5262) [#5374](https://svn.boost.org/trac/boost/ticket/5374) [#5412](https://svn.boost.org/trac/boost/ticket/5412) [#5563](https://svn.boost.org/trac/boost/ticket/5563) [#5582](https://svn.boost.org/trac/boost/ticket/5582) [#5599](https://svn.boost.org/trac/boost/ticket/5599) [#5718](https://svn.boost.org/trac/boost/ticket/5718) [#5729](https://svn.boost.org/trac/boost/ticket/5729) [#5870](https://svn.boost.org/trac/boost/ticket/5870) [#5972](https://svn.boost.org/trac/boost/ticket/5972) + - [#6002](https://svn.boost.org/trac/boost/ticket/6002) [#6071](https://svn.boost.org/trac/boost/ticket/6071) [#6074](https://svn.boost.org/trac/boost/ticket/6074) [#6161](https://svn.boost.org/trac/boost/ticket/6161) [#6766](https://svn.boost.org/trac/boost/ticket/6766) [#6712](https://svn.boost.org/trac/boost/ticket/6712) [#6748](https://svn.boost.org/trac/boost/ticket/6748) [#7046](https://svn.boost.org/trac/boost/ticket/7046) [#7136](https://svn.boost.org/trac/boost/ticket/7136) [#7410](https://svn.boost.org/trac/boost/ticket/7410) [#7894](https://svn.boost.org/trac/boost/ticket/7894) + - [#8201](https://svn.boost.org/trac/boost/ticket/8201) [#8272](https://svn.boost.org/trac/boost/ticket/8272) [#8467](https://svn.boost.org/trac/boost/ticket/8467) [#8862](https://svn.boost.org/trac/boost/ticket/8862) [#8895](https://svn.boost.org/trac/boost/ticket/8895) [#9179](https://svn.boost.org/trac/boost/ticket/9179) [#9272](https://svn.boost.org/trac/boost/ticket/9272) [#9390](https://svn.boost.org/trac/boost/ticket/9390) [#9409](https://svn.boost.org/trac/boost/ticket/9409) [#9537](https://svn.boost.org/trac/boost/ticket/9537) + - [#9539](https://svn.boost.org/trac/boost/ticket/9539) [#9581](https://svn.boost.org/trac/boost/ticket/9581) [#9960](https://svn.boost.org/trac/boost/ticket/9960) [#10318](https://svn.boost.org/trac/boost/ticket/10318) [#10394](https://svn.boost.org/trac/boost/ticket/10394) [#10888](https://svn.boost.org/trac/boost/ticket/10888) [#11054](https://svn.boost.org/trac/boost/ticket/11054) [#11347](https://svn.boost.org/trac/boost/ticket/11347) [#11358](https://svn.boost.org/trac/boost/ticket/11358) [#11359](https://svn.boost.org/trac/boost/ticket/11359) +* [TypeIndex](/libs/type_index/): + + + Removed dependencies on some of the Boost libraries to improve compilation + times and modularity + + Warnings fixed in tests and other maintainance improvements were + done. +* [Variant](/libs/variant/): + + + Fixed missing include in element\_index.hpp [#11196](https://svn.boost.org/trac/boost/ticket/11196), [#11283](https://svn.boost.org/trac/boost/ticket/11283) + + Fixed `boost::apply\_visitor` usage with C++14 + and const references [#11251](https://svn.boost.org/trac/boost/ticket/11251), [#11285](https://svn.boost.org/trac/boost/ticket/11285) + + Relaxed compile time checks for all the `get(variant\_variable)` functions (thanks to Nicolas Cornu) + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.4 + + Clang, C++14: 3.6 + + GCC: 4.4.7, 4.8.2, 4.9.3 + + GCC, C++11: 4.4.7 + + GCC, C++14: 4.9.3 + + Intel: 15.0 +* Windows: + + + Visual C++: 8.0, 9.0, 10.0, 11.0, 12.0, 14.0 +* Android: + + + Clang: 3.6 + + GCC: 4.8, 4.9 +* SunOS: + + + Sun: 6.0 +* QNX: + + + QCC: 4.4.2 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.1, 3.2, 3.3, 3.4 + + Clang, C++14: 3.6, 3.7 + + GCC: 4.4.7, 4.5.3, 4.6.4, 4.7.3, 4.8.1, 5.1.0, 6.0.0 + + GCC, C++11: 4.4.7 + + GCC, C++14: 4.9.3, 5.1.1 + + Intel: 15.0 +* Android: + + + Clang: 3.6 + + GCC: 4.8, 4.9 +* FreeBSD: + + + Clang: 3.4.1 + + GCC: 4.8.5, 5.1.0, 6.0.0 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_60_0.html b/users/history/version_1_60_0.html new file mode 100644 index 0000000..a33548e --- /dev/null +++ b/users/history/version_1_60_0.html @@ -0,0 +1,608 @@ +--- +title: Version 1.60.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.60.0 + +/\*\*/ + + + + + + + +Version 1.60.0 +============== + +Version 1.60.0 +-------------- + + +December 17th, 2015 15:52 GMT + + +[Documentation](/doc/libs/1_60_0/) + + +Downloads| Platform | File | +| unix | [boost\_1\_60\_0.tar.bz2](http://sourceforge.net/projects/boost/files/boost/1.60.0/boost_1_60_0.tar.bz2) | +| [boost\_1\_60\_0.tar.gz](http://sourceforge.net/projects/boost/files/boost/1.60.0/boost_1_60_0.tar.gz) | +| windows | [boost\_1\_60\_0.7z](http://sourceforge.net/projects/boost/files/boost/1.60.0/boost_1_60_0.7z) | +| [boost\_1\_60\_0.zip](http://sourceforge.net/projects/boost/files/boost/1.60.0/boost_1_60_0.zip) | + + +### New Libraries + + +* [VMD](/libs/vmd/): + Variadic Macro Data library, + from Edward Diener. + +### Updated Libraries + + +* [Atomic](/libs/atomic/): + + + Enforced proper alignment of `atomic<>` storage. This should fix + possible issues on platforms that support atomic operations on data + units larger than the native word size. This may also change binary + layout of user's data structures that have `atomic<>` members. + + Fixed compilation for PowerPC with IBM XL C++ compiler. Corrected + memory barriers in PowerPC assembler. + + Fixed compilation with MSVC-8 for ARM. + + Fixed compilation with gcc 4.4 for x86-64, when 128-bit atomic operations + were used. ([#10994](https://svn.boost.org/trac/boost/ticket/10994)) + + Optimized some gcc assembler blocks for x86/x86-64 to reduce the + number of used registers. This may require binutils 2.10 or later. +* [Chrono - 2.0.5](/libs/chrono/): + + + *Fixes:* + + - [#10778](http://svn.boost.org/trac/boost/ticket/10778) + VC14 CTP4 Atomic don't compile with boost::chrono durations + which are not TriviallyCopyable + - [#10840](http://svn.boost.org/trac/boost/ticket/10840) + Missing std:: qualifier for puts call in test\_7868.cpp + - [#10851](http://svn.boost.org/trac/boost/ticket/10851) + Missing std:: qualifier for puts call in time\_point\_output.cpp + - [#10893](http://svn.boost.org/trac/boost/ticket/10893) + Minor doc typo in Boost.Chrono + - [#10992](http://svn.boost.org/trac/boost/ticket/10992) + Chrono IO state savers inconsistent with Boost.IO state savers + - [#10995](http://svn.boost.org/trac/boost/ticket/10995) + duration\_put::put\_value truncates fractional part + - [#11006](http://svn.boost.org/trac/boost/ticket/11006) + Impossible to instantiate time\_fmt\_io\_saver due to several + errors. + - [#11012](http://svn.boost.org/trac/boost/ticket/11012) + chrono\_io v2 fail to compile with boost::chrono::duration< + boost::rational > +* [Container](/libs/container/): + + + Implemented Polymorphic + Memory Resources. + + Add more BOOST\_ASSERT checks to test preconditions in some operations + (like `pop\_back`, + `pop\_front`, `back`, `front`, + etc.) + + Added C++11 `back`/`front` operations to `basic_string`. + + Fixed bugs: + + - [Trac + #11627: *"small\_vector::swap() appears + to be broken"*](https://svn.boost.org/trac/boost/ticket/11627). + - [Trac + #11628: *"small\_vector iterates + over elements in destructor"*](https://svn.boost.org/trac/boost/ticket/11628). + - [Trac + #11697: *"Wrong initialization order in tuple + copy-constructor"*](https://svn.boost.org/trac/boost/ticket/11697). + - [Trac + #11698: *"Missing return statement in static\_storage\_allocator"*](https://svn.boost.org/trac/boost/ticket/11698). + - [GitHub + #29: *Doc fixes for flap\_map complexity requirements*](https://github.com/boostorg/container/pull/29). + - [GitHub + #31: *DL\_SIZE\_IMPL also dereference addr*](https://github.com/boostorg/container/pull/31). +* [Context](/libs/context/): + + + [#11603](https://svn.boost.org/trac/boost/ticket/11603) typo in PPC32/MACH-O asm + + support for CYGWIN +* [Core](/libs/core/): + + + In symbol demangling tools, added support for gabi++ ABI implementation + used in Android NDK. + + Added a new `enable\_if\_has\_type` + tool for performing SFINAE checks for presence of a nested type. +* [Filesystem](/libs/filesystem/): + + + *New Features:* + + - Added functions [`lexically\_normal`](/libs/filesystem/doc/reference.html#lex-normal), + [`lexically\_relative`](/libs/filesystem/doc/reference.html#lex-relative), + [`relative`](/libs/filesystem/doc/reference.html#op-relative), and [`weakly\_canonical`](/libs/filesystem/doc/reference.html#weakly_canonical). + Many thanks to Jamie Allsop for his help and perseverance. + Resolves tickets [#1976](https://svn.boost.org/trac/boost/ticket/1976), + [#5897](https://svn.boost.org/trac/boost/ticket/5897), + [#6249](https://svn.boost.org/trac/boost/ticket/6249). + - Class `path` + added types [`reverse\_iterator`](/libs/filesystem/doc/reference.html#path-iterators) + and [`const\_reverse\_iterator`](/libs/filesystem/doc/reference.html#path-iterators), + and added functions [`rbegin()`](/libs/filesystem/doc/reference.html#path-iterators), + and [`rend()`](/libs/filesystem/doc/reference.html#path-iterators). + - C++11 `noexcept` + supplied as specified in the Filesystem TS if supported by + the compiler. + - C++11 move constructors and move assignments supplied as specified + in the Filesystem TS if supported by the compiler. Resolves + [#10291](https://svn.boost.org/trac/boost/ticket/10291). + - Existing functions whose names changed in the Filesystem TS + are now supported under both the old and new names. + - Added [`size()`](/libs/filesystem/doc/reference.html#path-size) + function to class `path`. + Resolves [#6874](https://svn.boost.org/trac/boost/ticket/6874), + Path should have a `size()` member function. + + *Tickets:* + + - Fix [#11733](https://svn.boost.org/trac/boost/ticket/11733), + Missing unistd.h include in boost/libs/filesystem/src/unique\_path.cpp, + by apply a patch from Idar Tollefsen. + - Fix [#5706](https://svn.boost.org/trac/boost/ticket/5706), + unique\_path Fails on Windows for Temporary User Profiles, by + applying [pull + request #15](https://github.com/boostorg/filesystem/pull/15) from Sebastian Redl to fix a race condition + in `unique\_path`. + - Fix [#10591](https://svn.boost.org/trac/boost/ticket/10591), + boost::filesystem does not build on iOS 8, by applying a patch + submitted by Daniel Seither. + - Fix [#9454](https://svn.boost.org/trac/boost/ticket/9454), + Boost Filesystem [library build] not compiling when BOOST\_FILESYSTEM\_NO\_DEPRECATED + is defined, by applying a patch submitted by Makesim. + - Fix [#11447](https://svn.boost.org/trac/boost/ticket/11447), + `\_\_OpenBSD\_\_` + macro name misspelled, by applying a patch submitted by Jasper + Lievisse Adriaanse. + - Fix [#11288](https://svn.boost.org/trac/boost/ticket/11288), + A patch to avoid redundant string allocations, by applying + a patch submitted by Yevhen Ivannikov. + - Resolve [#11175](https://svn.boost.org/trac/boost/ticket/11175), + out-of-date documentation causing users to incorrectly expect + that the library could be used with exceptions disabled. + - Resolve [#11166](https://svn.boost.org/trac/boost/ticket/11166), + by mitigating (i.e. reducing the likelihood of) a possible + external file system race in `remove()`. + - Fix [#7258](https://svn.boost.org/trac/boost/ticket/7258), + `create\_directories` + returns false if the path ends with a slash. Also fix related + issues if path contains dot or dot-dot elements, and added + test cases to the test suite. + - Resolve [#10766](https://svn.boost.org/trac/boost/ticket/10766), + `parent\_path()` with redundant separator + returns wrong value, by adding examples and notes to the reference + documentation to show why the returned value is in fact correct, + and to provide rationale for that behavior. See [path.itr](/libs/filesystem/doc/reference.html#path-iterators), + and [path.decompose](/libs/filesystem/doc/reference.html#path-decomposition) + `parent\_path()` and `filename()` sections of the reference + docs. + - Close [#7607](https://svn.boost.org/trac/boost/ticket/7607), + path should not infer an invisible "." at the end + of a path that ends with a slash, as resolved by [#7258](https://svn.boost.org/trac/boost/ticket/7258) + and [#10766](https://svn.boost.org/trac/boost/ticket/10766). + - Close [#11061](https://svn.boost.org/trac/boost/ticket/11061), + [#11062](https://svn.boost.org/trac/boost/ticket/11062), + Impossible to traverse the path of the reverse iterator, as + effectively resolved by the addition of the class `path` reverse iteration feature. + The reference documentation has also been updated with a [note](/libs/filesystem/doc/reference.html#path-iterators) + warning about the limitations of class `path` + iterators. + + *Other fixes:* + + - Clear several spurious GCC warnings. + - Fix bug in `file\_status` + and `recursive\_directory\_iterator`: + C++ turns an explicit constructor with all arguments except + first defaulted into non-explicit single argument constructor. + - Apply Reference docs editorial cleanups: Use same style sheet + as the rest of the documentation. Tweak tab font size. Fix + excessively long lines in tables, synopsis. + - Minor fixes, including pull requests from Jonathan Wakely and + Marcel Raad. +* [Flyweight](/libs/flyweight/index.html): + + + Maintenance fixes. +* [Fusion](/libs/fusion/): + + + All of fusion containers and generators now support C++11 variadic + templates. ([pull-request + 89](https://github.com/boostorg/fusion/pull/89), [pull-request + 97](https://github.com/boostorg/fusion/pull/97), [pull-request + 100](https://github.com/boostorg/fusion/pull/100)) + + - **Special notice for `fusion::vector`** + + * Due to implementation limitation, numbered form (i.e. + `fusion::vectorN`) + is provided via C++11 aliasing templates and deprecated + in C++11 or later. In this case, you should check `BOOST\_FUSION\_HAS\_VARIADIC\_VECTOR` + macro and switch usage because some partial specialization + would become compile error (e.g. [pull-request + for Spirit](https://github.com/boostorg/spirit/pull/158/files#diff-250ce096dee927d2b7eb5a4e24afb8cd)). + + `fusion::nview` now support C++11 variadic + templates. ([pull-request + 90](https://github.com/boostorg/fusion/pull/90)) + + `fusion::fold` is now SFINAE-friendly. ([pull-request 102](https://github.com/boostorg/fusion/pull/102)) + + *Bug fixes:* + + - The generic fusion sequence convert to a deque fails with a + compiler error. ([#11572](https://svn.boost.org/trac/boost/ticket/11572)) + - (doc) Return type of functions incorrect. ([#3358](https://svn.boost.org/trac/boost/ticket/3358)) +* [Geometry](/libs/geometry/): + + + *Solved tickets:* + + - [#10803](https://svn.boost.org/trac/boost/ticket/10803) + Union algorithm returning invalid geometry + - [#11522](https://svn.boost.org/trac/boost/ticket/11522) + Namespace clash in buffer for traits::detail + - [#11533](https://svn.boost.org/trac/boost/ticket/11533) + Assert failure in rtree caused by a bug in remove() if min + elements number is 1 + - [#11607](https://svn.boost.org/trac/boost/ticket/11607) + Private geometry::exception::what() + - [#11709](https://svn.boost.org/trac/boost/ticket/11709) + is\_simple segfault + - [#11710](https://svn.boost.org/trac/boost/ticket/11710) + is\_simple - empty geometry logic + - [#11711](https://svn.boost.org/trac/boost/ticket/11711) + is\_simple and is\_valid - Points that are NaN or Infinity + + *Bugfixes:* + + - Fix colocations of touching interior ring / exterior ring, + where it also touches another polygon + - Fix removing values from an empty rtree - no effect and 0 returned + instead of assertion failure + - Fix segfault in centroid for multi geometries containing empty + single geometries (thanks to Jiri Drbalek) + - Fix liang\_barsky strategy for integral coordinates (thanks + to Dane Springmeyer) +* [Interprocess](/libs/interprocess/): + + + Improved `offset_ptr` + performance and removed any undefined behaviour. No special cases + needed for different compilers. + + Fixed bugs: + + - [Trac + #11699 (*"Forward declarations of std templates + causes stack corruption under Visual Studio 2015"*)](https://svn.boost.org/trac/boost/ticket/11699). +* [Intrusive](/libs/intrusive/): + + + Advanced lookup + and insertions in ordered associative containers now support + comparison functions that are not required to offer the same strict + weak ordering as `key\_compare`, + the container must be partitioned in regards to the passed comparison + object. + + Fixed bugs: + + - [Boost + Trac #11701: *Regression in boost::intrusive::set::equal\_range*](https://svn.boost.org/trac/boost/ticket/11701) + - [Boost + Trac #11765: *sgtree.hpp:830: bad if test ?*](https://svn.boost.org/trac/boost/ticket/11765) +* [Lexical Cast](/libs/lexical_cast/): + + + Fixed usage of `lexical\_cast` + with move only types [#11570](https://svn.boost.org/trac/boost/ticket/11570) + + Fixed crash when `BOOST\_LCAST\_NO\_COMPILE\_TIME\_PRECISION` + is defined [#11669](https://svn.boost.org/trac/boost/ticket/11669) + + Suppress some of the warning reported in [#11570](https://svn.boost.org/trac/boost/ticket/11570) and [#4946](https://svn.boost.org/trac/boost/ticket/4946) +* [Locale](/libs/locale): + + + Implemented generic codecvt facet and add general purpose utf8\_codecvt + facet + + Added posix locale support for FreeBSD 10.0 and above + + Fixed issues [#10017](https://svn.boost.org/trac/boost/ticket/10017) (sun redefinition on SunOS), [#11163](https://svn.boost.org/trac/boost/ticket/11163) (set\_default\_messages\_domain + incorrect behavior), [#11673](https://svn.boost.org/trac/boost/ticket/11673) build issues + + Some warning cleanup + + Fixed tests for latest ICU versions + + Added workaround for `libc++` issues + + Added new defines `BOOST\_LOCALE\_ENABLE\_CHAR16\_T` + and `BOOST\_LOCALE\_ENABLE\_CHAR32\_T` + to enable C++11 `char16\_t` + and `char32\_t` instead + of deprecated ones +* [Log](/libs/log/): + + + General changes: + + - On Windows, the configuration macro `BOOST\_LOG\_USE\_WINNT6\_API` + is no longer used by the library. The target Windows version + should be configured by defining macro `BOOST\_USE\_WINAPI\_VERSION`. + + Bug fixes: + + - Fixed compilation for Android using Google NDK. ([#11559](https://svn.boost.org/trac/boost/ticket/11559)) + - Fixed compilation of some logging statements, where the first + object to be put into stream is not directly supported by + `formatting\_ostream`. + ([#11549](https://svn.boost.org/trac/boost/ticket/11549)) + - Added a workaround for Solaris Studio 12.4, which should fix + the compilation of `formatting\_ostream`. + ([#11545](https://svn.boost.org/trac/boost/ticket/11545)) + - Fixed compilation when native `wchar\_t` + type is disabled. ([#11541](https://svn.boost.org/trac/boost/ticket/11541)) + - Fixed exporting symbols from the `boost\_log\_setup` + library on POSIX-like systems. + - Fixed compilation of character decorators. + - Added a workaround for incorrect file name generation in text + file sink backend, when the file name contains date/time placeholders. + ([#11691](https://svn.boost.org/trac/boost/ticket/11691)) + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Move](/libs/move/): + + + Fixed bug [Trac + #11615: *"Boost.Move should use the qualified name + for std::size\_t in type\_traits.hpp"*](https://svn.boost.org/trac/boost/ticket/11615), +* [Multi-index Containers](/libs/multi_index/index.html): + + + Fixed an interoperability problem with [Qt](http://www.qt.io/) + due to the optional definition of a macro with name `foreach` in this framework. + + Maintenance fixes. +* [odeint](/libs/numeric/odeint): + + + New features: + + - Added functionality to throw an exception if too many ODE steps + are performed. + - Added possibility to limit maximal step size in adaptive methods. + + several Bug fixes, see https://github.com/headmyshoulder/odeint-v2/issues +* [Optional](/libs/optional/): + + + Changed the implementation of `boost::none` + again. Now it is a const object with internal linkage (as any other + tag). This fixes [#11203](https://svn.boost.org/trac/boost/ticket/11203). +* [Predef](/libs/predef/): + + + Add detection of SIMD hardware. + + See [history](/libs/predef/doc/html/predef/history.html#predef.history.1_4) + for more details. +* [Test](/libs/test/): + + + Boost.test v3.1 see the '[Change + log](/doc/libs/1_60_0/libs/test/doc/html/boost_test/change_log.html)' section for details. + + New features + + - Improved Command Line Interface + - Improved dataset API + + Bug fixes + + - [#3384](https://svn.boost.org/trac/boost/ticket/3384), [#3897](https://svn.boost.org/trac/boost/ticket/3897), [#6032](https://svn.boost.org/trac/boost/ticket/6032), [#6859](https://svn.boost.org/trac/boost/ticket/6859), [#7257](https://svn.boost.org/trac/boost/ticket/7257) + - [#9228](https://svn.boost.org/trac/boost/ticket/9228), [#10317](https://svn.boost.org/trac/boost/ticket/10317), [#11279](https://svn.boost.org/trac/boost/ticket/11279), [#11478](https://svn.boost.org/trac/boost/ticket/11478) + - [#11571](https://svn.boost.org/trac/boost/ticket/11571), [#11623](https://svn.boost.org/trac/boost/ticket/11623), [#11624](https://svn.boost.org/trac/boost/ticket/11624), [#11625](https://svn.boost.org/trac/boost/ticket/11625) +* [Thread - 4.6.0](/libs/thread/): +*New + Experimental Features:* + + + [#11231](http://svn.boost.org/trac/boost/ticket/11231) + Allow to set continuation future's destructor behavior to non-blocking + + [#11424](http://svn.boost.org/trac/boost/ticket/11424) + Provide shared\_timed\_mutex as an alternative name for shared\_mutex + and deprecate the use of shared\_mutex as a timed mutex + + [#11734](http://svn.boost.org/trac/boost/ticket/11734) + future::then(Cont) should be able to execute the contination on undetermined + thread + + [#11736](http://svn.boost.org/trac/boost/ticket/11736) + Allow to use launch::executor on future::then(launch::executor, cont) + + [#11737](http://svn.boost.org/trac/boost/ticket/11737) + Add a launch::inherit policy that can be used on ::then() to use + the policy of the parent future *Fixed Bugs:* + + [#3926](http://svn.boost.org/trac/boost/ticket/3926) + thread\_specific\_ptr + dlopen library causes a SIGSEGV. + + [#6377](http://svn.boost.org/trac/boost/ticket/6377) + Condition variable blocks when changing time + + [#6787](http://svn.boost.org/trac/boost/ticket/6787) + boost::thread::sleep() hangs if system time is rolled back + + [#7665](http://svn.boost.org/trac/boost/ticket/7665) + this\_thread::sleep\_for no longer uses steady\_clock in thread + + [#7720](http://svn.boost.org/trac/boost/ticket/7720) + exception lock\_error while intensive locking/unlocking of mutex + + [#9309](http://svn.boost.org/trac/boost/ticket/9309) + test\_latch fails often on clang-darwin-tot11 + + [#10788](http://svn.boost.org/trac/boost/ticket/10788) + GetLogicalProcessor isn't available for Windows platform less or + equals to 0x0502 + + [#11090](http://svn.boost.org/trac/boost/ticket/11090) + ex\_future\_unwrap- ThreadSanitizer: lock-order-inversion (potential + deadlock) + + [#11158](http://svn.boost.org/trac/boost/ticket/11158) + Pthread thread deadlock when faketime used + + [#11174](http://svn.boost.org/trac/boost/ticket/11174) + boost::condition\_variable::timed\_wait with predicate unexpectedly + wakes up while should wait infinite + + [#11185](http://svn.boost.org/trac/boost/ticket/11185) + Incorrect URL redirection + + [#11192](http://svn.boost.org/trac/boost/ticket/11192) + boost::future<>::then() with an executor doesn't compile when + the callback returns a future + + [#11250](http://svn.boost.org/trac/boost/ticket/11250) + future made from make\_exceptional fails on assertion in destructor + + [#11256](http://svn.boost.org/trac/boost/ticket/11256) + future<>::is\_ready() == false in continuation function + + [#11261](http://svn.boost.org/trac/boost/ticket/11261) + bad use of scoped threads in basic\_thread\_pool + + [#11262](http://svn.boost.org/trac/boost/ticket/11262) + bad use of direct pointer in shared\_state\_nullary\_task + + [#11263](http://svn.boost.org/trac/boost/ticket/11263) + lock already locked lock + + [#11266](http://svn.boost.org/trac/boost/ticket/11266) + boost::packaged\_task has invalid variadic signature + + [#11302](http://svn.boost.org/trac/boost/ticket/11302) + boost thread doesn't build with BOOST\_THREAD\_PATCH. + + [#11322](http://svn.boost.org/trac/boost/ticket/11322) + sleep\_for() nanoseconds overload will always return too early on + windows + + [#11329](http://svn.boost.org/trac/boost/ticket/11329) + using declarative for GetProcessHeap, .... fails + + [#11368](http://svn.boost.org/trac/boost/ticket/11368) + boost thread's usage of CreateWaitableTimer wakes PC from sleep (doh) + + [#11377](http://svn.boost.org/trac/boost/ticket/11377) + Boost condition variable always waits for system clock deadline + + [#11435](http://svn.boost.org/trac/boost/ticket/11435) + gcc compiler warning in future.hpp + + [#11555](http://svn.boost.org/trac/boost/ticket/11555) + devector.hpp assumes allocator\_traits\_type is always present + + [#11562](http://svn.boost.org/trac/boost/ticket/11562) + Timer (using steady\_clock) expires after computer time is set forward + on Ubuntu 64-bit + + [#11672](http://svn.boost.org/trac/boost/ticket/11672) + Thread: Should use unique\_ptr, not auto\_ptr + + [#11688](http://svn.boost.org/trac/boost/ticket/11688) + thread::try\_join\_until: Avoid busy wait if system clock changes + + [#11716](http://svn.boost.org/trac/boost/ticket/11672) + ::then(f) should inherit the parent Executor +* [UUID](/libs/uuid/): + + + Added a workaround for MSVC codegen bug that could cause crashes + when comparing UUIDs. + + Added detection of AVX being enabled with MSVC compiler switches. + +### News +### Notes for + Windows users + This release of Boost will by default compile for Windows Vista/Windows Server + 2008, if the compiler supports a recent enough Windows SDK, and for Windows + XP otherwise. Binaries compiled with default options may not run on the older + Windows versions. + + It is still possible to explicitly specify target Windows version by defining + `BOOST\_USE\_WINAPI\_VERSION` + to a numeric version of Windows API. For example, building Boost for Windows + XP can be done with the following command: + +``` + b2 release define=BOOST\_USE\_WINAPI\_VERSION=0x0501 + +``` + + + The list of Windows API version numbers can be seen on [this](https://msdn.microsoft.com/en-us/library/6sehtctf.aspx) + page. + + This change only concerns libraries that use the common Windows API abstraction + layer. Currently, these libraries are: Boost.Chrono, Boost.Dll, Boost.Log, + Boost.UUID. This will also affect all dependent libraries. + + +### Release + of Hana postponed + Due to time constraints, the release of [Hana](https://github.com/boostorg/hana) + will be postponed to a later release of Boost. This will also allow some + known issues to be addressed properly before releasing the library officially + as a part of Boost. More information can be found on the [mailing + list](http://article.gmane.org/gmane.comp.lib.boost.devel/263964). + + +### Release + of Boost.DLL library postponed + In order to provide superior support of uncommon toolsets and platforms, + the release of Boost.DLL was postponed to a later release of Boost. This + also allows to test better a recently added ability to copy construct and + copy assign instances of `boost::dll::shared\_library` and provide examples on + importing functions with non default calling conventions. Latest version + and developer documentation of the library could be found at [GitHub + repo](https://github.com/boostorg/dll). + + + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.4, 3.6 + + Clang, C++14: 3.7 + + GCC: 4.4.7, 4.8.4, 4.9.3, 5.1.0, 5.2.1 + + GCC, C++11: 4.4.7 + + GCC, C++14: 4.9.3 +* Windows: + + + GCC, C++03, mingw: 3.4.5 + + GCC, C++11, mingw: 4.6.4, 4.7.3, 4.8.1 + + GCC, C++14, mingw: 4.9.3, 5.1.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0 +* Android: + + + Clang: 3.6, 3.7 + + GCC: 4.9.0, 5.2.0 +* QNX: + + + QCC: 4.4.2 +* SunOS: + + + Oracle Solaris Studio: 12.4, 12.5 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.1, 3.2, 3.3, 3.4.2, 3.6.0, 3.8.0 + + Clang, C++14: 3.7.0 + + GCC: 4.4.7, 4.5.3, 4.6.4, 4.7.3, 4.8.1, 4.9.3, 5.1.0, 6.0.0 + + GCC, C++11: 4.4.7 + + GCC, C++14: 4.9.3, 5.2.1 + + IBM XL C++: 13.1.2.0 + + Intel: 16.0 +* OS X: + + + Clang: 7.0.0 + + GCC: 5.2.0 +* Windows: + + + GCC, C++03, mingw: 3.4.5 + + GCC, C++11, mingw: 4.7.3, 4.8.1 + + GCC, C++14, mingw: 4.9.3, 5.1.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0 +* Android: + + + Clang: 3.6, 3.7 + + GCC: 4.9.0, 5.2.0 +* FreeBSD: + + + Clang, C++11: 3.4.1, 3.7.0 + + GCC, C++11: 4.8.5, 5.2.0, 6.0.0 +* QNX: + + + QCC: 4.4.2 +* SunOS: + + + Oracle Solaris Studio: 12.4, 12.5 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_61_0.html b/users/history/version_1_61_0.html new file mode 100644 index 0000000..64f9e04 --- /dev/null +++ b/users/history/version_1_61_0.html @@ -0,0 +1,423 @@ +--- +title: Version 1.61.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.61.0 + +/\*\*/ + + + + + + + +Version 1.61.0 +============== + +Version 1.61.0 +-------------- + + +May 13th, 2016 02:58 GMT + + +[Documentation](/doc/libs/1_61_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_61\_0.tar.bz2](https://sourceforge.net/projects/boost/files/boost/1.61.0/boost_1_61_0.tar.bz2) | a547bd06c2fd9a71ba1d169d9cf0339da7ebf4753849a8f7d6fdb8feee99b640 | +| [boost\_1\_61\_0.tar.gz](https://sourceforge.net/projects/boost/files/boost/1.61.0/boost_1_61_0.tar.gz) | a77c7cc660ec02704c6884fbb20c552d52d60a18f26573c9cee0788bf00ed7e6 | +| windows | [boost\_1\_61\_0.7z](https://sourceforge.net/projects/boost/files/boost/1.61.0/boost_1_61_0.7z) | fa1c34862b7ba8674ed6e064a14667a11830c6252f702d9458451834b74f7815 | +| [boost\_1\_61\_0.zip](https://sourceforge.net/projects/boost/files/boost/1.61.0/boost_1_61_0.zip) | 02d420e6908016d4ac74dfc712eec7d9616a7fc0da78b0a1b5b937536b2e01e8 | + +[List of checksums](/users/download/signatures/boost_1_61_0.sums.asc) signed by [Vladimir Prus](https://pgp.mit.edu/pks/lookup?op=get&search=0xDA472E8659753BA4) + + +### Third Party Downloads + + +* [Windows Binaries](https://sourceforge.net/projects/boost/files/boost-binaries/1.61.0) + + +### New Libraries + + +* [Compute](/libs/compute/): + Parallel/GPU-computing + library +* [DLL](/libs/dll/): + Library for comfortable work + with DLL and DSO. Library provides a portable across platforms way to: + + + load libraries + + import any native functions and variables + + make alias names for C++ mangled functions and symbols + + query libraries for sections and exported symbols + + self loading and self querying + + getting program and module location by exported symbol +* [Hana](/libs/hana/): + A modern C++ metaprogramming + library. It provides high level algorithms to manipulate heterogeneous + sequences, allows writing type-level computations with a natural syntax, + provides tools to introspect user-defined types and much more. +* [Metaparse](/libs/metaparse/): + A library for generating + compile time parsers parsing embedded DSL code as part of the C++ compilation + process. The library is similar to Spirit, however while parsers built + with Spirit parse at run-time, parsers built with Metaparse parse at compile-time. + +### Updated Libraries + + +* [Any](/libs/any/): + + + More tests and maintainance fixes. +* [Container](/libs/container/): + + + `small\_vector` supports + more constructors and assignments. + + Fixed bugs: + + - [Trac + #11820 : *"compiler error when using operator[] + of map"*](https://svn.boost.org/trac/boost/ticket/11820). + - [Trac + #11856 : *"pool\_resource.cpp error: declaration + changes meaning"*](https://svn.boost.org/trac/boost/ticket/11856). + - [Trac + #11866 : *"small\_vector does not have range constructor"*](https://svn.boost.org/trac/boost/ticket/11866). + - [Trac + #11867 : *"small\_vector should have constructor + and assignment operator taking other small\_vector"*](https://svn.boost.org/trac/boost/ticket/11867). + - [Trac + #11912 : *"flat\_map use of vector::priv\_forward\_range\_insert\_expand\_backwards + may cause move with same source"*](https://svn.boost.org/trac/boost/ticket/11912). + - [Trac + #11957 : *"static\_vector::max\_size() is higher + than the capacity"*](https://svn.boost.org/trac/boost/ticket/11957). + - [Trac + #12014 : *"boost::container::set can not insert + const (ref) range"*](https://svn.boost.org/trac/boost/ticket/12014). + - [GitHub + #33: *Make sure std::string constructor is available*](https://github.com/boostorg/container/pull/33). +* [Context](/libs/context/): + + + [#11246](https://svn.boost.org/trac/boost/ticket/11246) fails to build for mingw because of undefined symbols + + [#11365](https://svn.boost.org/trac/boost/ticket/11365) execution\_context.hpp gives errors when building with + VS2015RC + + [#11652](https://svn.boost.org/trac/boost/ticket/11652) checking \_\_cpp\_lib\_integer\_sequence + + [#11946](https://svn.boost.org/trac/boost/ticket/11946) crashes on x86\_64/MinGW + + fcontext\_t: no longer part of public API + + support for WinFiber API removed + + execution\_context: relaxed to C++11 + + execution\_context: type-safe transfer of data + + execution\_context: execute function on top of stack + + execution\_context: improved performance + + execution\_context: static member-fn `current()` removed + + execution\_context: new call semantic +* [Coroutine](/libs/coroutine/): + + + attribute related to FPU-env removed +* [Coroutine2](/libs/coroutine2/): + + + attribute related to FPU-env removed + + improved performance + + relaxed to C++11 +* [Fusion](/libs/fusion/): + + + Mitigate massive warnings about use of `BOOST\_PP\_IS\_EMPTY` + on MSVC8. [#11157](https://svn.boost.org/trac/boost/ticket/11157) + + Container's conversion ctor and SFINAE. [#11766](https://svn.boost.org/trac/boost/ticket/11766) + + Drop trailing `fusion::void\_` + support from C++11 `fusion::vector`. + [pull-request + 120](https://github.com/boostorg/fusion/pull/120) + + Workarounds for GCC 4.0 and 4.1 ICE. [#5808](https://svn.boost.org/trac/boost/ticket/5808) [#7229](https://svn.boost.org/trac/boost/ticket/7229) + + Workaround for ambiguous call of `fusion::convert` + on GCC 3.4. [pull-request + 130](https://github.com/boostorg/fusion/pull/130) +* [Geometry](/libs/geometry): + + + *Additional functionality:* + + - Support within and covered\_by for Box/Box in spherical and + geographic coordinate systems. + + *Improvements:* + + - Overlay: handle\_tangencies replaced by clusters, fixing many + cases with colocated turns + + *Solved tickets:* + + - [#9162](https://svn.boost.org/trac/boost/ticket/9162) + Invalid result of relational operations for non-cartesian Point/Areal. + - [#10866](https://svn.boost.org/trac/boost/ticket/10866) + union\_ doesn't work in 1.56 and 1.57. + - [#11018](https://svn.boost.org/trac/boost/ticket/11018) + Invalid geometry intersection + - [#11576](https://svn.boost.org/trac/boost/ticket/11576) + Intersection gives wrong results. + - [#11637](https://svn.boost.org/trac/boost/ticket/11637) + Unused parameter warning. + - [#11725](https://svn.boost.org/trac/boost/ticket/11725) + union\_ fails to create holes + - [#11789](https://svn.boost.org/trac/boost/ticket/11789) + Assertion failure or invalid result of set operations for spherical\_equatorial + coordinate system. + - [#11917](https://svn.boost.org/trac/boost/ticket/11917) + Andoyer distance strategy returns 0 for antipodal points (default + geographic distance). + - [#11928](https://svn.boost.org/trac/boost/ticket/11928) + Improvement of the accuracy of surveyor area strategy. + - [#11966](https://svn.boost.org/trac/boost/ticket/11966) + Compilation error in svg() for box and non-int coordinate type. + - [#11984](https://svn.boost.org/trac/boost/ticket/11984) + union\_() generates self-intersecting polygon + - [#11987](https://svn.boost.org/trac/boost/ticket/11987) + rtree::remove() not compiling for geographic CS. + - [#12000](https://svn.boost.org/trac/boost/ticket/12000) + Uninitialized reference in (unused) constructor of relate's + mask\_handler. + - [#12106](https://svn.boost.org/trac/boost/ticket/12106) + Invalid assertion failure in envelope() for non-cartesian very + short segments. + + *Bugfixes:* + + - Fix intersects and disjoint for Segment/Box in cartesian coordinate + system when Segment is parallel to Box's face. + - Fix relation operations for Point/Areal in spherical and geographic + coordinate systems for edge cases. + - Fix intersects and disjoint for Point/Box and Box/Box in spherical + and geographic coordinate systems for some cases. + - Fix within and covered\_by for Point/Box in spherical and geographic + coordinate systems for some cases. +* [Interprocess](/libs/interprocess/): + + + Fixed bugs: + + - [GitHub + Pull #23 (*"Fixed case sensetive for linux mingw"*)](https://github.com/boostorg/interprocess/pull/23). +* [Intrusive](/libs/intrusive/): + + + Fixed bugs: + + - [Boost + Trac #11832: *clang-cl + boost intrusive = miscompile*](https://svn.boost.org/trac/boost/ticket/11832) + - [Boost + Trac #11865: *Intrusive list explicit ctor error with + Clang 3.6 (C++11/14)*](https://svn.boost.org/trac/boost/ticket/11865) + - [Boost + Trac #11992: *Add an overload of insert\_check taking + a key\_type*](https://svn.boost.org/trac/boost/ticket/11992) + - [GitHub + Pull #19: *ebo\_functor\_holder: compile fix for copy + constructor*](https://github.com/boostorg/intrusive/pull/19) +* [Lexical Cast](/libs/lexical_cast/): + + + Fixed Sun Studio related issues +* [Log](/libs/log/): + + + General changes: + + - The support for `boost::basic\_string\_ref` + and its specializations is deprecated; users are encouraged + to switch to `boost::basic\_string\_view`. + The support for `boost::basic\_string\_ref` + will be removed in future releases. + - Added support for limiting the number of stored log files in + the target directory of the file collector. Thanks to Erich + Keane for the patch. ([#8746](https://svn.boost.org/trac/boost/ticket/8746)) + + Bug fixes: + + - Fixed various compilation problems for Windows CE. + - Fixed compilation problems on Solaris. + - Added a workaround for MSVC-10 generating broken code for formatters + in some cases. ([#12025](https://svn.boost.org/trac/boost/ticket/12025)) + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Math](/libs/math/): + + + Polynomial arithmetic added to tools. +* [Move](/libs/move/): + + + Experimental: asymptotically optimal bufferless merge and sort algorithms: + adaptive\_merge and adaptive\_sort. + + Fixed bug: + + - [Trac + #11758: *"BOOST\_MOVABLE\_BUT\_NOT\_COPYABLE doesn't + reset private access with rvalue ref version"*](https://svn.boost.org/trac/boost/ticket/11758). +* [Multiprecision](/libs/multiprecision/): + + + Fixed bug in stream input for integer types, see [#11857](https://svn.boost.org/trac/boost/ticket/11857). + + Fixed some ambiguous conversions involving expression templates see + [#11922](https://svn.boost.org/trac/boost/ticket/11922). + + Add expression template aware min/max overloads see [#11149](https://svn.boost.org/trac/boost/ticket/11149). + + Fix bug in right shifting negative small integers in cpp\_int see + [#11999](https://svn.boost.org/trac/boost/ticket/11999). + + Use memmove for bitshifts in cpp\_int when possible see [#9233](https://svn.boost.org/trac/boost/ticket/9233). + + Use memcpy for data import into cpp\_int where possible, see [#9235](https://svn.boost.org/trac/boost/ticket/9235). + + Changed `cpp\_bin\_float.convert\_to()` to a function template rather + than proceding via `long double` to avoid double-rounding bug, + see [#12039](https://svn.boost.org/trac/boost/ticket/12039). + + Fixed conversions from NaN's and Infinities, see [#12112](https://svn.boost.org/trac/boost/ticket/12112). + + Enabled better support for Clang on Windows. + + Fixed handling of NaN's and Infinities in basic arithmetic for cpp\_dec\_float + and cpp\_bin\_float, see [#12090](https://svn.boost.org/trac/boost/ticket/12090). + + Fixed fencepost error in cpp\_bin\_float subtraction. + + Fixed double-rounding in conversion to float routines for cpp\_bin\_float, + see [#12039](https://svn.boost.org/trac/boost/ticket/12039). + + Make float128 denorm aware, see [#12075](https://svn.boost.org/trac/boost/ticket/12075). + + Allow the library and tests to be used without exception handling + support, see [#12070](https://svn.boost.org/trac/boost/ticket/12070). + + Fixed buggy comparison operator overloads for boost::rational. + + Added some workarounds for Oracle C++. + + Fixed some missing typecasts for cases where cpp\_int's limb\_type + is wider than unsigned. +* [Optional](/libs/optional/): + + + Now `boost::optional` is specialized for reference + parameters. This addresses a couple of issues: + + - the `sizeof` of + optional reference is that of a pointer, + - some bugs connected to copying optional references are gone, + - all run-time bugs caused by incorrect reference binding on + some compilers are now turned into compile-time errors, + - you can swap optional references: it is like swapping pointers: + shalow, underlying objects are not affected, + - optional references to abstract types work. + + Documented nested typedefs ([Trac + #5193](https://svn.boost.org/trac/boost/ticket/5193)). + + Made the perfect-forwarding constructor SFINAE-friendly, which fixes + [Trac #12002](https://svn.boost.org/trac/boost/ticket/12002). + However, this only works in the newer platforms that correctly implement + C++11 ``. + + Fixed [Trac + #10445](https://svn.boost.org/trac/boost/ticket/10445). +* [Regex](/libs/regex/): + + + Change to lockfree implementation of memory cache, see [PR#23](https://github.com/boostorg/regex/pull/23). +* [Test](/libs/test/): + + + Boost.test v3.2 see the '[Change + log](/doc/libs/1_61_0/libs/test/doc/html/boost_test/change_log.html)' section for details. + + New features + + - dataset driven test-cases learned to support fixtures and variadic + number of arguments + - dataset driven test-cases sample types now honor move semantics + + Bug fixes + + - [#6767](https://svn.boost.org/trac/boost/ticket/6767), [#8905](https://svn.boost.org/trac/boost/ticket/8905), [#9443](https://svn.boost.org/trac/boost/ticket/9443), [#11854](https://svn.boost.org/trac/boost/ticket/11854) + - [#11887](https://svn.boost.org/trac/boost/ticket/11887), [#11889](https://svn.boost.org/trac/boost/ticket/11889), [#11983](https://svn.boost.org/trac/boost/ticket/11983) +* [Variant](/libs/variant/): + + + Maintainance fixes. + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7.1 + + Clang, C++14: 3.7.1, 3.8.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.7.3, 4.8.4, 4.8.5, 4.9.3, 5.3.0 + + GCC, C++11: 4.4.7 + + GCC, C++14: 5.2.1, 5.3.1 + + Intel: 16.0 +* Windows: + + + GCC, C++03, mingw: 3.4.5 + + GCC, C++11, mingw: 4.6.4, 4.7.3, 4.8.1 + + GCC, C++14, mingw: 4.9.3, 5.1, 5.2 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0 +* Android: + + + Clang: 3.6, 3.7 + + GCC: 4.9, 5.3 +* FreeBSD: + + + Clang: 3.4.1, 3.7 + + GCC: 4.8.5, 5.3 +* Haiku: + + + GCC, C++11: 4.8.5 +* QNX: + + + QCC: 4.4.2 +* SunOS: + + + Oracle Solaris Studio: 12.4, 12.5 + + Oracle Solaris Studio, C++11: 12.5 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7.1 + + Clang, c++14: 3.7.1, 3.8.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.7.3, 4.8.5, 4.9.3, 5.3.0, 5.3.1, 6.0.0 + + GCC, C++11: 4.4.7 + + GCC, C++14: 5.2.1 + + Intel: 16.0 +* OS X: + + + Apple Clang: 7.0.2 + + G++: 5.3.0 +* Windows: + + + GCC, C++03, mingw: 3.4.5 + + GCC, C++11, mingw: 4.6.4, 4.7.3, 4.8.1 + + GCC, C++14, mingw: 4.9.3, 5.1, 5.2 + + GCC, cygwin: 5.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0 +* Android: + + + Clang: 3.6, 3.7 + + GCC: 4.9, 5.3, 6.0 +* FreeBSD: + + + Clang: 3.41, 3.7.0 + + GCC, C++11: 4.8.5, 5.3.0, 6.0 + + GCC: 6.0 +* Haiku: + + + GCC, C++11: 4.8.5 +* QNX: + + + QCC: 4.4.2 +* SunOS: + + + Oracle Solaris Studio: 12.4, 12.5 + + Oracle Solaris Studio, C++11: 12.5 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_62_0.html b/users/history/version_1_62_0.html new file mode 100644 index 0000000..6fe2447 --- /dev/null +++ b/users/history/version_1_62_0.html @@ -0,0 +1,440 @@ +--- +title: Version 1.62.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.62.0 + +/\*\*/ + + + + + + + +Version 1.62.0 +============== + +Version 1.62.0 +-------------- + + +September 28th, 2016 15:17 GMT + + +[Documentation](/doc/libs/1_62_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_62\_0.tar.bz2](https://sourceforge.net/projects/boost/files/boost/1.62.0/boost_1_62_0.tar.bz2) | 36c96b0f6155c98404091d8ceb48319a28279ca0333fba1ad8611eb90afb2ca0 | +| [boost\_1\_62\_0.tar.gz](https://sourceforge.net/projects/boost/files/boost/1.62.0/boost_1_62_0.tar.gz) | 440a59f8bc4023dbe6285c9998b0f7fa288468b889746b1ef00e8b36c559dce1 | +| windows | [boost\_1\_62\_0.7z](https://sourceforge.net/projects/boost/files/boost/1.62.0/boost_1_62_0.7z) | b91c2cda8bee73ea613130e19e72c9589e9ef0357c4c5cc5f7523de82cce11f7 | +| [boost\_1\_62\_0.zip](https://sourceforge.net/projects/boost/files/boost/1.62.0/boost_1_62_0.zip) | 084b2e0638bbe0975a9e43e21bc9ceae33ef11377aecab3268a57cf41e405d4e | + + +### Third Party Downloads + + +* [Windows Binaries](https://sourceforge.net/projects/boost/files/boost-binaries/1.62.0/) + + +### New Libraries + + +* [Fiber](/libs/fiber/): + Framework for userland-threads/fibers, + from Oliver Kowalke. +* [QVM](/libs/qvm/doc/index.html): + Boost QVM is a + generic library for working with quaternions, vectors and matrices of static + size with the emphasis on 2, 3 and 4-dimensional operations needed in graphics, + video games and simulation applications, from Emil Dotchevski. + +### Updated Libraries + + +* [Atomic](/libs/atomic/): + + + Improved support for Oracle Studio and SPARC. The library now provides + native atomic operations on SPARCv8+. +* [Chrono](/libs/chrono/): + + + [#11330](http://svn.boost.org/trac/boost/ticket/11330) + boost::chrono::duration default constructor doesn't initialize rep\_ + + [#11618](http://svn.boost.org/trac/boost/ticket/11618) + Chrono IO V2 doc ios\_state.hpp does not exist + + [#11631](http://svn.boost.org/trac/boost/ticket/11631) + boost chrono io v2 does not let you support custom clocks +* [Circular Buffer](/libs/circular_buffer/): + + + Debug implementation is no longer used by default in debug mode. + Debug implementation does not have the same thread safety guarantees + as the normal (release) implementation or other containers. As a + result of this change `BOOST\_CB\_DISABLE\_DEBUG` + macro is no longer used. `BOOST\_CB\_ENABLE\_DEBUG=1` + should be defined instead to enable debug support. ([#6277](https://svn.boost.org/trac/boost/ticket/6277)) +* [Container](/libs/container/): + + + Fixed bugs: + + - [Trac + #9481: *"Minor comment typo in Boost.Container"*](https://svn.boost.org/trac/boost/ticket/9481). + - [Trac + #9689: *"Add piecewise\_construct to boost::container"*](https://svn.boost.org/trac/boost/ticket/9689). + - [Trac + #11170: *"Doc slip for index\_of"*](https://svn.boost.org/trac/boost/ticket/11170). + - [Trac + #11802: *"Incorrect ordering after using insert() + with ordered\_range\_t on a flat\_multiset with a non-default + sort order"*](https://svn.boost.org/trac/boost/ticket/11802). + - [Trac + #12117: *"flat\_set constructor with ordered\_unique\_range"*](https://svn.boost.org/trac/boost/ticket/12117). + - [Trac + #12177: *"vector::priv\_merge uses unqualified + uintptr\_t"*](https://svn.boost.org/trac/boost/ticket/12177). + - [Trac + #12183: *"GCC 6.1 thinks boost::container::string + violates strict aliasing"*](https://svn.boost.org/trac/boost/ticket/12183). + - [Trac + #12256: *"set>::insert + cause compilation error in debug configuration in Visual Studio + 2012"*](https://svn.boost.org/trac/boost/ticket/12256). + - [Trac + #12273: *"static\_vector max\_size() and capacity() + should be constant expressions"*](https://svn.boost.org/trac/boost/ticket/12273). Added + constant `static\_vector<>::static\_capacity` + to use the configured capacity in constant expressions. + - [Trac + #12286: *"PMR flat\_map from Boost Container does + not compile"*](https://svn.boost.org/trac/boost/ticket/12286). + - [Trac + #12296: *"{deque,string} combine for a memory + leak"*](https://svn.boost.org/trac/boost/ticket/12296). + - [Trac + #12319: *"`flat\_set` + should be nothrow move constructible"*](https://svn.boost.org/trac/boost/ticket/12319). + + Revised noexcept expressions of default and move constructors in + all containers. + + Implemented C++17 `insert\_or\_assign`/`try\_emplace` for `map` + and `flat_map`. + + Implemented C++17 `extract`/`insert(node)` + for `map`, `multimap`, `set`, `multiset`. +* [Context](/libs/context/): + + + [#12215](https://svn.boost.org/trac/boost/ticket/12215) all stack corrupted on Windows using default fixedsize\_stack + + [#12242](https://svn.boost.org/trac/boost/ticket/12242) build issue with Intel C++ compiler for MacOS + + fix stack unwinding for execution\_context\_v1 +* [Coroutine](/libs/coroutine/): + + + deprecated in favour of Coroutine2 +* [Coroutine2](/libs/coroutine2/): + + + [#12221](https://svn.boost.org/trac/boost/ticket/12221) coroutine<>::push\_type function starts without pushing + + do not swallow exceptions thrown at coroutine<>::push\_type + construction +* [DLL](/libs/dll/): + + + Mangled symbols and classes loading was implemented by Klemens Morgenstern + + Suppress a 'unused parameter' warning in detail::aggressive\_ptr\_cast + [pull-request + 9](https://github.com/apolukhin/Boost.DLL/pull/9) + + Allowed to query non-existant sections [pull-request + 32](https://github.com/apolukhin/Boost.DLL/pull/32) + + More tests and docs +* [Functional/Forward](/libs/functional/forward/): + + + Fix C++11 compile error. +* [Geometry](/libs/geometry): + + + *Improvements:* + + - Union: take care that output is valid (with some exceptions), + also with self-tangent polygons or shared edges + - SVG: support boost::variant of geometries + - SVG: coordinates are now written as double (by default) to + svg + - Rename namespace concept to concepts to avoid conflicts with + the newest compilers + - New spherical intersection strategy used in relational and + set operations for spherical and geographic Geometries (previously + cartesian intersection strategy was used for all coordinate + systems). + + *Solved tickets:* + + - [#12189](https://svn.boost.org/trac/boost/ticket/12189) + Relational operations not compiling when point types of inputs + are different + - [#12287](https://svn.boost.org/trac/boost/ticket/12287) + Invalid result of rtree.query() for contains() predicate +* [Interprocess](/libs/interprocess/): + + + Fixed bug [GitHub + Pull #27 (*"Fix undefined behavior"*)](https://github.com/boostorg/interprocess/pull/27). +* [Intrusive](/libs/intrusive/): + + + Fixed bugs: + + - [Boost + Trac #11476: *has\_member\_function\_callable\_with.hpp + is massively broken with BOOST\_NO\_CXX11\_DECLTYPE*](https://svn.boost.org/trac/boost/ticket/11476) + - [Boost + Trac #11994: *Support intrusive container key extractors + that return the key by value*](https://svn.boost.org/trac/boost/ticket/11994) + - [Boost + Trac #12184: *clang -Wdocumentation warning*](https://svn.boost.org/trac/boost/ticket/12184) + - [Boost + Trac #12190: *Intrusive List + Flat Map combination + crashes*](https://svn.boost.org/trac/boost/ticket/12190) + - [Boost + Trac #12229: *intrusive::unordered\_set::rehash() + broken*](https://svn.boost.org/trac/boost/ticket/12229) + - [Boost + Trac #12245: *bstree uses a shared static size\_traits + for constant\_time\_size*](https://svn.boost.org/trac/boost/ticket/12245) +* [Lexical Cast](/libs/lexical_cast/): + + + Fix incorrect static assertion [#11759](https://svn.boost.org/trac/boost/ticket/11759) +* [Log](/libs/log/): + + + New features: + + - Added new tools for inter-process logging on a local machine. + The implementation includes a resource name wrapper, an inter-process + message queue and a sink backend. + - Added a new character decorator called `max\_size\_decor`. + The new decorator allows to limit the output of its adopted + formatter up to the specified length. + + Bug fixes: + + - Fixed that logging streams could retain formatting settings + across different log records. ([#12178](https://svn.boost.org/trac/boost/ticket/12178)) + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Math](/libs/math/): + + + New Features: + + - Enabled all the special function code to work correctly with + types whose precision can change at runtime: for example type + `mpfr\_float` + from Boost.Multiprecision. + + Patches: + + - Fix `tgamma\_delta\_ratio` + for cases where the delta is small compared to the base. + - Fix misc GCC-4.4 test failures. +* [Optional](/libs/optional/): + + + Fixed [Trac + #12179](https://svn.boost.org/trac/boost/ticket/12179). +* [Phoenix](/libs/phoenix/): + + + Fix compilation for MSVC 10. [pull-request + 18](https://github.com/boostorg/phoenix/pull/18) + + Remove unused preprocessed files. [pull-request + 28](https://github.com/boostorg/phoenix/pull/28) + + Fix erroneous doc for switch\_ statement. [#8156](https://svn.boost.org/trac/boost/ticket/8156) + + Cleanup config unordered. [pull-request + 33](https://github.com/boostorg/phoenix/pull/33) + + Suppress unused placeholder warnings. + + Fix too few arguments error on binary math functions. +* [Regex](/libs/regex/): + + + Fix buffer over-run error when parsing certain invalid regexes, see + [#12222](https://svn.boost.org/trac/boost/ticket/12222). + + Fix detection of ICU in library build, see [#12152](https://svn.boost.org/trac/boost/ticket/12152). + + Fix bug in case sensitivity change, see [#11940](https://svn.boost.org/trac/boost/ticket/11940). + + Allow types wider than int in `\x{}` + expressions (for char32\_t etc), see [#11988](https://svn.boost.org/trac/boost/ticket/11988). +* [Test](/libs/test/): + + + Boost.test v3.3 see the [Change + log](/doc/libs/1_62_0/libs/test/doc/html/boost_test/change_log.html) section for more details. + + New features + + - dataset driven test-cases have now a unique name and all sample + tests of a dataset live inside the same test suite + - Boost.test learned a new command line switch, `--logger` + for setting a test logger as well as its parameter in one command + - Boost.test learned to have several loggers at the same time, + each of which having their own log level and output stream + - Boost.test learned a new logger, `JUNIT`, + that is able to output Junit/xUnit compatible streams + - It is now possible to specify several test filters through + the environment variable `BOOST\_TEST\_RUN\_FILTERS` + + Bug fixes + + - Trac tickets [#8707](https://svn.boost.org/trac/boost/ticket/8707), [#8834](https://svn.boost.org/trac/boost/ticket/8834), [#11128](https://svn.boost.org/trac/boost/ticket/11128), [#11845](https://svn.boost.org/trac/boost/ticket/11845), + [#11859](https://svn.boost.org/trac/boost/ticket/11859), [#12024](https://svn.boost.org/trac/boost/ticket/12024), + - Trac tickets [#12093](https://svn.boost.org/trac/boost/ticket/12093), [#12103](https://svn.boost.org/trac/boost/ticket/12103), [#12224](https://svn.boost.org/trac/boost/ticket/12224), [#12241](https://svn.boost.org/trac/boost/ticket/12241), + [#12257](https://svn.boost.org/trac/boost/ticket/12257), [#12378](https://svn.boost.org/trac/boost/ticket/12378) + - Pull request [PR81](https://github.com/boostorg/test/pull/81) +* [Thread](/libs/thread/): + + + [#12102](http://svn.boost.org/trac/boost/ticket/12102) + condition\_variable\_fwd.hpp fails to compile when BOOST\_THREAD\_PROVIDES\_INTERRUPTIONS + is disabled + + [#12120](http://svn.boost.org/trac/boost/ticket/12120) + Performance improvement in thread/barrier.hpp + + [#12146](http://svn.boost.org/trac/boost/ticket/12146) + make\_exceptional\_future is not mentioned in the docs + + [#12202](http://svn.boost.org/trac/boost/ticket/12202) + shared\_lock should be in shared\_mutex header + + [#12371](http://svn.boost.org/trac/boost/ticket/12371) + boost thread/future.hpp fails to build + + #88 fix typos in boost::upgrade\_lock + + #89 fix a bug in upgrade\_to\_unique\_lock<>::operator=() + + #90 fix a bug in try\_lock\_wrapper<>::operator=() + + #91 Add shared\_lock\_guard to the included lock types + + #92 Fixed compilation with MSVC-8. + + #93 Fix variable shadowing warnings (Clang) + + #94 fix bugs in boost::barrier + + #95 fix a mistake in boost::completion\_latch + + #96 rename async\_func.hpp to invoker.hpp. + + #97 fix a mistake in sync\_timed\_queue<>::pull\_until() +* [TypeIndex](/libs/type_index/): + + + `ctti\_type\_index` was + made constexpr in C++14. Now it is possible to retrieve actual name + of the type as `const char\*` + at compile time. So we can do a lot of interesting things at **compile time**: check namespace of a type, sort + types according to their lexical representation, check that type + is a template type and so on... A few examples were provided. + + Fixed issue with `noexcept` + on MSVC in type names and issue with space in type name (pulled from + klemens-morgenstern/develop) + + Fixed typos [pull-request + 7](https://github.com/boostorg/type_index/pull/7) + + Improved CI testing +* [Unordered](/libs/unordered/): + + + Remove use of deprecated `boost::iterator`. + + Fixed an exception safety issue in assignment of `unordered\_multiset` + and `unordered\_multimap`. + + See the [changelog](/doc/html/unordered/changes.html) + for more details. +* [Variant](/libs/variant/): + + + Fixed variant construction from classes derived from variant [#7120](https://svn.boost.org/trac/boost/ticket/7120), + [#10278](https://svn.boost.org/trac/boost/ticket/10278), [#12155](https://svn.boost.org/trac/boost/ticket/12155) + + Variant constructors and assignment operators now do not participate + in overload resolutions if variant can not hold the input type [#5871](https://svn.boost.org/trac/boost/ticket/5871), + [#11602](https://svn.boost.org/trac/boost/ticket/11602) + + Fixed the issue with implicit conversion operator in C++11 [#8555](https://svn.boost.org/trac/boost/ticket/8555) + + Fixed comparisons when variant holds non-const reference [#11751](https://svn.boost.org/trac/boost/ticket/11751) + + Fixed noexcept for variant's move-assignment [#11696](https://svn.boost.org/trac/boost/ticket/11696) + + Fixed double quotes in includes [#12057](https://svn.boost.org/trac/boost/ticket/12057) + + Dropped BOOST\_VARIANT\_NO\_REFERENCE\_SUPPORT macro and dropped support + for compilers without SFINAE [#12250](https://svn.boost.org/trac/boost/ticket/12250) + + Suppress implicit instantiation of MPL end iterator + + Multiple minor fixes (typos, missing includes) + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 3.8.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 3.8.0 + + Clang, C++14: 3.5, 3.6, 3.7, 3.8.0, 3.8.1, 3.9.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.7.2, 5.2.0, 6.1.1 + + GCC, C++11: 4.4.7, 4.7.2, 4.7.3, 4.8.5, 4.9.3, 5.2.0, 6.1.1 + + GCC, C++14: 5.2.0, 5.3.0, 5.4.1, 6.1.1 + + Intel: 16.0 + + Intel, C++11: 16.0 + + Intel, C++14: 16.0 +* Windows: + + + GCC, C++03, mingw: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0 + + GCC, C++11, mingw: 4.6.4, 4.7.3, 4.8.1 + + GCC, C++14, mingw: 6.1.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0 +* Android: + + + Clang: 3.6, 3.7, 3.8 + + GCC: 4.9, 5.4, 6.1 +* FreeBSD: + + + Clang: 3.4.1, 3.7 + + GCC: 4.8.5, 5.4.0, 6.1.1 +* QNX: + + + QCC: 4.4.2 +* SunOS: + + + Oracle Solaris Studio: 12.5 + + Oracle Solaris Studio, C++11: 12.5 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.8 + + Clang, c++11: 3.0, 3.1, 3.2, 3.3, 3.4, 3.8 + + Clang, c++14: 3.5, 3.6, 3.7, 3.8, 3.9 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.7.2, 4.8.4, 5.2.0, 6.1.1 + + GCC, C++11: 4.4.7, 4.7.2, 4.7.3, 4.8.5, 4.9.3, 5.2.0, 6.1.1 + + GCC, C++14: 5.2.0, 5.3.0, 5.4.1, 6.1.1, 7.0.0 (experimental) + + Intel: 16.0 + + Intel, C++11: 16.0 + + Intel, C++14: 16.0 +* OS X: + + + Apple Clang: 7.3.0 + + G++: 6.1.0 +* Windows: + + + Clang: 3.8.1 + + GCC, C++03, mingw: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0 + + GCC, C++11, mingw: 4.6.4, 4.7.3, 4.8.1 + + GCC, C++14, mingw: 4.9.3, 5.1.0, 5.2.0, 5.3.0, 6.1.0 + + GCC, cygwin: 5.4.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0 +* Android: + + + Clang: 3.6, 3.7, 3.8 + + GCC: 4.9, 5.4, 6.1 +* FreeBSD: + + + Clang, C++11: 3.4.1, 3.7.0 + + GCC, C++11: 4.8.5. 5.4.0, 6.1.1 +* Haiku: + + + GCC, C++11: 5.4.0 +* QNX: + + + QCC: 4.4.2 +* SunOS: + + + Oracle Solaris Studio: 12.5 + + Oracle Solaris Studio, C++11: 12.5 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_63_0.html b/users/history/version_1_63_0.html new file mode 100644 index 0000000..ffef18b --- /dev/null +++ b/users/history/version_1_63_0.html @@ -0,0 +1,347 @@ +--- +title: Version 1.63.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.63.0 + +/\*\*/ + + + + + + + +Version 1.63.0 +============== + +Version 1.63.0 +-------------- + + +December 26th, 2016 23:43 GMT + + +[Documentation](/doc/libs/1_63_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_63\_0.tar.bz2](https://sourceforge.net/projects/boost/files/boost/1.63.0/boost_1_63_0.tar.bz2) | beae2529f759f6b3bf3f4969a19c2e9d6f0c503edcb2de4a61d1428519fcb3b0 | +| [boost\_1\_63\_0.tar.gz](https://sourceforge.net/projects/boost/files/boost/1.63.0/boost_1_63_0.tar.gz) | fe34a4e119798e10b8cc9e565b3b0284e9fd3977ec8a1b19586ad1dec397088b | +| windows | [boost\_1\_63\_0.7z](https://sourceforge.net/projects/boost/files/boost/1.63.0/boost_1_63_0.7z) | 25db3956a8d58187ac7a0702cc917e9bab47ff90baafc35e4e789dca1ce5f423 | +| [boost\_1\_63\_0.zip](https://sourceforge.net/projects/boost/files/boost/1.63.0/boost_1_63_0.zip) | 97ce6635df1f44653a597343cd5757bb8b6b992beb3720f5fc761e3644bcbe7b | + + +### Third Party Downloads + + +* [Windows Binaries](https://boostorg.jfrog.io/artifactory/main/release/1.63.0/binaries/) + + +### Post-release Patches + + +* [Atomic](/libs/atomic/): + + + Using 64-bit atomic operations on 32-bit x86 with gcc versions older + than 4.7 and compatible compilers can result in generation of incorrect + code. This problem is fixed in [this](https://github.com/boostorg/atomic/commit/a67cc1b055cf09f371e2eca544884634a1ccc886) + commit. + +### Updated Libraries + + +* [Atomic](/libs/atomic/): + + + Added the static constant `atomic::is\_always\_lock\_free` + for conformance with C++17. The constant indicates that the given + specialization always provides lock-free implementation of atomic + operations. + + Improved support of Oracle Studio on x86 targets. +* [Container](/libs/container/): + + + Fixed bugs: + + - [Trac + #12534: *"flat\_map fails to compile if included + after type\_traits is instantiated under gcc"*](https://svn.boost.org/trac/boost/ticket/12534). + - [Trac + #12577: *"Null reference in pair.hpp triggers + runtime warning with -fsanitize=undefined"*](https://svn.boost.org/trac/boost/ticket/12577). + - [GitHub + #40: *Fix parameter types in copy\_move\_algo.hpp: iterator\_traits::difference\_type + -> allocator\_traits::size\_type*](https://github.com/boostorg/container/pull/40). + - [GitHub + #41: *Avoid -Wunreachable-code in do\_allocate()*](https://github.com/boostorg/container/pull/41). +* [Context](/libs/context/): + + + [#11687](https://svn.boost.org/trac/boost/ticket/11687) Xcode (Apple clang) and thread\_local + + [#12114](https://svn.boost.org/trac/boost/ticket/12114) context does not preserve fpu context on ios arm64 devices + (fixed for other architecturs too) + + [#12411](https://svn.boost.org/trac/boost/ticket/12411) fpu registers not preserved with O2 optimizations in Visual + Studio (fixed for other architecturs too) + + [#12551](https://svn.boost.org/trac/boost/ticket/12551) building boost on arm64 causes error: unknown directive + + reduced signatur for ontop-functions + + unit-test for private fcontext-API + + performance-test for ucontext and fcontext fixed +* [Fiber](/libs/fiber/): + + + unbounded\_channel and bounded\_channel marked as deprecated + + new classes buffered\_channel and unbuffered\_channel + + performance improved +* [Fusion](/libs/fusion/): + + + Fixed `fusion::vector` buggy constructors (Thanks + to Lee Clagett). + + `BOOST\_FUSION\_ADAPT\*` and `BOOST\_FUSION\_DEFINE\*` now allow empty structures. ([#6592](https://svn.boost.org/trac/boost/ticket/6592)) + + `BOOST\_FUSION\_DEFINE\*` allows move constructor and assignment. + ([#10099](https://svn.boost.org/trac/boost/ticket/10099)) + + Adaptor for `std::array` (Thanks to Mateusz Łoskot). + ([#8241](https://svn.boost.org/trac/boost/ticket/8241)) + + Fixed returning temporary variable warnings on MSVC. +* [Geometry](/libs/geometry): + + + *Improvements:* + + - Intersection: take care that output is valid (work in progres, + not yet finished - but more is valid) + + *Solved tickets:* + + - [#12289](https://svn.boost.org/trac/boost/ticket/12289) + Avoid warning/compilation error for std::cout + - [#12412](https://svn.boost.org/trac/boost/ticket/12412) + Invalid result of covered\_by() with geographic Points and Boxes + - [#12413](https://svn.boost.org/trac/boost/ticket/12413) + rtree::remove() not working properly with geographic Points +* [Hash](/libs/functional/hash): + + + Fixed some warnings. +* [Interprocess](/libs/interprocess/): + + + Fixed bugs: + + - [Trac + #12499 (*"Memory allocation fails"*)](https://svn.boost.org/trac/boost/ticket/12499). + - [GitHub + Pull #30 (*"Provide extension point so library + user can provide default temp folder"*)](https://github.com/boostorg/interprocess/pull/30). + - [GitHub + Pull #31 (*"Add xsi\_key(key\_t) constructor"*)](https://github.com/boostorg/interprocess/pull/31). +* [Intrusive](/libs/intrusive/): + + + Fixed bugs: + + - [Boost + Trac #12556: *member\_value\_traits.hpp has a missing + #include*](https://svn.boost.org/trac/boost/ticket/12556) +* [Lexical Cast](/libs/lexical_cast/): + + + Fixed issue found by `-fsanitize=undefined` [#21](https://github.com/boostorg/lexical_cast/issues/21) +* [Log](/libs/log/): + + + General changes: + + - Removed the previously deprecated `type\_info\_wrapper`. + + New features: + + - Added a way to access the current file name from the text file + sink backend. The file name can be obtained with the `get\_current\_file\_name` method. + + Bug fixes: + + - Fixed compilation errors for Android API prior to version 21. + - Streaming operators now take scalar types and enums by value. + This allows to output static constants and bitfields directly + into formatting stream and record stream. ([#11998](https://svn.boost.org/trac/boost/ticket/11998)) + - Fixed auto-detection of native syslog API. ([#12600](https://svn.boost.org/trac/boost/ticket/12600)) + - In UDP socket based syslog backend implementation, changed + the syslog message format for better compliance with RFC3164. + - File close handler installed in text file sink backend is no + longer called if the file is not open yet. + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Metaparse](/libs/metaparse/): + + + Improved the implementation of `BOOST\_METAPARSE\_STRING` + + - The maximal string length limit has been increased to 2048 + - The maximal string length limit can be extended beyond 2048 + by regenerating some of the Boost headers using a script (part + of the library) + - The string length limit can be changed within a compilation + unit +* [Move](/libs/move/): + + + Improved experimental adaptive sort algorithm performance + + Activate BOOST\_MOVE\_FORCEINLINE +* [Optional](/libs/optional/): + + + Added two new in-place constructors. They work similarly to `emplace()` + functions: they initialize the contained value by perfect-forwarding + the obtained arguments. One constructor always initializes the contained + value, the other based on a boolean condition. + + Syntax `o = + {}` now correctly un-initializes + an `optional`, just + like in `std::optional`. + + Fixed `optional&>` + initialization. ([#12203](https://svn.boost.org/trac/boost/ticket/12203)) + + Optional constructors are sfinae-friendly. This fixes interaction + with `std::tuple`. ([#12563](https://svn.boost.org/trac/boost/ticket/12563)) +* [Phoenix](/libs/phoenix/): + + + Most of modules now support C++11 variadic templates. + + Fixed type deduction failure with result type. + + Suppress unused warnings. + + Fixed too few arguments error on binary math functions. + + Added workarounds for older compiler. +* [Python](/libs/python/): + + + Added (basic) support for C++11 (std::shared\_ptr, std::unique\_ptr) + + Incorporated an extension API to wrap [NumPy](http://www.numpy.org/) + + Removed obsolete bits and pieces +* [Test](/libs/test/): + + + Boost.test v3.4 see the [Change + log](/doc/libs/1_63_0/libs/test/doc/html/boost_test/change_log.html) section for more details. + + New feature: `per\_element` + and `lexicographic` + modifiers of `BOOST\_TEST` + can also be applied to string comparison + + Breaking change: colons that appear in test case names are replaced + with underscores + + Bug fixes + + - Trac tickets [#11756](https://svn.boost.org/trac/boost/ticket/11756), [#11907](https://svn.boost.org/trac/boost/ticket/11907), [#12339](https://svn.boost.org/trac/boost/ticket/12339), [#12506](https://svn.boost.org/trac/boost/ticket/12506), + [#12507](https://svn.boost.org/trac/boost/ticket/12507), [#12530](https://svn.boost.org/trac/boost/ticket/12530), + - Trac tickets [#12531](https://svn.boost.org/trac/boost/ticket/12531) + - Pull request [PR103](https://github.com/boostorg/test/pull/103), + [PR104](https://github.com/boostorg/test/pull/104) +* [TypeIndex](/libs/type_index/): + + + Added `runtime\_cast` + to the library as an emulation of `dynamic\_cast`. + Thanks to Chris Glover for the implementation. See [runtime\_cast + reference](/doc/html/boost_typeindex_header_reference.html#header.boost.type_index.runtime_cast_hpp) for more info. + + Internals of the CTTI were made more platform independant, due to + change of the `std::size\_t` + type to `unsigned int`. +* [Units](/libs/units/): + + + Fix inspection warnings + + updated physico-chemical constants to CODATA 2014 values + + define biot correctly as 10 Ampere +* [Unordered](/libs/unordered/): + + + Fix an exception safety issue in assignment. + + Use `std::allocator\_traits` where available, + and support modern style rebind ([#12459](https://svn.boost.org/trac/boost/ticket/12459)). + + Add some allocator aware constructors. + + Use the hint iterator in `emplace\_hint`. + + Fixed some warnings. + + See the [changelog](/doc/html/unordered/changes.html) + for more details. + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 3.8.1 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 3.8.1 + + Clang, C++14: 3.5, 3.6, 3.7, 3.8.1 + + Clang, C++1z: 3.8.1 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.7.2, 5.2.0, 6.2.0 + + GCC, C++11: 4.4.7, 4.7.2, 4.7.3, 4.8.5, 4.9.3, 5.2.0, 6.1.1, 6.2.0 + + GCC, C++14: 5.2.0, 5.3.0, 6.1.1, 6.2.0 + + Intel: 16.0, 17.0 + + Intel, C++11: 16.0, 17.0 + + Intel, C++14: 16.0, 17.0 +* OS X: + + + Apple Clang: 7.0.2 + + Apple Clang, C++11: 7.0.2 +* Windows: + + + GCC, C++03, mingw: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0 + + GCC, C++11, mingw: 4.6.4, 4.7.3, 4.8.1 + + GCC, C++14, mingw: 4.9.3, 5.1.0, 5.2.0, 5.3.0, 6.1.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0 +* Android: + + + Clang: 3.6, 3.7, 3.8 + + GCC: 4.9, 5.4, 6.2 +* QNX: + + + QCC: 4.4.2 +* SunOS: + + + Oracle Solaris Studio: 12.5 + + Oracle Solaris Studio, C++11: 12.5 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.8.1 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 3.8.1 + + Clang, C++14: 3.5, 3.6, 3.7, 3.8.1 + + Clang, C++1z: 3.8.1 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.7.2, 5.2.0, 6.1.1, 6.2.0 + + GCC, C++11: 4.4.7, 4.7.2, 4.7.3, 4.8.5, 4.9.3, 5.2.0, 6.1.1, 6.2.0 + + GCC, C++14: 5.2.0, 5.3.0, 6.1.1, 6.2.0, 7.0.0 (experimental) + + GCC, C++1z: 6.1.1 + + Intel: 16.0, 17.0 + + Intel, C++11: 16.0, 17.0 + + Intel, C++14: 16.0, 17.0 +* OS X: + + + Apple Clang: 7.0.2 + + Apple Clang, C++11: 7.0.2 +* Windows: + + + GCC, C++03, mingw: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0 + + GCC, C++11, mingw: 4.6.4, 4.7.3, 4.8.1 + + GCC, C++14, mingw: 4.9.3, 5.1.0, 5.2.0, 5.3.0, 6.1.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0 +* Android: + + + Clang: 3.6, 3.7, 3.8 + + GCC: 4.9, 5.4, 6.2 + + GCC,C++14: 6.1.0 +* QNX: + + + QCC: 4.4.2 +* SunOS: + + + Oracle Solaris Studio: 12.5 + + Oracle Solaris Studio, C++11: 12.5 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_64_0.html b/users/history/version_1_64_0.html new file mode 100644 index 0000000..46c7746 --- /dev/null +++ b/users/history/version_1_64_0.html @@ -0,0 +1,456 @@ +--- +title: Version 1.64.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.64.0 + +/\*\*/ + + + + + + + +Version 1.64.0 +============== + +Version 1.64.0 +-------------- + + +April 19th, 2017 17:42 GMT + + +[Documentation](/doc/libs/1_64_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_64\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.64.0/source/boost_1_64_0.tar.bz2) | 7bcc5caace97baa948931d712ea5f37038dbb1c5d89b43ad4def4ed7cb683332 | +| [boost\_1\_64\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.64.0/source/boost_1_64_0.tar.gz) | 0445c22a5ef3bd69f5dfb48354978421a85ab395254a26b1ffb0aa1bfd63a108 | +| windows | [boost\_1\_64\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.64.0/source/boost_1_64_0.7z) | 49c6abfeb5b480f6a86119c0d57235966b4690ee6ff9e6401ee868244808d155 | +| [boost\_1\_64\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.64.0/source/boost_1_64_0.zip) | b99973c805f38b549dbeaf88701c0abeff8b0e8eaa4066df47cac10a32097523 | + + +### Third Party Downloads + + +* [Windows Binaries](https://boostorg.jfrog.io/artifactory/main/release/1.64.0/binaries/) + + +### New Libraries + + +* [Process](/libs/process/): + Process library by Klemens + D. Morgenstern, that provides cross platorm ways to allows you to: + + + create child processes + + setup streams for child processes + + communicate with child processes through streams (synchronously or + asynchronously) + + wait for processes to exit (synchronously or asynchronously) + + terminate processes + Broken feature: + + + [GitHub + #67: *"group.wait() does not return"*](https://github.com/klemens-morgenstern/boost-process/issues/67). + +### Updated Libraries + + +* [Any](/libs/any/): + + + Suppressed false warnings about returning reference to temporary + + `boost::addressof` is now used instead of + directly taking the address [#12615](https://svn.boost.org/trac/boost/ticket/12615) + + Headers are not included using double quotes any more [#12053](https://svn.boost.org/trac/boost/ticket/12053) + + CI tests now run with `address`, + `leak`, and `undefined` sanitizers + + Added more test +* [Atomic](/libs/atomic/): + + + Fixed possible incorrect code generation in 64-bit atomic operations + on 32-bit x86 with gcc versions older than 4.7 and compatible compilers. +* [Config](/libs/config/): + + + Added `BOOST\_NO\_CXX11\_SFINAE\_EXPR` + defect detection. +* [Container](/libs/container/): + + + Fixed bugs: + + - [Trac + #12749: *"container::pmr::polymorphic\_allocator + compilation error"*](https://svn.boost.org/trac/boost/ticket/12749). + - [Trac + #11333: *"boost::basic\_string\_ref should interop + with boost::container::basic\_string"*](https://svn.boost.org/trac/boost/ticket/11333). + - [GitHub + #45: *"emplace\_back must return reference to + back(), not to \*end()"*](https://github.com/boostorg/container/pull/45). +* [Context](/libs/context/): + + + new API: call/cc + + deprecated API:execution-context + + stack manipulation on MIPS fixed + + [#12719](https://svn.boost.org/trac/boost/ticket/12719) segmentation fault when built with mingw-w64 + + [#12948](https://svn.boost.org/trac/boost/ticket/12948) Unexpected snprintf result is on Android ARM + + #38: context\_entry() crashes on macOS + + #39: Unknown directive .cpu on aarch64 with Clang 3.8 on Android + + #41: std::bind() fails with invoke() + + #46: "rename of continuation member functions" missed a + spot + + #50: bad assembly for fcontext on ppc64/sysv/elf +* [Conversion](/libs/conversion/): + + + Docs were ported to Quickbook (thanks to Mikhail Maksimov for the + port) + + Fixed a memory leak in test (thanks to Mikhail Maksimov for the fix) + + CI tests now run with `address`, + `leak`, and `undefined` sanitizers +* [Core](/libs/core/): + + + Implemented `constexpr` + `addressof` on compilers + that support C++11 `constexpr` + and SFINAE expressions (Glen Fernandes). `BOOST\_CORE\_NO\_CONSTEXPR\_ADDRESSOF` + macro indicates when `constexpr` + `addressof` is not + available. + + In `lightweight\_test.hpp`, + added new macros `BOOST\_TEST\_ALL\_EQ` + and `BOOST\_TEST\_ALL\_WITH` + for testing container contents (Bjorn Reese). +* [Coroutine2](/libs/coroutine2/): + + + #4: coroutine2<> does not accept std::bind +* [DLL](/libs/dll/): + + + Fixed WinCE compilation + + Added `boost:dll::symbol\_location\_ptr` function for + getting location of a symbol by pointer that could not be dereferenced + (`void` pointer for example) + + Fixed UB in `detail::aggressive\_ptr\_cast` + for member pointers + + Fixed leaks in experimental smart imports + + Fixed warnings + + CI tests now run with `address` + and `leak` sanitizers +* [Fiber](/libs/fiber/): + + + (un)bounded\_channel<> removed + + #100: ASIO: unbuffered\_channel / scheduler notify issue + + #105: skynet variants crash on windows + + #106: Passing a fixed\_stack allocator to async/packaged\_task doesn't + compile + + #110: Compile error on ARMv6 + + #111: endless-loop in buffered\_channel::try\_value\_pop() + + #114: buffered\_channel::try\_push `does + not wake + fibers in`pop` +* [Geometry](/libs/geometry/): + + + Improvements: + + - matrix transformation is now based on Boost.QVM instead of + Boost.Ublas + + Breaking changes: + + - ublas\_transformer is renamed to matrix\_transformer + - explicit modifier is added to constructors of rtree index::dynamic\_\* + parameters + - strategy::area::huiller replaced by strategy::area::spherical + + Solved issues: + + - [363](https://github.com/boostorg/geometry/issues/363) + Missing includes in geometry/index/parameters.hpp + - [364](https://github.com/boostorg/geometry/issues/364) + within(Linear, Areal) compilation error when arguments use + different point types + - [370](https://github.com/boostorg/geometry/issues/370) + Buffer Seg Faults with Ring as Input + + Solved tickets: + + - [11899](https://svn.boost.org/trac/boost/ticket/11899) + boost::geometry::equals doesn't handle open polygons + - [11930](https://svn.boost.org/trac/boost/ticket/11930) + Inaccuracy of area::huiller strategy + - [11931](https://svn.boost.org/trac/boost/ticket/11931) + Wrong spherical area with pole encircling polygons + - [12410](https://svn.boost.org/trac/boost/ticket/12410) + Lack of support of geographic coordinate system in correct() + - [12566](https://svn.boost.org/trac/boost/ticket/12566) + Ambiguous template instantiation in equal\_to<> when pair + value contains raw pointer + - [12861](https://svn.boost.org/trac/boost/ticket/12861) + Segmentation fault in stdlibc++ (gcc 4.8.2) affecting rtree + - [12885](https://svn.boost.org/trac/boost/ticket/12885) + Use BOOST\_THROW\_EXCEPTION instead of throw + + Bugfixes: + + - Fix distance\_measure in get\_turn\_info +* [Hash](/libs/functional/hash/): + + + Stop using `std::unary\_function` and `std::binary\_function` when they're not + available. +* [Interprocess](/libs/interprocess/): + + + Fixed bugs: + + - [Trac + #12617 (*"clock\_gettime not available on OS X + 10.11"*)](https://svn.boost.org/trac/boost/ticket/12617). + - [Trac + #12744 (*"winapi::set\_timer\_resolution inadvertently + changes timer resolution (Windows)"*)](https://svn.boost.org/trac/boost/ticket/12744). + - [GitHub + Pull #32 (*"Conform to std::pointer\_traits requirements"*)](https://github.com/boostorg/interprocess/pull/32). + - [GitHub + Pull #33 (*"explicit cast to derived class" + and "64/32 bit processes sharing"*)](https://github.com/boostorg/interprocess/pull/33). + - [GitHub + Pull #34 (*"Update example to use multi\_index::member + instead of BOOST\_MULTI\_INDEX\_MEMBER"*)](https://github.com/boostorg/interprocess/pull/34). + - [GitHub + Pull #35 (*"Fixed options for cross-compilation"*)](https://github.com/boostorg/interprocess/pull/35). + + New experimental option `BOOST\_INTERPROCESS\_BOOTSTAMP\_IS\_SESSION\_MANAGER\_BASED` + from Windows systems. This option derives the unique bootstamp used + to name the folder where shared memory is placed from registry values + associated with the session manager. This option only works on Vista + and later systems and might be more stable than the default version. +* [Intrusive](/libs/intrusive/): + + + Fixed bugs: + + - [Boost + Trac #12745: *key\_nodeptr\_comp broken if the key type + is void\**](https://svn.boost.org/trac/boost/ticket/12745) + - [Boost + Trac #12761: *intrusive::set::swap doesn't swap the + comparison function\**](https://svn.boost.org/trac/boost/ticket/12761) +* [LexicalCast](/libs/lexical_cast/): + + + Fixed multiple warnings [#11842](https://svn.boost.org/trac/boost/ticket/11842) + + CI tests now run with `address`, + `leak`, and `undefined` sanitizers +* [Math](/libs/math/): + + + Big push to ensure all functions in also in C99 are compatible with + Annex F. + + Improved accuracy of the Bessel functions I0, I1, K0 and K1, see + [12066](https://svn.boost.org/trac/boost/ticket/12066). +* [Multi-index Containers](/libs/multi_index/index.html): + + + Fixed a bug related to ambiguous references in the presence of more + than one ranked index (ticket [#12955](https://svn.boost.org/trac/boost/ticket/12955)). + + Maintenance fixes. +* [Multiprecision](/libs/multiprecision/): + + + In `cpp\_bin\_float` + prevent double rounding when converting to a denormalized float. + See [#12527](https://svn.boost.org/trac/boost/ticket/12527). + + Fix bug in integer sqrt for very small integers. See [#12559](https://svn.boost.org/trac/boost/ticket/12559). + + Fix conversion to signed-zero in `cpp\_bin\_float`. + + Change `cpp\_bin\_float` + rounding code to round at arbitrary location so we can use it for + conversions, see [#12527](https://svn.boost.org/trac/boost/ticket/12527). + + Improve performance of 128-bit bit-scan operations. + + Fix subtraction of very small quantities in `cpp\_bin\_float`. + See: [#12580](https://svn.boost.org/trac/boost/ticket/12580). + + Bring error handling into line with C99 Annex F. See [#12581](https://svn.boost.org/trac/boost/ticket/12581). + + Fix bitwise export of trivial `cpp\_int`'s, + see [#12627](https://svn.boost.org/trac/boost/ticket/12627). + + Fix `ilogb` (and code + that uses it) to consistently return the smallest value of the exponent + type when the argument is zero, see [#12625](https://svn.boost.org/trac/boost/ticket/12625). + + Allow conversion from `\_\_float128` + to `cpp\_bin\_float`. + + Fix bug in left shift of `cpp\_int` + which would result in bit-loss, see [#12790](https://svn.boost.org/trac/boost/ticket/12790). + + Fixed bugs in bounded but variable precision `cpp\_int`'s + caused by over-aggressive constexpr optimization, see [#12798](https://svn.boost.org/trac/boost/ticket/12798). +* [Predef](/libs/predef/): + + + Fix Intel C/C++ compiler version specification. + + Add `BOOST\_VERSION\_NUMBER\_MAJOR`, + `BOOST\_VERSION\_NUMBER\_MINOR`, + `BOOST\_VERSION\_NUMBER\_PATCH` + macros to extract components from valid version numbers. + + Change VS version numbering. Versions after VS2015 will use the compiler + version instead of the varied product versions. +* [Regex](/libs/regex/): + + + Compiling with Oracle C++ toolset is no longer restricted to static + linking. + + Big effort to de-fuzz the library using libFuzzer and fix identified + issues, see: [#12818](https://svn.boost.org/trac/boost/ticket/12818). +* [Smart Pointers](/libs/smart_ptr/): + + + Rewrite of `allocate\_shared` + and `make\_shared` for + arrays for a more optimal and more maintainable implementation (Glen + Fernandes) + + Pointer cast functions with move semantics (Chris Glover) +* [Test](/libs/test/): + + + Boost.test v3.5 see the [Change + log](/doc/libs/1_64_0/libs/test/doc/html/boost_test/change_log.html) section for more details. + + New feature: + + - Now Boost.Test provides **customization + points** for logging user defined types + - JUnit output format can now have a *log-level* + - JUnit output format has not better performances when the test + modules have a lot of checks + + Bug fixes + + - Trac tickets [#11756](https://svn.boost.org/trac/boost/ticket/11756), [#12540](https://svn.boost.org/trac/boost/ticket/12540), [#12712](https://svn.boost.org/trac/boost/ticket/12712), [#12748](https://svn.boost.org/trac/boost/ticket/12748), + [#12778](https://svn.boost.org/trac/boost/ticket/12778) + - Pull request [PR107](https://github.com/boostorg/test/pull/107), + [PR108](https://github.com/boostorg/test/pull/108) +* [TypeIndex](/libs/type_index/): + + + Added `BOOST\_TYPE\_INDEX\_IMPLEMENT\_RUNTIME\_CAST`, + which implements the functionality for `runtime\_cast` + but does not include the `BOOST\_TYPE\_INDEX\_REGISTER\_CLASS` + macro (thanks to Chris Glover for imlpementing it) + + Fixed undefined macro warning in stl\_type\_index.hpp [#12739](https://svn.boost.org/trac/boost/ticket/12739) + + CI tests now run with `address`, + `leak`, and `undefined` sanitizers +* [TypeTraits](/libs/type_traits/): + + + Added new traits `make\_void` + and `void\_t`. +* [Unordered](/libs/unordered/): + + + Initial support for new C++17 member functions: `insert\_or\_assign` + and `try\_emplace` in + `unordered\_map`, `merge` and `extract` + in all containers. +* [Variant](/libs/variant/): + + + Fixed construction of variant from `recursive\_variant\_` + (thanks to Mikhail Maksimov for the fix) [#12508](https://svn.boost.org/trac/boost/ticket/12508), [#12645](https://svn.boost.org/trac/boost/ticket/12645) + + Do not enable variadic templates for MSVC2015Update1 as it still + has issues [#12236](https://svn.boost.org/trac/boost/ticket/12236) + + Workaround GCC6 crash (thanks to Mikhail Maksimov for the workaround) + [#12680](https://svn.boost.org/trac/boost/ticket/12680), [#7120](https://svn.boost.org/trac/boost/ticket/7120) + + Made `boost::polymorphic\_\*get` to work as `boost::\*get` + in undocumented border cases and fixed tests [#11950](https://svn.boost.org/trac/boost/ticket/11950) + + CI tests now run with `address`, + `leak`, and `undefined` sanitizers + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 3.8.1, 3.9.1 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 3.8.1, 3.9.1 + + Clang, C++14: 3.5, 3.6, 3.7.1, 3.8.1, 3.9.1 + + Clang, C++1z: 3.9.1 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.7.2, 6.2.0 + + GCC, C++11: 4.4.7, 4.7.2, 4.7.3, 4.8.5, 4.9.4, 6.2.0 + + GCC, C++14: 5.4.1, 6.2.0, 6.3.0 + + GCC, C++1z: 6.2.0 + + Intel: 16.0, 17.0 + + Intel, C++11: 16.0, 17.0 + + Intel, C++14: 16.0, 17.0 +* OS X: + + + Apple Clang: 7.0.2 + + Apple Clang, C++11: 7.0.2 +* Windows: + + + GCC, C++03, mingw: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0 + + GCC, C++11, mingw: 4.6.4, 4.7.3, 4.8.1 + + GCC, C++14, mingw: 4.9.3, 5.1.0, 5.2.0, 5.3.0, 6.1.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0 +* Android: + + + Clang: 3.6, 3.7, 3.8 + + GCC: 4.9, 5.4, 6.2 +* FreeBSD: + + + Clang: 3.8 + + Clang, C++11: 3.8 + + Clang, C++14: 3.8 + + Clang, C++1z: 3.8 +* QNX: + + + QCC: 4.4.2 +* SunOS: + + + Oracle Solaris Studio: 12.5 + + Oracle Solaris Studio, C++11: 12.5 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.8.1, 3.9.1 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.8.1, 3.9.1 + + Clang, C++14: 3.4, 3.5, 3.6, 3.7. 3.8, 3.8.1, 3.9.1 + + Clang, C++1z: 3.9.1, 4.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.7.2, 6.2.0 + + GCC, C++11: 4.4.7, 4.7.2, 4.7.3, 4.8.5, 4.9.4, 6.2.0 + + GCC, C++14: 5.4.1, 6.2.0, 6.3.0, 7.0.1 + + GCC, C++1z: 6.2.0 + + Intel: 16.0, 17.0 + + Intel, C++11: 16.0, 17.0 + + Intel, C++14: 16.0, 17.0 +* OS X: + + + Apple Clang: 7.0.2 +* Windows: + + + GCC, C++03, mingw: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* Android: + + + Clang: 3.6, 3.7, 3.8 + + GCC: 4.9, 5.4, 6.2 +* FreeBSD: + + + Clang, C++98: 3.8 + + Clang, C++11: 3.8 + + Clang, C++14: 3.8 + + Clang, C++1z: 3.8 +* QNX: + + + QCC: 4.4.2 +* SunOS: + + + Oracle Solaris Studio: 12.5 + + Oracle Solaris Studio, C++11: 12.5 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_65_0.html b/users/history/version_1_65_0.html new file mode 100644 index 0000000..4e5847f --- /dev/null +++ b/users/history/version_1_65_0.html @@ -0,0 +1,484 @@ +--- +title: Version 1.65.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.65.0 + +/\*\*/ + + + + + + + +Version 1.65.0 +============== + +Version 1.65.0 +-------------- + + +August 21st, 2017 20:50 GMT + + +[Documentation](/doc/libs/1_65_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_65\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.65.0/source/boost_1_65_0.tar.bz2) | ea26712742e2fb079c2a566a31f3266973b76e38222b9f88b387e3c8b2f9902c | +| [boost\_1\_65\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.65.0/source/boost_1_65_0.tar.gz) | 8a142d33ab4b4ed0de3abea3280ae3b2ce91c48c09478518c73e5dd2ba8f20aa | +| windows | [boost\_1\_65\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.65.0/source/boost_1_65_0.7z) | 4873d8f3506fd8d76e2eadcf0ace83b258010fc268a4d974361af7abad5448f5 | +| [boost\_1\_65\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.65.0/source/boost_1_65_0.zip) | f3f5c37be45eb6516c95cd147d8aa4abb9b52121fc3eccc1fc65c4af0cf48592 | + + +### Third Party Downloads + + +* [Windows Binaries](https://boostorg.jfrog.io/artifactory/main/release/1.65.0/binaries/) + + +### Known Issues + These are patches from library authors which were found too late to be fixed + in the release. Be careful as they have not been through the normal testing + process. + + Combined patch for fixes to issues: [boost\_1\_65\_0.patch](/patches/1_65_0/boost_1_65_0.patch). + Use `patch -p1 < boost\_1\_65\_0.patch` from the root of the boost repo to + apply. Or you can apply the patches individually below. + + + +* Context and Fiber don't return continuations when they should: + + + [Context + patch](/patches/1_65_0/0001-context-function-executed-by-resume_with-has-to-retu.patch) + + [Fiber + patch](/patches/1_65_0/0002-fiber-resume_with-requires-tor-return-a-continuation.patch) +* Thread: Bug in `boost::condition\_variable` on Windows: + + + [Thread + patch 1](/patches/1_65_0/0003-thread-130-Bug-in-boost-condition_variable-on-Window.patch) + + [Thread + patch 2](/patches/1_65_0/0004-thread-130-Bug-in-boost-condition_variable-on-Window.patch) + +### New Libraries + + +* [PolyCollection](/libs/poly_collection/): + Fast + containers of polymorphic objects, from Joaquín M López Muñoz. +* [Stacktrace](/libs/stacktrace/): + Gather, store, + copy and print backtraces, from Antony Polukhin. + + + Note: Library has [issue + with MinGW](https://github.com/boostorg/stacktrace/issues/14) and may produce empty backtraces with that compiler. + +### Removed Libraries + + +* TR1 + +### Updated Libraries + + +* [Asio](/libs/asio/): + + + Changed to require g++ versions >= 4.7 to use + standard atomics, to fix a linker error when using g++ + 4.6 ([#13121](https://svn.boost.org/trac/boost/ticket/13121)). + + Enabled use of `constexpr` + and variadic templates with recent MSVC versions. + + Fixed a race condition in the Linux epoll backend, which may occur + when a socket or descriptor is closed while another thread is blocked + on epoll. + + Eliminated use of deprecated `auto\_ptr`. + + Fixed misplaced use of `asio\_handler\_is\_continuation` + result in reactive `async\_accept` + implementation. + + Changed to use `poll.h` + rather than `sys/poll.h` on some modern POSIX platforms + ([#12419](https://svn.boost.org/trac/boost/ticket/12419)). + + Fixed MSVC intellisense detection. + + Disabled use of the `\_\_thread` + keyword extension for android/clang/x86 targets. +* [Context](/libs/context/): + + + Improvements: + + - call/cc supports ucontext-API (swapcontext) + - call/cc supports Windows-Fiber-API + - call/cc supports on demand growing (segmented/split) stacks + + Bugfixes: + + - [#12719](https://svn.boost.org/trac/boost/ticket/12719): context test cases and examples segmentation fault + when built with mingw-w64 toolchain + - #52: Failing to build callcc test with g++-4.9 + + important: + + - required bug fix [420554fe9ac01482990e8ae314f4f7ba81010c9a](https://github.com/boostorg/context/commit/420554fe9ac01482990e8ae314f4f7ba81010c9a) + not included in 1.65 +* [Config](/libs/config/): + + + Added `BOOST\_NO\_CXX11\_POINTER\_TRAITS`, + `BOOST\_NO\_CXX17\_FOLD\_EXPRESSIONS`, + `BOOST\_NO\_CXX17\_INLINE\_VARIABLES`, + `BOOST\_NO\_CXX17\_STRUCTURED\_BINDINGS` + defect detection. + + BOOST\_FALLTHROUGH support for GCC 7 and above. (Glen Fernandes) +* [Core](/libs/core/): + + + Implemented `pointer\_traits` + for C++03 and higher, that implements [P0653r0](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0653r0.html) + (Glen Fernandes). This implementation is now used by Align, Circular + Buffer, Fiber, Geometry, among other libraries. + + Added `BOOST\_TEST\_GT` + and `BOOST\_TEST\_GE` + to Lightweight Test. +* [Coroutine2](/libs/coroutine2/): + + + supports ucontext-API (swapcontext) + + supports Windows-Fiber-API + + [#13064](https://svn.boost.org/trac/boost/ticket/13064): different behavior coroutine and coroutine2 +* [DLL](/libs/dll/): + + + Fix PE parsing on non Windows platforms. +* [Fiber](/libs/fiber/): + + + Improvements: + + - hardware transactional memory (Intel TSX) supported + - NUMA supported + - ucontext-API (swapcontext) supported + - Windows-Fiber-API supported + - on demand growing stacks + + Bugfixes: + + - #121: failing to build static lib with GCC 4.8 and C++11 + - #123: assertion failure in schedule\_from\_remote + - #125: erratic crashes in testsuite + - #126: incorrect std::memory\_order value in compare\_exchange\_strong? + + important: + + - required bug fix [63f1041f0e484e64dec437a0fa780ea2463abda2](https://github.com/boostorg/fiber/commit/63f1041f0e484e64dec437a0fa780ea2463abda2) + not included in 1.65 +* [Fusion](/libs/fusion/): + + + MSVC 14.1 supports variadic containers, such as `fusion::vector`, + `fusion::deque`, `fusion::map`, + `fusion::set`, and `fusion::tuple`. + ([#12986](https://svn.boost.org/trac/boost/ticket/12986)) +* [Geometry](/libs/geometry/): + + + Improvements: + + - Add correct() overload taking area strategy + - Add is\_convex() overload taking side strategy + - Add missing relational operations (covered\_by, crosses, equals, + etc.) for MultiPoint/AnyGeometry + + Solved issues: + + - [12410](https://svn.boost.org/trac/boost/ticket/12410) + Lack of support of geographic coordinate system in correct() + - [13035](https://svn.boost.org/trac/boost/ticket/13035) + Wrong result of non-cartesian intersection strategies for segments + near poles. + - [13057](https://svn.boost.org/trac/boost/ticket/13057) + Wrong result of intersects() for linestrings caused by numerical + issue in disjoint() for boxes. + + Bugfixes: + + - Fix is\_valid which could return false for multipolygons where + an interior ring touches another interior ring + - Fix is\_valid which could return false for multipolygons where + a polygon was located in an interior ring, all touching each + other + - Fix union which could produce invalid results (for some cases, + this needs to define BOOST\_GEOMETRY\_INCLUDE\_SELF\_TURNS) + - Fix intersection (idem), but some cases are still not yet valid + - Fix difference (idem), but some cases are still not yet valid + - Fix propagation of area strategy into the internals of various + algorithms from intersection strategy + - Fix uninitialized variable in relate and reference to temporary + in overlay + - Fix error in disjoint for geographic Segment/Box + - Fix handling of non-cartesian geometries in various algorithms +* [Hash](/libs/functional/hash/): + + + Support for `char16\_t`, + `char32\_t`, `u16string`, `u32string`. +* [Log](/libs/log/): + + + General changes: + + - Improved compatibility with Solaris. + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Phoenix](/libs/phoenix/): + + + Corrected some documentation. ([PR#50](https://github.com/boostorg/phoenix/pull/50)) + + `phoenix::erase` with associative container + returns iterator in C++11 mode. ([#7423](https://svn.boost.org/trac/boost/ticket/7423)) + + `std::set` and `std::multiset` + should be worked with predefined lazy functions. ([PR#52](https://github.com/boostorg/phoenix/pull/52)) + + Disable `phoenix::random\_shuffle` in C++17. ([PR#53](https://github.com/boostorg/phoenix/pull/53)) + + Don't forward declare, include instead. ([#11875](https://svn.boost.org/trac/boost/ticket/11875)) +* [Predef](/libs/predef/): + + + Fix Intel C/C++ version 9999 detection to be 12.1.0. + + Addition of `BOOST\_PREDEF\_WORKAROUND` + and `BOOST\_PREDEF\_TESTED\_AT` + macros for defect workarounds and detection. + + Add ARM64 MSVC SIMD detection. (from Minmin Gong) + + Add detection of iOS simulator vs device as a platform choice. (from + Ruslan Baratov) + + Fix MinGW incorrect header guard. (from Ruslan Baratov) +* [Program Options](/libs/program_options/): + + + Support for storing values into `boost::optional`, + thanks to Ed Catmur ([#7495](https://svn.boost.org/trac/boost/ticket/7495), + [PR#18](https://github.com/boostorg/program_options/pull/18)) + + Parsing of implicit options can now use the value from the next token. + Since 1.59, unless the value of implicit option was specified in + the same token as the option itself, the implicit value was used. + That proved inconvenient, and now we again check the next token and + use it as value if it's not an option itself. ([#25](https://github.com/boostorg/program_options/issues/25)) +* [Python](/libs/python/): + + + `eval()`, + `exec()`, + and `exec\_statement()` now allow `char + const \*` + arguments, in addition to `boost::python::str`. + + The `boost::python::numeric` API has been removed, as + it is being obsoleted by `boost::python::numpy`. + + Fix some build issues when using Python3 with MSVC. +* [Smart Pointers](/libs/smart_ptr/): + + + New class template`atomic\_shared\_ptr`, + that provides thread-safe atomic pointer operations over `shared\_ptr`. (Peter Dimov) + + New class template `local\_shared\_ptr`, + where the reference count is updated with non-atomic operations. + (Peter Dimov) + + More optimizations in `allocate\_shared` + and `make\_shared` for + arrays. (Glen Fernandes) + + Documentation has been completely rewritten in Asciidoc format. +* [Test](/libs/test/): + + + Boost.test v3.6 see the [Change + log](/doc/libs/1_65_0/libs/test/doc/html/boost_test/change_log.html) section for more details. + + New feature: + + - C++17 compatibility (tested on VS2017), thanks to [Daniela + Engert](https://github.com/DanielaE) + - Direct comparison of C-arrays in `BOOST\_TEST` + - Better global fixtures mechanism, and spitting of responsibilities + with [`BOOST\_TEST\_GLOBAL\_FIXTURE`](/doc/libs/1_65_0/libs/test/doc/html/boost_test/utf_reference/test_org_reference/test_org_boost_test_global_fixture.html) + for global fixtures and [`BOOST\_TEST\_GLOBAL\_CONFIGURATION`](/doc/libs/1_65_0/libs/test/doc/html/boost_test/utf_reference/link_references/link_boost_test_global_configuration.html) + for global initialization (compile time configuration). + - Improved support for fixtures (`setup` + / `teardown` + member function) which enables better teardown time checks + + Breaking changes + + - Some API changes for the loggers + - Deprecating `BOOST\_GLOBAL\_FIXTURE` + in favor of `BOOST\_TEST\_GLOBAL\_FIXTURE` + and `BOOST\_TEST\_GLOBAL\_CONFIGURATION` + (see above) + + Bug fixes + + - Trac tickets [#5282](https://svn.boost.org/trac/boost/ticket/5282), [#5563](https://svn.boost.org/trac/boost/ticket/5563), [#11471](https://svn.boost.org/trac/boost/ticket/11471), [#11962](https://svn.boost.org/trac/boost/ticket/11962), + [#12228](https://svn.boost.org/trac/boost/ticket/12228) + - Trac tickets [#12631](https://svn.boost.org/trac/boost/ticket/12631), [#13011](https://svn.boost.org/trac/boost/ticket/13011) + - Pull request [PR106](https://github.com/boostorg/test/pull/106) +* [Thread](/libs/thread/): + + + Important Regression on Windows: + + - [#130](https://github.com/boostorg/thread/issues/130) + windows: Bug in boost::condition\_variable on Windows Please, + merge these two patches + - + - + + Bug fixes + + - [#6787](http://svn.boost.org/trac/boost/ticket/6787) + boost::thread::sleep() hangs if system time is rolled back + - [#12519](http://svn.boost.org/trac/boost/ticket/12519) + boost::thread::try\_join\_for does not return after timeout + - [#12874](http://svn.boost.org/trac/boost/ticket/12874) + future<> extension constructor must be under BOOST\_THREAD\_PROVIDES\_FUTURE\_UNWRAP + - [#12888](http://svn.boost.org/trac/boost/ticket/12888) + Linking with boost thread does not work on mingw/gcc 4.4 + - [#12958](http://svn.boost.org/trac/boost/ticket/12958) + sync\_bounded\_queue::wait\_pull\_front( lve ) might throw + - [#13077](http://svn.boost.org/trac/boost/ticket/13077) + Linking to static 64bit libboost\_thread fails DLL initialization + - [#13155](http://svn.boost.org/trac/boost/ticket/13155) + log doesn't build on a system with pthreads + - [#121](https://github.com/boostorg/thread/issues/121) + on\_tls\_prepare is broken under VS2017 +* [TypeIndex](/libs/type_index/): + + + Include if required, thanks to + Ed Catmur [#13009](https://svn.boost.org/trac/boost/ticket/13009). + + Use native `hash\_code()` when possible on GCC-like compilers + [#13027](https://svn.boost.org/trac/boost/ticket/13027). + + Fix `ctti\_type\_index` + for GCC 7 and later, thanks to Benjamin Buch [PR16](https://github.com/boostorg/type_index/pull/16). +* [Typeof](/libs/typeof/): + + + Fix compilation error with clang-cl [ticket + 11821](https://svn.boost.org/trac10/ticket/11821). +* [Unordered](/libs/unordered/): + + + Use the same data structure for `unordered\_set` + and `unordered\_multiset`, + and for`unordered\_map` + and `unordered\_multimap`. + This is required for C++17, so that nodes can be merged and extracted + between compatible containers. + + Add deprecated attributes to long deprecated functions. + + Improved use of `allocator\_traits` + `construct` and `destroy` on C++11 compilers, using + piecewise pair construction when appropriate. + + Fewer workarounds on newer Oracle compilers. + + Avoid dereferencing pointers to uninitialized memory ([PR + #5](https://github.com/boostorg/unordered/pull/5)). +* [Utility](/libs/utility/): + + + Improved compatibility of `boost::next`/`boost::prior` with SFINAE-unfriendly iterators. + [#10847](https://svn.boost.org/trac/boost/ticket/10847), [#13002](https://svn.boost.org/trac/boost/ticket/13002). +* [Variant](/libs/variant/): + + + r-value overload for `boost::get` + was added by Albert Sverdlov [#13018](https://svn.boost.org/trac/boost/ticket/13018). + + Missing include fro `` + header was added by Adam Badura [#13037](https://svn.boost.org/trac/boost/ticket/13037). + + `boost::make\_variant\_over` was fixed and + now works with views and other Forward Sequences (thanks to Mikhail + Maksimov for the fix) [#8554](https://svn.boost.org/trac/boost/ticket/8554), [#10041](https://svn.boost.org/trac/boost/ticket/10041), [PR#35](https://github.com/boostorg/variant/pull/35). + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 3.8.1 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 3.8.1 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.8.1, 3.9.1, 4.0.1 + + Clang, C++1z: 4.0.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.7.2, 5.4.0, 7.1.0 + + GCC, C++11: 4.4.7, 4.7.2, 4.7.3, 4.8.5, 4.9.4, 5.4.0, 7.1.0 + + GCC, C++14: 5.4.0, 5.4.1, 6.3.0, 7.1.0 + + GCC, C++17: 7.1.0 + + GCC, C++1z: 6.3.0 + + Intel: 16.0, 17.0 + + Intel, C++11: 16.0, 17.0 + + Intel, C++14: 16.0 +* OS X: + + + Clang: 8.1.0 + + Clang, C++11: 8.1.0 + + Clang, C++14: 8.1.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++11: 4.6.4, 4.7.3, 4.8.1 + + GCC, C++14: 4.9.3, 5.1.0, 5.2.0, 5.3.0, 6.1.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* Android: + + + Clang: 3.6, 3.7, 3.8 + + GCC: 4.9, 5.4 + + GCC, C++14: 6.2 +* FreeBSD: + + + Clang: 3.8.0 + + Clang, C++11: 3.8.0 + + Clang, C++14: 3.8.0 + + Clang, C++1z: 3.8.0 +* QNX: + + + QCC, C++11: 4.7.3 +* SunOS: + + + Oracle Solaris Studio: 12.5\_next, 12.5 + + Oracle Solaris Studio, C++11: 12.5\_next, 12.5 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.8.1 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 3.8.1 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.8.1, 3.9.1, 4.0.1 + + Clang, C++1z: 4.0.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.7.2, 5.4.0, 7.1.0 + + GCC, C++11: 4.4.7, 4.7.2, 4.7.3, 4.8.5, 4.9.4, 5.4.0, 7.1.0 + + GCC, C++14: 5.4.1, 6.2.0, 6.3.0, 7.1.0, 8.0.0 + + GCC, C++17: 7.1.0 + + GCC, C++1z: 6.3.0 + + Intel: 17.0 + + Intel, C++11: 16.0, 17.0 + + Intel, C++14: 16.0 +* OS X: + + + Clang: 8.1.0 + + Clang, C++11: 8.1.0 + + Clang, C++14: 8.1.0 + + Clang, C++1z: 8.1.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++11: 4.6.4, 4.7.3, 4.8.1 + + GCC, C++14: 4.9.3, 5.1.0, 5.2.0, 5.3.0, 6.1.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* Android: + + + Clang: 3.6, 3.7, 3.8 + + GCC: 4.9, 5.4 + + GCC, C++14: 6.2 +* FreeBSD: + + + Clang: 3.8.0 + + Clang, C++11: 3.8.0 + + Clang, C++14: 3.8.0 + + Clang, C++1z: 3.8.0 +* SunOS: + + + Oracle Solaris Studio: 12.5\_next, 12.5 + + Oracle Solaris Studio, C++11: 12.5\_next, 12.5 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Eric Niebler, + [Rene Rivera](/users/people/rene_rivera.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_65_1.html b/users/history/version_1_65_1.html new file mode 100644 index 0000000..3abc0a7 --- /dev/null +++ b/users/history/version_1_65_1.html @@ -0,0 +1,449 @@ +--- +title: Version 1.65.1 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.65.1 + +/\*\*/ + + + + + + + +Version 1.65.1 +============== + +Version 1.65.1 +-------------- + + +September 7th, 2017 17:31 GMT + + +[Documentation](/doc/libs/1_65_1/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_65\_1.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.65.1/source/boost_1_65_1.tar.bz2) | 9807a5d16566c57fd74fb522764e0b134a8bbe6b6e8967b83afefd30dcd3be81 | +| [boost\_1\_65\_1.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.65.1/source/boost_1_65_1.tar.gz) | a13de2c8fbad635e6ba9c8f8714a0e6b4264b60a29b964b940a22554705b6b60 | +| windows | [boost\_1\_65\_1.7z](https://boostorg.jfrog.io/artifactory/main/release/1.65.1/source/boost_1_65_1.7z) | df7bea4ce58076bd8e9cd63966562d8cf969b431e1c587969e6aa408e51de606 | +| [boost\_1\_65\_1.zip](https://boostorg.jfrog.io/artifactory/main/release/1.65.1/source/boost_1_65_1.zip) | d1775aef807bd6a14077b450cce2950d8eacd86aaf51015f79e712917f8cc3c2 | + + +### Third Party Downloads + + +* [Windows Binaries](https://boostorg.jfrog.io/artifactory/main/release/1.65.1/binaries/) + + +### Fixes in 1.65.1 + + +* [Config](/libs/config/): + + + Version macro changes for CUDA. + + Update last known MSVC version. + + MSVC 14.11 supports structured bindings. +* [Context](/libs/context/): + + + Return a continuation from functions executed by `resume\_with`. +* [Fiber](/libs/fiber/): + + + Return a continuation from functions executed by `resume\_with`. +* [Smart Pointers](/libs/smart_ptr/): + + + Fix Visual C++ version checks. + + Fix compilation for NVCC with host compiler clang. +* [Stacktrace](/libs/stacktrace/): + + + Update build testing file to detail with a MinGW issue. + + Change preprocessor file extensions to work with the installation + system. + + Support FreeBSD and other OSs that do not define `\_GNU\_SOURCE` + but have `\_Unwind\_Backtrace` + function. +* [Thread](/libs/thread/): + + + Fix bug in `boost::condition\_variable` + on Windows ([#130](https://github.com/boostorg/thread/issues/130)). + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 4.0.1, 5.0.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 5.0.0 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 5.0.0 + + Clang, C++17: 5.0.0 + + Clang, C++1z: 4.0.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.7.2, 5.4.0, 7.1.0 + + GCC, C++11: 4.4.7, 4.7.2, 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0 + + GCC, C++14: 5.4.0, 5.4.1, 6.3.0, 6.4.0, 7.1.0, 7.2.0 + + GCC, C++17: 7.1.0 + + GCC, C++1z: 6.3.0 + + Intel: 17.0 +* OS X: + + + Clang: 8.1.0 + + Clang, C++11: 8.1.0 + + Clang, C++14: 8.1.0 + + Clang, C++1z: 8.1.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++11: 4.6.4, 4.7.3, 4.8.1 + + GCC, C++14: 4.9.3, 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0, + 7.1.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* Android: + + + Clang: 3.6, 3.7, 3.8 + + GCC: 4.9, 5.4 + + GCC, C++14: 6.2 +* FreeBSD: + + + Clang: 3.8.0 + + Clang, C++11: 3.8.0 + + Clang, C++14: 3.8.0 + + Clang, C++1z: 3.8.0 +* QNX: + + + QCC, C++11: 4.4.2 +* SunOS: + + + Oracle Solaris Studio: 12.5\_next, 12.5 + + Oracle Solaris Studio, C++11: , 12.5\_next, 12.5 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + +### New Libraries in + 1.65.0 + + +* [PolyCollection](/libs/poly_collection/): + Fast + containers of polymorphic objects, from Joaquín M López Muñoz. +* [Stacktrace](/libs/stacktrace/): + Gather, store, + copy and print backtraces, from Antony Polukhin. + + + Note: Library has [issue + with MinGW](https://github.com/boostorg/stacktrace/issues/14) and may produce empty backtraces with that compiler. + +### Removed Libraries + in 1.65.0 + + +* TR1 + +### Updated Libraries + in 1.65.0 + + +* [Asio](/libs/asio/): + + + Changed to require g++ versions >= 4.7 to use + standard atomics, to fix a linker error when using g++ + 4.6 ([#13121](https://svn.boost.org/trac/boost/ticket/13121)). + + Enabled use of `constexpr` + and variadic templates with recent MSVC versions. + + Fixed a race condition in the Linux epoll backend, which may occur + when a socket or descriptor is closed while another thread is blocked + on epoll. + + Eliminated use of deprecated `auto\_ptr`. + + Fixed misplaced use of `asio\_handler\_is\_continuation` + result in reactive `async\_accept` + implementation. + + Changed to use `poll.h` + rather than `sys/poll.h` on some modern POSIX platforms + ([#12419](https://svn.boost.org/trac/boost/ticket/12419)). + + Fixed MSVC intellisense detection. + + Disabled use of the `\_\_thread` + keyword extension for android/clang/x86 targets. +* [Context](/libs/context/): + + + Improvements: + + - call/cc supports ucontext-API (swapcontext) + - call/cc supports Windows-Fiber-API + - call/cc supports on demand growing (segmented/split) stacks + + Bugfixes: + + - [#12719](https://svn.boost.org/trac/boost/ticket/12719): context test cases and examples segmentation fault + when built with mingw-w64 toolchain + - #52: Failing to build callcc test with g++-4.9 + + important: + + - required bug fix [420554fe9ac01482990e8ae314f4f7ba81010c9a](https://github.com/boostorg/context/commit/420554fe9ac01482990e8ae314f4f7ba81010c9a) + not included in 1.65 +* [Config](/libs/config/): + + + Added `BOOST\_NO\_CXX11\_POINTER\_TRAITS`, + `BOOST\_NO\_CXX17\_FOLD\_EXPRESSIONS`, + `BOOST\_NO\_CXX17\_INLINE\_VARIABLES`, + `BOOST\_NO\_CXX17\_STRUCTURED\_BINDINGS` + defect detection. + + BOOST\_FALLTHROUGH support for GCC 7 and above. (Glen Fernandes) +* [Core](/libs/core/): + + + Implemented `pointer\_traits` + for C++03 and higher, that implements [P0653r0](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0653r0.html) + (Glen Fernandes). This implementation is now used by Align, Circular + Buffer, Fiber, Geometry, among other libraries. + + Added `BOOST\_TEST\_GT` + and `BOOST\_TEST\_GE` + to Lightweight Test. +* [Coroutine2](/libs/coroutine2/): + + + supports ucontext-API (swapcontext) + + supports Windows-Fiber-API + + [#13064](https://svn.boost.org/trac/boost/ticket/13064): different behavior coroutine and coroutine2 +* [DLL](/libs/dll/): + + + Fix PE parsing on non Windows platforms. +* [Fiber](/libs/fiber/): + + + Improvements: + + - hardware transactional memory (Intel TSX) supported + - NUMA supported + - ucontext-API (swapcontext) supported + - Windows-Fiber-API supported + - on demand growing stacks + + Bugfixes: + + - #121: failing to build static lib with GCC 4.8 and C++11 + - #123: assertion failure in schedule\_from\_remote + - #125: erratic crashes in testsuite + - #126: incorrect std::memory\_order value in compare\_exchange\_strong? + + important: + + - required bug fix [63f1041f0e484e64dec437a0fa780ea2463abda2](https://github.com/boostorg/fiber/commit/63f1041f0e484e64dec437a0fa780ea2463abda2) + not included in 1.65 +* [Fusion](/libs/fusion/): + + + MSVC 14.1 supports variadic containers, such as `fusion::vector`, + `fusion::deque`, `fusion::map`, + `fusion::set`, and `fusion::tuple`. + ([#12986](https://svn.boost.org/trac/boost/ticket/12986)) +* [Geometry](/libs/geometry/): + + + Improvements: + + - Add correct() overload taking area strategy + - Add is\_convex() overload taking side strategy + - Add missing relational operations (covered\_by, crosses, equals, + etc.) for MultiPoint/AnyGeometry + + Solved issues: + + - [12410](https://svn.boost.org/trac/boost/ticket/12410) + Lack of support of geographic coordinate system in correct() + - [13035](https://svn.boost.org/trac/boost/ticket/13035) + Wrong result of non-cartesian intersection strategies for segments + near poles. + - [13057](https://svn.boost.org/trac/boost/ticket/13057) + Wrong result of intersects() for linestrings caused by numerical + issue in disjoint() for boxes. + + Bugfixes: + + - Fix is\_valid which could return false for multipolygons where + an interior ring touches another interior ring + - Fix is\_valid which could return false for multipolygons where + a polygon was located in an interior ring, all touching each + other + - Fix union which could produce invalid results (for some cases, + this needs to define BOOST\_GEOMETRY\_INCLUDE\_SELF\_TURNS) + - Fix intersection (idem), but some cases are still not yet valid + - Fix difference (idem), but some cases are still not yet valid + - Fix propagation of area strategy into the internals of various + algorithms from intersection strategy + - Fix uninitialized variable in relate and reference to temporary + in overlay + - Fix error in disjoint for geographic Segment/Box + - Fix handling of non-cartesian geometries in various algorithms +* [Hash](/libs/functional/hash/): + + + Support for `char16\_t`, + `char32\_t`, `u16string`, `u32string`. +* [Log](/libs/log/): + + + General changes: + + - Improved compatibility with Solaris. + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Phoenix](/libs/phoenix/): + + + Corrected some documentation. ([PR#50](https://github.com/boostorg/phoenix/pull/50)) + + `phoenix::erase` with associative container + returns iterator in C++11 mode. ([#7423](https://svn.boost.org/trac/boost/ticket/7423)) + + `std::set` and `std::multiset` + should be worked with predefined lazy functions. ([PR#52](https://github.com/boostorg/phoenix/pull/52)) + + Disable `phoenix::random\_shuffle` in C++17. ([PR#53](https://github.com/boostorg/phoenix/pull/53)) + + Don't forward declare, include instead. ([#11875](https://svn.boost.org/trac/boost/ticket/11875)) +* [Predef](/libs/predef/): + + + Fix Intel C/C++ version 9999 detection to be 12.1.0. + + Addition of `BOOST\_PREDEF\_WORKAROUND` + and `BOOST\_PREDEF\_TESTED\_AT` + macros for defect workarounds and detection. + + Add ARM64 MSVC SIMD detection. (from Minmin Gong) + + Add detection of iOS simulator vs device as a platform choice. (from + Ruslan Baratov) + + Fix MinGW incorrect header guard. (from Ruslan Baratov) +* [Program Options](/libs/program_options/): + + + Support for storing values into `boost::optional`, + thanks to Ed Catmur ([#7495](https://svn.boost.org/trac/boost/ticket/7495), + [PR#18](https://github.com/boostorg/program_options/pull/18)) + + Parsing of implicit options can now use the value from the next token. + Since 1.59, unless the value of implicit option was specified in + the same token as the option itself, the implicit value was used. + That proved inconvenient, and now we again check the next token and + use it as value if it's not an option itself. ([#25](https://github.com/boostorg/program_options/issues/25)) +* [Python](/libs/python/): + + + `eval()`, + `exec()`, + and `exec\_statement()` now allow `char + const \*` + arguments, in addition to `boost::python::str`. + + The `boost::python::numeric` API has been removed, as + it is being obsoleted by `boost::python::numpy`. + + Fix some build issues when using Python3 with MSVC. +* [Smart Pointers](/libs/smart_ptr/): + + + New class template`atomic\_shared\_ptr`, + that provides thread-safe atomic pointer operations over `shared\_ptr`. (Peter Dimov) + + New class template `local\_shared\_ptr`, + where the reference count is updated with non-atomic operations. + (Peter Dimov) + + More optimizations in `allocate\_shared` + and `make\_shared` for + arrays. (Glen Fernandes) + + Documentation has been completely rewritten in Asciidoc format. +* [Test](/libs/test/): + + + Boost.test v3.6 see the [Change + log](/doc/libs/1_65_0/libs/test/doc/html/boost_test/change_log.html) section for more details. + + New feature: + + - C++17 compatibility (tested on VS2017), thanks to [Daniela + Engert](https://github.com/DanielaE) + - Direct comparison of C-arrays in `BOOST\_TEST` + - Better global fixtures mechanism, and spitting of responsibilities + with [`BOOST\_TEST\_GLOBAL\_FIXTURE`](/doc/libs/1_65_0/libs/test/doc/html/boost_test/utf_reference/test_org_reference/test_org_boost_test_global_fixture.html) + for global fixtures and [`BOOST\_TEST\_GLOBAL\_CONFIGURATION`](/doc/libs/1_65_0/libs/test/doc/html/boost_test/utf_reference/link_references/link_boost_test_global_configuration.html) + for global initialization (compile time configuration). + - Improved support for fixtures (`setup` + / `teardown` + member function) which enables better teardown time checks + + Breaking changes + + - Some API changes for the loggers + - Deprecating `BOOST\_GLOBAL\_FIXTURE` + in favor of `BOOST\_TEST\_GLOBAL\_FIXTURE` + and `BOOST\_TEST\_GLOBAL\_CONFIGURATION` + (see above) + + Bug fixes + + - Trac tickets [#5282](https://svn.boost.org/trac/boost/ticket/5282), [#5563](https://svn.boost.org/trac/boost/ticket/5563), [#11471](https://svn.boost.org/trac/boost/ticket/11471), [#11962](https://svn.boost.org/trac/boost/ticket/11962), + [#12228](https://svn.boost.org/trac/boost/ticket/12228) + - Trac tickets [#12631](https://svn.boost.org/trac/boost/ticket/12631), [#13011](https://svn.boost.org/trac/boost/ticket/13011) + - Pull request [PR106](https://github.com/boostorg/test/pull/106) +* [Thread](/libs/thread/): + + + Important Regression on Windows: + + - [#130](https://github.com/boostorg/thread/issues/130) + windows: Bug in boost::condition\_variable on Windows Please, + merge these two patches + - + - + + Bug fixes + + - [#6787](http://svn.boost.org/trac/boost/ticket/6787) + boost::thread::sleep() hangs if system time is rolled back + - [#12519](http://svn.boost.org/trac/boost/ticket/12519) + boost::thread::try\_join\_for does not return after timeout + - [#12874](http://svn.boost.org/trac/boost/ticket/12874) + future<> extension constructor must be under BOOST\_THREAD\_PROVIDES\_FUTURE\_UNWRAP + - [#12888](http://svn.boost.org/trac/boost/ticket/12888) + Linking with boost thread does not work on mingw/gcc 4.4 + - [#12958](http://svn.boost.org/trac/boost/ticket/12958) + sync\_bounded\_queue::wait\_pull\_front( lve ) might throw + - [#13077](http://svn.boost.org/trac/boost/ticket/13077) + Linking to static 64bit libboost\_thread fails DLL initialization + - [#13155](http://svn.boost.org/trac/boost/ticket/13155) + log doesn't build on a system with pthreads + - [#121](https://github.com/boostorg/thread/issues/121) + on\_tls\_prepare is broken under VS2017 +* [TypeIndex](/libs/type_index/): + + + Include if required, thanks to + Ed Catmur [#13009](https://svn.boost.org/trac/boost/ticket/13009). + + Use native `hash\_code()` when possible on GCC-like compilers + [#13027](https://svn.boost.org/trac/boost/ticket/13027). + + Fix `ctti\_type\_index` + for GCC 7 and later, thanks to Benjamin Buch [PR16](https://github.com/boostorg/type_index/pull/16). +* [Typeof](/libs/typeof/): + + + Fix compilation error with clang-cl [ticket + 11821](https://svn.boost.org/trac10/ticket/11821). +* [Unordered](/libs/unordered/): + + + Use the same data structure for `unordered\_set` + and `unordered\_multiset`, + and for`unordered\_map` + and `unordered\_multimap`. + This is required for C++17, so that nodes can be merged and extracted + between compatible containers. + + Add deprecated attributes to long deprecated functions. + + Improved use of `allocator\_traits` + `construct` and `destroy` on C++11 compilers, using + piecewise pair construction when appropriate. + + Fewer workarounds on newer Oracle compilers. + + Avoid dereferencing pointers to uninitialized memory ([PR + #5](https://github.com/boostorg/unordered/pull/5)). +* [Utility](/libs/utility/): + + + Improved compatibility of `boost::next`/`boost::prior` with SFINAE-unfriendly iterators. + [#10847](https://svn.boost.org/trac/boost/ticket/10847), [#13002](https://svn.boost.org/trac/boost/ticket/13002). +* [Variant](/libs/variant/): + + + r-value overload for `boost::get` + was added by Albert Sverdlov [#13018](https://svn.boost.org/trac/boost/ticket/13018). + + Missing include fro `` + header was added by Adam Badura [#13037](https://svn.boost.org/trac/boost/ticket/13037). + + `boost::make\_variant\_over` was fixed and + now works with views and other Forward Sequences (thanks to Mikhail + Maksimov for the fix) [#8554](https://svn.boost.org/trac/boost/ticket/8554), [#10041](https://svn.boost.org/trac/boost/ticket/10041), [PR#35](https://github.com/boostorg/variant/pull/35). + + + + + + + + + + + diff --git a/users/history/version_1_66_0.html b/users/history/version_1_66_0.html new file mode 100644 index 0000000..48cef1f --- /dev/null +++ b/users/history/version_1_66_0.html @@ -0,0 +1,481 @@ +--- +title: Version 1.66.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.66.0 + +/\*\*/ + + + + + + + +Version 1.66.0 +============== + +Version 1.66.0 +-------------- + + +December 18th, 2017 13:58 GMT + + +[Documentation](/doc/libs/1_66_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_66\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.66.0/source/boost_1_66_0.tar.bz2) | 5721818253e6a0989583192f96782c4a98eb6204965316df9f5ad75819225ca9 | +| [boost\_1\_66\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.66.0/source/boost_1_66_0.tar.gz) | bd0df411efd9a585e5a2212275f8762079fed8842264954675a4fddc46cfcf60 | +| windows | [boost\_1\_66\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.66.0/source/boost_1_66_0.7z) | 596389389c005814ecb2a6b64c31dccd2c3e6fbc5a802b4dfada999ae5844628 | +| [boost\_1\_66\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.66.0/source/boost_1_66_0.zip) | e1c55ebb00886c1a96528e4024be98a38b815115f62ecfe878fcf587ba715aad | + + +### Third Party Downloads + + +* [Windows Binaries](https://boostorg.jfrog.io/artifactory/main/release/1.66.0/binaries/) + + +### Note about + the new Visual Studio release + Visual Studio 15.5 was released too late for us to test this release with it. + + +### New Libraries + + +* [Beast](/libs/beast/): + Portable HTTP, WebSocket, + and network operations using only C++11 and Boost.Asio, from Vinnie Falco. +* [CallableTraits](/libs/callable_traits/): + A spiritual + successor to Boost.FunctionTypes, Boost.CallableTraits is a header-only + C++11 library for the compile-time inspection and manipulation of all 'callable' + types. Additional support for C++17 features, from Barrett Adair. +* [Mp11](/libs/mp11/): + A C++11 metaprogramming library, + from Peter Dimov. + +### Updated Libraries + + +* [Asio](/libs/asio/): + + + Implemented interface changes to reflect the Networking TS ([N4656](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4656.pdf)). + + - See the [list](/doc/libs/1_66_0/doc/html/boost_asio/net_ts.html) + of new interfaces and, where applicable, the corresponding + old interfaces that have been superseded. + - The service template parameters, and the corresponding classes, + are disabled by default. For example, instead of `basic\_socket` + we now have simply `basic\_socket`. The old interface can + be enabled by defining the `BOOST\_ASIO\_ENABLE\_OLD\_SERVICES` + macro. + + Removed previously deprecated functions. + + Added support for customised handler tracking. + + Added reactor-related (i.e. descriptor readiness) events to handler + tracking. + + Added special "concurrency hint" values that may be used + to disable locking on a per `io\_context` + basis. + + Enabled perfect forwarding for the first `ssl::stream<>` constructor argument. + + Added ability to release ownership of the underlying native socket. + (Requires Windows 8.1 or later when using the I/O completion port + backend.) +* [Atomic](/libs/atomic/): + + + Implemented a set of experimental extended atomic operations for + integral types: + + - `fetch\_negate`, + `fetch\_complement` + - atomically replaces the value with a negated or binary complemented + value and returns the original value + - `opaque\_` + - equivalent to `fetch\_` except that it doesn't + return the original value + - `\_and\_test` + - atomically applies `` + and returns `true` + if the result is zero. **Note:** + The result of these operations will change to the opposite + in Boost 1.67. The code that uses these functions will need + to be updated. + - `bit\_test\_and\_set`, + `bit\_test\_and\_reset`, + `bit\_test\_and\_complement` + - atomically sets, resets or complements the specified bit + and returns the original value of the bit + + Following C++17 ([P0558R1](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0558r1.pdf)), + arithmetic operations for pointers to non-object types are no longer + provided. + + Also following C++17 exposed `atomic::value\_type` + and `atomic::difference\_type` member typedefs, + where applicable, to the user's code. + + Improved compatibility with gcc 7. In particular, using 128-bit operations + on x86-64 should no longer require linking with libatomic (the compiler-supplied + library). +* [DateTime](/libs/date_time/): + + + The library has been converted to use Boost.WinAPI as the abstraction + layer for Windows SDK. + + Fixed an integral overflow that could cause incorrect results when + adding or subtracting many years from a date (see [here](https://stackoverflow.com/questions/45537280/boost-datetime-issue-with-adding-long-year-durations)). +* [Fiber](/libs/fiber/): + + + synchronization with CUDA streams + + synchronization with ROCm/HIP streams +* [Format](/libs/format/): + + + Improvements: + + - Accept new conversion specifiers: + + * [`a`](https://github.com/boostorg/format/pull/41): sets flags + `fixed | scientific` + (i.e. `hexfloat`) + * [`b`](https://github.com/boostorg/format/pull/43): sets flag + `boolalpha` + * [`A`](https://github.com/boostorg/format/pull/41): same as + `a` plus + flag `uppercase` + * [`F`](https://github.com/boostorg/format/pull/41): same as + `f` plus + flag `uppercase` + - [42](https://github.com/boostorg/format/pull/42) + Accept new argument types `j` + and `z` from + ISO C99 (parsed and ignored like all others). + - [44](https://github.com/boostorg/format/pull/44) + Accept new argument types `I`, + `I32`, `I64`, and `w` + from Microsoft (parsed and ignored like all others). + - [33](https://github.com/boostorg/format/issues/33) + Added a development tool called `format\_matrix` + that exercises as many different combinations of format strings + as possible and logs them to a file: + + * helps prevent regressions in between boost releases + * allows for comparison against `snprintf` + + Bugfixes: + + - [36](https://github.com/boostorg/format/issues/36) + Safely allow volatile arguments to be used with operator% + - [4636](https://svn.boost.org/trac10/ticket/4636) + Explicit clamping provided to allow MSVC /RTCc to succeed + - [7477](https://svn.boost.org/trac10/ticket/7477) + Fix compatibility with MSVC /Za + - [10324](https://svn.boost.org/trac10/ticket/10324) + Const-correct cast issue resolved + - [11632](https://svn.boost.org/trac10/ticket/11632) + Fix `-fsanitize=undefined` + issue in `alt\_sstream.hpp` +* [Fusion](/libs/fusion/): + + + [PR#149](https://github.com/boostorg/fusion/pull/149) + `isspace(c)` + is not a macro in Dinkum clib for VxWorks, thanks to Brian Kuhl(@kuhlenough). + + [PR#150](https://github.com/boostorg/fusion/pull/150) + Remove circular preprocessor include, thanks to Gregor Jasny(@gjasny). + + [PR#151](https://github.com/boostorg/fusion/pull/151) + Change base of `fusion::tuple`. + + [PR#153](https://github.com/boostorg/fusion/pull/153) + Fixed compile error with `std::array`. + + [PR#154](https://github.com/boostorg/fusion/pull/154) + Fixed bugs nesting and copying on c++03. +* [Geometry](/libs/geometry/): + + + Improvements: + + - Add distance for geographic PointLike/AnyGeometry. + + Bugfixes: + + - Fixes in results of union/intersection/difference which could + be incorrect in very complex cases + - Fixes in validity of union/intersection/difference/buffer + - Fixes in set and relational operations for non-cartesian coordinate + systems. +* [Iterator](/libs/iterator/): + + + `next()`/`prior()` + functions now support user's iterators that don't specify nested + types such as `iterator\_category`, + `difference\_type`, + etc. and instead specialize `std::iterator\_traits` + to define those types. The compiler must support C++17-compatible + `std::iterator\_traits` for this to work. +* [Log](/libs/log/): + + + Bug fixes: + + - Fixed a bug in `file\_collector::scan\_for\_files` + that could cause incorrectly named log files in the target + directory after the user's application restart. + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Math](/libs/math/): + + + New Features: + + - Add Gauss and Gauss-Kronrod quadrature routines. + - Add double-exponential (tanh-sinh, exp-sinh and sinh-sinh) + quadrature routines. + - Add Chebyshev polynomial evaluation, roots, integration, differentiation, + and interpolation routines. +* [Multi-index Containers](/libs/multi_index/index.html): + + + Made `modify` and + `modify\_key` more robust + so that the modified element is erased if the modifier throws or + the rollback functor does not properly restore the element (full + discussion at ticket [#12542](https://svn.boost.org/trac/boost/ticket/12542)). This is technically backwards + incompatible; for instance, the following code: + + + ``` + c.modify(c.begin(),[](auto&){throw 0;}); + + ``` + + + keeps the container `c` + untouched in former versions of Boost whereas now `c.begin()` is erased. Thanks to Jon Kalb for + raising the issue. + + Maintenance fixes. +* [Optional](/libs/optional/index.html): + + + On newer compilers `optional` + is now trivially-copyable for scalar `T`s. + This uses a different storage (just `T` + rather than `aligned\_storage`). + We require the compiler to support defaulted functions. + + Changed the implementation of `operator==` to get rid of the `-Wmaybe-uninitialized` + false-positive warning from GCC. +* [PolyCollection](/libs/poly_collection/): + + + Boost.PolyCollection has been backported to GCC 4.8 to 4.9 and Clang + 3.3 to 3.6. The version of libstdc++-v3 shipped with GCC 4.8 (which + can also be used by Clang) has deficiencies that result in the following + limitations when using Boost.PolyCollection: + + - Stateful allocators are not properly supported. + - Allocator-extended move construction decays to allocator-extended + copy construction. + - Copy construction crashes if an exception is thrown during + element copying. + + Maintenance fixes. +* [Predef](/libs/predef/): + + + Improved Windows Universal Platform detection. (from James E. King, + III) + + Add detection for CloudABI with cloudlibc. (from James E. King, III) + + Various other bug fixes. +* [Regex](/libs/regex/): + + + Bug fixes: + + - Numerous small fixes for security issues discovered by de-fuzzing. +* [Stacktrace](/libs/stacktrace/): + + + Now works out-of-the-box on MinGW-w64. + + Now works on MinGW (without `-w64`) if `libbacktrace` + is properly installed. See "MinGW specific notes" section + in documentation for more info. +* [Thread](/libs/thread/): + + + Bugs Fixes + + - [#12323](http://svn.boost.org/trac/boost/ticket/12323) + windows - boost/thread/win32/mfc\_thread\_init.hpp has wrong + signature for \_pRawDllMainOrig + - [#12730](http://svn.boost.org/trac/boost/ticket/12730) + windows - static threads library is incompatible with MSVC + 2017 RC + - [#12976](http://svn.boost.org/trac/boost/ticket/12976) + Boost Thread Executors documentation mistakes + - [#12949](http://svn.boost.org/trac/boost/ticket/12949) + using sleep\_for in a thread context without including boost/thread/thread.hpp + yields incorrect behaviour when BOOST\_THREAD\_HAS\_CONDATTR\_SET\_CLOCK\_MONOTONIC + is defined + - [#13019](http://svn.boost.org/trac/boost/ticket/13019) + ABI compatibility for BOOST\_THREAD\_PROVIDES\_INTERRUPTIONS incomplete + - [#13069](http://svn.boost.org/trac/boost/ticket/13069) + Boost unit test "sync\_pq\_multi\_thread\_p\_lib.exe" + hung in thread library + - [#13163](http://svn.boost.org/trac/boost/ticket/13163) + boost::detail::heap\_new does not have a variadic variant + - [#13226](http://svn.boost.org/trac/boost/ticket/13226) + getpagesize() is deprecated since 199506L + - [#132](https://github.com/boostorg/thread/issues/132) + VS 2017.4 Preview deadlocks on Test 10964 + - [#133](https://github.com/boostorg/thread/issues/133) + windows - Spurious timing test failures on windows + - [#134](https://github.com/boostorg/thread/issues/134) + VS 2017.4 Preview deadlock in sync\_pq\_multi\_thread\_p\_lib.exe + - [#135](https://github.com/boostorg/thread/issues/135) + VS 2017.4 Preview test\_scheduled\_tp\_p.exe deadlock + - [#136](https://github.com/boostorg/thread/issues/136) + VS 2017.4 Preview test\_scheduler\_p.exe deadlock + - [#137](https://github.com/boostorg/thread/issues/137) + VS 2017.4 Preview executor\_ex.exe deadlock + - [#143](https://github.com/boostorg/thread/issues/143) + Failures on msvc-12.0 + - [#145](https://github.com/boostorg/thread/issues/145) + Clang build error with BOOST\_THREAD\_ATTRIBUTE\_MAY\_ALIAS + + New Experimental Feature + + - [#116](https://github.com/boostorg/thread/issues/116) + [Proposal] Add APIs for deferred set\_value/exception +* [Utility](/libs/utility/): + + + `boost/next\_prior.hpp` has been moved to Boost.Iterator. + No changes needed to the user's code. +* [Uuid](/libs/uuid/): + + + Improvements: + + - [26](https://github.com/boostorg/uuid/issues/26) + Refactored `name\_generator` + to support a configurable hash provider concept and provide + an optional MD5 hash implementation per RFC-4122. This will + make it easier to support whatever becomes the next standard + hash algorithm. + - [34](https://github.com/boostorg/uuid/issues/34) + Added RFC-4122 namespaces in `boost::uuids::ns`. + + Bugfixes: + + - [8630](https://svn.boost.org/trac10/ticket/8630) + [11482](https://svn.boost.org/trac10/ticket/11482) + [12253](https://svn.boost.org/trac10/ticket/12253) + Various deficiencies in `string\_generator` + were resolved. + - [10665](https://svn.boost.org/trac10/ticket/10665) + `name\_generator::operator()` is now const, matching docs. + - Detail headers were moved into the detail subdirectory. No + changes needed to user's code, however you may get build warnings + if you use the old header location. +* [Variant](/libs/variant/): + + + `boost::apply\_visitor` now does perfect + forwarding of visitables [#6971](https://svn.boost.org/trac/boost/ticket/6971). Great thanks to Levon Tarakchyan + for implementing this feature. + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 4.0.1, 5.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 5.0.1 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.1 + + Clang, C++17: 5.0.1 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.7.2, 5.4.0, 7.2.0 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.2, 4.7.3, 4.8.5, 4.9.4, 6.4.0, 7.1.0, 7.2.0 + + GCC, C++14: 5.4.1, 6.3.0, 6.4.0, 7.1.0, 7.2.0, 7.2.1 + + GCC, C++17: 7.2.0 + + Intel: 18.0 +* OS X: + + + Clang: 9.0.0 + + Clang, C++11: 9.0.0 + + Clang, C++14: 9.0.0 + + Clang, C++1z: 9.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* Android: + + + Clang: 3.6, 3.7, 3.8 + + GCC: 4.9, 5.4 + + GCC, C++14: 6.2 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 +* QNX: + + + QCC, C++0x: 4.4.2 + + QCC, C++11: 4.7.3 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.8.1, 4.0.1, 5.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 5.0.1 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.1 + + Clang, C++17: 5.0.1 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.7.2, 5.4.0, 7.2.0 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.2, 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 7.2.0 + + GCC, C++14: 5.4.1, 6.3.0, 6.4.0, 7.1.0, 7.2.0, 7.2.1, 8.0.0 + + GCC, C++17: 7.2.0 + + Intel: 18.0 +* OS X: + + + Clang: 9.0.0 + + Clang, C++11: 9.0.0 + + Clang, C++14: 9.0.0 + + Clang, C++1z: 9.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0, 7.1.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* Android: + + + Clang: 3.6, 3.7, 3.8 + + GCC: 4.9, 5.4 + + GCC, C++14: 6.2 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 +* QNX: + + + QCC, C++0x: 4.4.2 + + QCC, C++11: 4.7.3 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_67_0.html b/users/history/version_1_67_0.html new file mode 100644 index 0000000..8fd3492 --- /dev/null +++ b/users/history/version_1_67_0.html @@ -0,0 +1,713 @@ +--- +title: Version 1.67.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.67.0 + +/\*\*/ + + + + + + + +Version 1.67.0 +============== + +Version 1.67.0 +-------------- + + +April 14th, 2018 20:37 GMT + + +[Documentation](/doc/libs/1_67_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_67\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.67.0/source/boost_1_67_0.tar.bz2) | 2684c972994ee57fc5632e03bf044746f6eb45d4920c343937a465fd67a5adba | +| [boost\_1\_67\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.67.0/source/boost_1_67_0.tar.gz) | 8aa4e330c870ef50a896634c931adf468b21f8a69b77007e45c444151229f665 | +| windows | [boost\_1\_67\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.67.0/source/boost_1_67_0.7z) | 1cd94f03a71334a67d36f5161b57f5931e0cd6ecf726d7aca8bd82a3be720b74 | +| [boost\_1\_67\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.67.0/source/boost_1_67_0.zip) | 7e37372d8cedd0fd6b7529e9dd67c2cb1c60e6c607aed721f5894d704945a7ec | + + +### Third Party Downloads + + +* [Windows Binaries](https://boostorg.jfrog.io/artifactory/main/release/1.67.0/binaries/) + + +### Known Issues + These are patches from library authors which were found too late to be fixed + in the release. Be careful as they have not been through the normal testing + process. + + + +* Fix compiling with FreeBSD: + + + + + +* Fix Python auto-linking: + + + + +### New Libraries + + +* [Contract](/libs/contract/): + Contract programming + for C++. All contract programming features are supported: Subcontracting, + class invariants, postconditions (with old and return values), preconditions, + customizable actions on assertion failure (e.g., terminate or throw), optional + compilation and checking of assertions, etc, from Lorenzo Caminiti. +* [HOF](/libs/hof/): + Higher-order functions for C++, + from Paul Fultz II. + +### Updated Libraries + + +* [Asio](/libs/asio/): + + + Added missing const qualifier to `basic\_socket\_acceptor::get\_option`. + + Worked around a parsing error that occurs with some versions of gcc. + + Fixed broken code samples in tutorial. + + Added new experimental features. (Note that "experimental" + features may be changed without notice in subsequent releases.) + + - Added `experimental::detached` + completion token. + - Added `experimental::redirect\_error` + completion token. + - Added `experimental::co\_spawn` + facility for integration with the coroutines technical specification. + - Updated timeout examples to use latest features. + - Used `asio::steady\_timer` rather than + `asio::deadline\_timer`. + - Used `asio::dynamic\_buffer` rather than + `asio::streambuf`. + - Used timed `asio::io\_context::run\_for()` function for blocking clients. + - Added example showing a custom completion token for blocking + with timeouts. + + Fixed unit tests to compile when `BOOST\_ASIO\_NO\_DEPRECATED` + is defined. + + Changed socket iostreams to use chrono by default, to fix compatibility + with the Networking TS. Define `BOOST\_ASIO\_USE\_BOOST\_DATE\_TIME\_FOR\_SOCKET\_IOSTREAM` + to enable the old Boost.Date\_Time interface in `basic\_socket\_streambuf` + and `basic\_socket\_iostream`. + + Updated examples to use chrono rather than Boost.Date\_Time. + + Fixed an incorrect member function detector in the `is\_dynamic\_buffer` trait. + + Fixed an `async\_result` + incompatibility with deprecated `handler\_type`. + + Added a missing move optimisation in the SSL stream implementation. + + Fixed incorrect `basic\_resolver\_results::value\_type` + typedef. + + Fixed a compile error with some OpenSSL versions when `SSL\_OP\_NO\_COMPRESSION` is defined. + + Changed `add\_certificate\_authority` + to process multiple certificates in a bundle. + + Eliminated deprecation warning with MSVC by using `std::invoke\_result` + rather than `std::result\_of`. + + Changed to use `std::string\_view` + for C++17 or later, and `std::experimental::string\_view` + for C++14. Define the preprocessor macro `BOOST\_ASIO\_DISABLE\_STD\_STRING\_VIEW` + to force the use of std::experimental::string\_view (assuming it is + available) when compiling in C++17 mode. + + Ensured `DynamicBuffer` + template arguments are decayed before using in `enable\_if` + tests. + + Changed documentation to distinguish legacy completion handlers (which + are still required to be CopyConstructible) from new MoveConstructible + handlers. + + Suppressed a discarded return value warning in the buffer debugging + support. + + Fixed `basic\_yield\_context` + to work with completion signatures containing reference parameters. + + Ensured that stackful coroutines launched using `spawn()` correctly store decayed copies + of their function and handler arguments. + + Fixed some compatibility issues with Android. + + Added cross-compilation support to Jamfiles. + + Fixed some minor portability issues in examples. +* [Atomic](/libs/atomic/): + + + **Breaking change:** Changed the result + of the `(op)\_and\_test` + operations added in Boost 1.66 to the opposite - the functions now + return `true` if the operation + result is non-zero. This is consistent with other `test` + methods in Boost.Atomic and the C++ standard library. Users can define + `BOOST\_ATOMIC\_DETAIL\_HIGHLIGHT\_OP\_AND\_TEST` + when compiling their code to emit warnings on every use of the changed + functions. This way users can locate the code that needs to be updated. + ([#11](https://github.com/boostorg/atomic/issues/11)) + + Update for C++2a. On C++11 compilers that support scoped enums, the + `memory\_order` enumeration + is now scoped and contains constants with shorter names like `acquire`, `release` + or `seq\_cst` (i.e. + users can use `memory\_order::acquire` + instead of `memory\_order\_acquire`). + The old constants are also provided for backward compatibility. ([P0439R0](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0439r0.html)) + + Update for C++2a. Added experimental support for atomic operations + on floating point types. In addition to general operations, `add`, `sub`, + `negate` operations + and their `fetch\_(op)` and `opaque\_(op)` versions are supported. Lock-free + property can be tested with the new macros `BOOST\_ATOMIC\_FLOAT/DOUBLE/LONG\_DOUBLE\_LOCK\_FREE`. + The support for floating point types is optional and can be disabled + by defining `BOOST\_ATOMIC\_NO\_FLOATING\_POINT`. + ([P0020R6](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0020r6.html)) + + Added new experimental operations: + + - `negate\_and\_test` + and `complement\_and\_test` + which perform negation or bitwise complement and return `true` if the result is not zero. + - `add`, `sub`, `negate`, + `bitwise\_and`, + `bitwise\_or`, + `bitwise\_xor`, + `bitwise\_complement` + operations which perform the operation and return its result. + + For generic `atomic` specialization, the default constructor + is now trivial if `T`'s + default constructor is. + + The internal implementation of `atomic` has been updated to avoid undefined + behavior that stems from signed integer overflows. As required by + the C++ standard, the library uses two's complement representation + of signed integers internally and accroding rules of overflow. Currently, + the library requires the native signed integer types to also use + two's complement representation (but no defined overflow semantics). + + Improved Clang support. In particular, fixed DCAS not being lock-free + and fixed possible incorrect code generated on 32-bit x86. + + Improved MinGW support. For gcc versions up to 4.6, fixed compilation + of DCAS on x86. + + In x86 PIE code, asm blocks now preserve `ebx` + value. +* [Beast](/libs/beast/): + + + This version fixes significant defects in `websocket::stream` + which can lead to asserts or undefined behavior. Users are encouraged + to update to the latest Boost release. + + For a complete list of changes, please view the official [Release + Notes](/libs/beast/doc/html/beast/release_notes.html). +* [ContainerHash](/libs/container_hash/): + + + Extracted from the functional module to break a dependency cycle. + + Moved headers to new location to reflect name change, the old include + paths will still work. + + Added support for `std::string\_view`, + `std::error\_code`, `std::error\_condition`, + `std::optional`, `std::variant`, + `std::monostate` where available. + + Added explicit support for `vector`, so that it will work with libc++ + ([#13501](https://svn.boost.org/trac/boost/ticket/13501)). + + More detail in the [library + change log](/doc/html/hash/changes.html#hash.changes.boost_1_67_0). +* [Context](/libs/context/): + + + [#62](https://github.com/boostorg/context/issues/62)/[PR#64](https://github.com/boostorg/context/pull/64): fix i386/macho routines to correctly + return transfer\_t in EAX/EDX + + [#65](https://github.com/boostorg/context/issues/65): `\_\_sanitizer\_finish\_switch\_fiber` + should be called directly after context switch + + [#66](https://github.com/boostorg/context/issues/66): Clang on Windows : error: No best alternative for libs/context/build/asm\_sources + + [#73](https://github.com/boostorg/context/issues/73): fixing C2492 for execution\_context (v1) + + known bug: including all.hpp + ucontext/winfib + causes error 'forced\_unwind: is not a member of boost::context::detail' +* [Core](/libs/core/): + + + Updated `to\_address` + and `pointer\_traits` + to reflect the design adopted for C++2a in [P0653R2](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0653r2.html) + (Glen Fernandes). +* [Coroutine2](/libs/coroutine2/): + + + [#13](https://github.com/boostorg/coroutine2/issues/13): Pull coroutine does not rethrow an exception if + it is thrown on the first entry +* [DateTime](/libs/date_time/): + + + Fixed various year 2038 (32-bit) issues ([#2818](https://svn.boost.org/trac/boost/ticket/2818)) ([#2819](https://svn.boost.org/trac/boost/ticket/2819)) ([#3487](https://svn.boost.org/trac/boost/ticket/3487)) + ([#4543](https://svn.boost.org/trac/boost/ticket/4543)) ([#8450](https://svn.boost.org/trac/boost/ticket/8450)) ([#9158](https://svn.boost.org/trac/boost/ticket/9158)) ([#9489](https://svn.boost.org/trac/boost/ticket/9489)) ([#10570](https://svn.boost.org/trac/boost/ticket/10570)) ([#12609](https://svn.boost.org/trac/boost/ticket/12609)) + + Fixed a binary serialization regression introduced in 1.66.0 ([#56](https://github.com/boostorg/date_time/issues/56)) + ([PR#58](https://github.com/boostorg/date_time/pull/58)) ([PR#70](https://github.com/boostorg/date_time/pull/70)) + + Updated the timezone database file ([#4430](https://svn.boost.org/trac/boost/ticket/4430)) ([#10087](https://svn.boost.org/trac/boost/ticket/10087)) ([PR#68](https://github.com/boostorg/date_time/pull/68)) + + Enhanced `from\_iso\_string` + so it can read output of `to\_iso\_string` + for special values ([#1078](https://svn.boost.org/trac/boost/ticket/1078)) ([PR#69](https://github.com/boostorg/date_time/pull/69)) + + Changed maximum supported year from 10000 to 9999 to resolve various + issues ([#13159](https://svn.boost.org/trac/boost/ticket/13159)) ([#12630](https://svn.boost.org/trac/boost/ticket/12630)) ([PR#71](https://github.com/boostorg/date_time/pull/71)) + + `boost::date\_time::period\_parser::delimiter\_strings` did nothing ([#11142](https://svn.boost.org/trac/boost/ticket/11142)) + ([PR#63](https://github.com/boostorg/date_time/pull/63)) + + Ensure special values are not automatically translated to integral + types ([#11168](https://svn.boost.org/trac/boost/ticket/11168)) ([PR#64](https://github.com/boostorg/date_time/pull/64)) + + `int\_adapter::is\_signed` should be const ([#12363](https://svn.boost.org/trac/boost/ticket/12363)) + ([PR#60](https://github.com/boostorg/date_time/pull/60)) + + `boost::date\_time::time\_input\_facet` throws when using + `%j` + alone ([#12910](https://svn.boost.org/trac/boost/ticket/12910)) ([PR#59](https://github.com/boostorg/date_time/pull/59)) + + Time input facet is not able to parse `%e` day ([#13194](https://svn.boost.org/trac/boost/ticket/13194)) ([PR#54](https://github.com/boostorg/date_time/pull/54)) + + Improved Github CI build environment for better project metrics and + quality ([PR#52](https://github.com/boostorg/date_time/pull/52)) ([PR#72](https://github.com/boostorg/date_time/pull/72)) + + Fixed various compiler warnings ([#3606](https://svn.boost.org/trac/boost/ticket/3606)) ([#9882](https://svn.boost.org/trac/boost/ticket/9882)) ([PR#62](https://github.com/boostorg/date_time/pull/62)) +* [DLL](/libs/dll/): + + + Fixes for calling functions on dirty `GetLastError()` [#16](https://github.com/boostorg/dll/issues/16). +* [Fiber](/libs/fiber/): + + + [#128](https://github.com/boostorg/fiber/issues/128): Assertion "! ctx->ready\_is\_linked()" when + using condition\_variable::wait\_for + + [#132](https://github.com/boostorg/fiber/issues/132): fatal error: 'stdexception' file not found + + [#141](https://github.com/boostorg/fiber/issues/141): boost::fibers::async problem + + [#146](https://github.com/boostorg/fiber/issues/146): remove unecessary lock of remote-ready-queue spinlock + + [#153](https://github.com/boostorg/fiber/issues/153): docu: replace set\_ready() by schedule() + + [#154](https://github.com/boostorg/fiber/issues/154): Document iterators on channels + + [#155](https://github.com/boostorg/fiber/issues/155): this\_fiber is wrongly documented as being a member + of boost::fibers + + [#156](https://github.com/boostorg/fiber/issues/156): Many examples are using their own barrier.hpp + + [#158](https://github.com/boostorg/fiber/issues/158): add BOOST\_FIBERS\_DECL to work\_stealing class + + [#162](https://github.com/boostorg/fiber/issues/162): remove use-coutner increment for timed wait ops + + [#166](https://github.com/boostorg/fiber/issues/166): remove assertion for wait\_is\_linked() in schedule() + + [#167](https://github.com/boostorg/fiber/issues/167): call shared\_state::owner\_destroyed() only if future + was created from + + [#168](https://github.com/boostorg/fiber/issues/168): fiber/doc/installing.qbk not not up to date +* [Filesystem](/libs/filesystem/): + + + Fix static initialization issue that caused a crash if path operations + were used before main() ([PR#62](https://github.com/boostorg/filesystem/pull/62), [PR#43](https://github.com/boostorg/filesystem/pull/43), [PR#50](https://github.com/boostorg/filesystem/pull/50), + [PR#59](https://github.com/boostorg/filesystem/pull/59)) +* [Fusion](/libs/fusion/): + + + Switch to SFINAE in template parameters on `fusion::map` + to fix compile error on newer MSVC 2017. ([PR#164](https://github.com/boostorg/fusion/pull/164)) + + Fix for compilers not compatible with CWG defect 945 on `fusion::vector`. ([PR#166](https://github.com/boostorg/fusion/pull/166)) + + Added limits precheck on sequence converter to make error message + clearer. ([PR#168](https://github.com/boostorg/fusion/pull/168)) + + Allow incomplete types in `fusion::tag\_of` + and `fusion::is\_native\_fusion\_sequence`. Note + that this changes no behaviour from previous release, but compliant + to TypeTraits's change. ([PR#171](https://github.com/boostorg/fusion/pull/171)) +* [Geometry](/libs/geometry/): + + + Improvements: + + - New map projection and SRS transformation representations (undocumented + for now due to potential interface changes). + - New densify() algorithm. + - No longer using std::iterator (thanks to Daniela Engert). + - No longer using allocator directly in the rtree. Replaced with + boost::container::allocator\_traits (thanks to Daniela Engert). + - Default rtree allocator changed to boost::container::new\_allocator + to still support move semantics emulation in C++03 with boost::container::allocator\_traits. + - Area strategies interface changed. This is potentially a breaking + change. + - Radius or Sphere can be passed into spherical strategies. + - Added Point-Box and Box-Box spherical and geographic distance() + strategies. + - Simplify (multi)polygons will discard output rings of 2 points + or (for closed polygons) 3 points, but it tries to avoid creating + those + - Simplify (multi)polygons will omit empty interior rings or + polygons from output + + Solved issues: + + - [13386](https://svn.boost.org/trac10/ticket/13386) + Workaround for some gcc compilers + - [13381](https://svn.boost.org/trac10/ticket/13381) + Compile error with matrix\_transformer in Visual C++ 2015 + - [13436](https://svn.boost.org/trac10/ticket/13436) + Incorrectness in boost::geometry::model::polygon documentation + + Bugfixes: + + - Add missing strategy resolving in length() algorithm, affecting + Variant support. + - Simplify (multi)polygons now simplifies closing point + + Changes in behavior + + - Simplify (multi)polygons now usually rotates input rings before + simplifying to select a non collinear point on its convex hull. + This improves output. +* [Locale](/libs/locale/): + + + Added support of `unique\_ptr` + interface in addition to C++2003 `auto\_ptr` + - in order to support C++2017, now you can use `BOOST\_LOCALE\_HIDE\_AUTO\_PTR` + definiton to remove `auto\_ptr` + from the interfaces and prevent deprecated watnings. + + Fixed test problem with ICU >60.1 + + Fix of solaris build + + Fixed wired FreeBSD/clang issue on optimized build. Probably compiler + workaround + + Added workaround for failing MSVC tests due to 932 codepage codecvt + issue + + Fixed bugs 6851, 12572, 12453 + + Fixed missing throw in case of failure in `icu/date\_time` + + Fixed build agains Boost.Thread v4 + + Fixed Year of week instead of year ICU backend formatting + + Fixed formatting test for ICU 56.1 and above +* [Log](/libs/log/): + + + Improved compatibility with C++17: use `allocator\_traits` + to work with allocators instead of directly accessing its members. + + Improved compatibility with gcc 7 and later by updating library ABI + namespace definition. + + Added documentation for the "Append" config file parameter + for "TextFile" sinks. The parameter was supported previously, + only the documentation was missing. +* [Math](/libs/math/index.html): + + + Add naive Monte Carlo integration support. + + Add Chebyshev interpolation routines. +* [Multi-index Containers](/libs/multi_index/index.html): + + + Elements with overloaded `operator&` are now fully accepted (ticket + [#13307](https://svn.boost.org/trac/boost/ticket/13307)). Thanks to Daniel Frey for his updating [Boost.Operators](/libs/utility/operators.htm#deref) + to help fix this issue. + + Avoided usage of `std::allocator` + members deprecated in C++17. Contributed by Daniela Engert. + + Maintenance fixes. +* [Multiprecision](/libs/multiprecision/index.html): + + + **Breaking Change:** When converting + a multiprecision integer to a narrower type, if the value is too + large (or negative) to fit in the smaller type, then the result is + either the maximum (or minimum) value of the target type. This was + always the intended behaviour, but was somewhat haphazardly enforced + before. If you really do want just the low order N bits of a value, + then you will need to mask these out prior to the case, for example: + `static\_cast(~static\_cast(0) & my\_value)`. Note that technically (to avoid + undefined behaviour) you should do the same thing with built in integer + types too. See [#13109](https://svn.boost.org/trac/boost/ticket/13109). + + Fix bug in conversion of decimal to rational types (zero needs special + handling), see [#13148](https://svn.boost.org/trac/boost/ticket/13148). + + Fix conversion from cpp\_bin\_float to a wider built in integer type, + see [#13301](https://svn.boost.org/trac/boost/ticket/13301). + + Improve performance heurists used in cpp\_bin\_float exp function. + + Fix bug in floor/ceil and cpp\_bin\_float when the exponent type is + wider than an int, see [#13264](https://svn.boost.org/trac/boost/ticket/13264). + + Disable explicit conversion operator when the target type is already + constructible from this type, see [#30](https://github.com/boostorg/multiprecision/issues/30). + + Fix support for changes new to MPIR-3.0, see [#13124](https://svn.boost.org/trac/boost/ticket/13124). +* [Optional](/libs/optional/index.html): + + + Fixed issue [#46](https://github.com/boostorg/optional/issues/46) + + Fixed `-Wzero-as-null-pointer-constant` + warnings. +* [Phoenix](/libs/phoenix/): + + + Correct documentation and example code. ([#8187](https://svn.boost.org/trac/boost/ticket/8187), [PR#56](https://github.com/boostorg/phoenix/pull/56), + [PR#57](https://github.com/boostorg/phoenix/pull/57)) + + Fixed bug with initializing phoenix lazy from array types in C++11. + ([#12733](https://svn.boost.org/trac/boost/ticket/12733), [PR#58](https://github.com/boostorg/phoenix/pull/58), [PR#61](https://github.com/boostorg/phoenix/pull/61)) + + Use proto subscript and assignment overload operators buildins to + fix compile error with some lambda experssions on recent MSVC. ([#62](https://github.com/boostorg/phoenix/issues/62), + [PR#64](https://github.com/boostorg/phoenix/pull/64), [PR#66](https://github.com/boostorg/phoenix/pull/66), [PR#67](https://github.com/boostorg/phoenix/pull/67)) + + Remove use of deprecated `std::iteratror`. + Thanks to Daniela Engert. ([PR#59](https://github.com/boostorg/phoenix/pull/59)) +* [PolyCollection](/libs/poly_collection/): + + + Maintenance fixes. +* [Python](/libs/python/): + + + The library name now includes the version suffix of the Python version + used to compile it. For example, a variant compiled with Python 2.7 + will produce library names `boost\_python27` + and `boost\_numpy27`, + etc.. Combined with a related fix in Boost.Build, this means that + it is now possible to build variants for multiple Python versions + in a single build process. +* [Spirit](/libs/spirit/): + + + Spirit.X3: + + - **Breaking change:** Removed + `with\_context` + ([#239](https://github.com/boostorg/spirit/issues/239)) + - Added noexcept to `x3::variant` + and `forward\_ast` + ([#241](https://github.com/boostorg/spirit/issues/241)) + - CR+LF lines wrongly counted in `error\_handler::position()` ([#248](https://github.com/boostorg/spirit/issues/248)) + - Fixed `unused\_type` + attribute case in `parse\_into\_container` + ([#266](https://github.com/boostorg/spirit/issues/266)) + - Fixed parsing into associative containers ([#289](https://github.com/boostorg/spirit/issues/289)) + - Fixed overflow problem in `uint\_parser` + ([#297](https://github.com/boostorg/spirit/issues/297)) + - Added VS2015 Update 3 support by using workarounds ([#308](https://github.com/boostorg/spirit/issues/308)) + - Fixed include guard names collision with Qi ([#313](https://github.com/boostorg/spirit/issues/313)) + - Added parsing into range ([#316](https://github.com/boostorg/spirit/issues/316)) ([#12928](https://svn.boost.org/trac/boost/ticket/12928)) + - Changed iterator concept static assert from `ForwardIterator` + to `ReadableIteratorConcept` + && `ForwardTraversalConcept` + ([#320](https://github.com/boostorg/spirit/issues/320)) + - Reenabled `fusion::map` + support ([#330](https://github.com/boostorg/spirit/issues/330)) + - Fixed `string("...")` and `attr("...")` to single item sequence ([#337](https://github.com/boostorg/spirit/issues/337)) + - Dereference a single item view instead of unwrapping sequence + ([#340](https://github.com/boostorg/spirit/issues/340)) + - Prevent `parse\_nan` + from dereferencing out of range iterator ([#351](https://github.com/boostorg/spirit/issues/351)) + - Use traits to test if container is empty ([#355](https://github.com/boostorg/spirit/issues/355)) + + Spirit V2 + + - Fixed keyword directives compilation on C++11 ([#256](https://github.com/boostorg/spirit/issues/256)) + ([#11493](https://svn.boost.org/trac/boost/ticket/11493)) + - Fixed subrules compilation ([#279](https://github.com/boostorg/spirit/issues/279)) ([#259](https://github.com/boostorg/spirit/issues/259)) + - Fixed subrules use after scope bug ([#284](https://github.com/boostorg/spirit/issues/284)) ([#5270](https://svn.boost.org/trac/boost/ticket/5270)) + - Fixed undefined behavior in sequential or operator. Underlying + parsers order of execution was dependent on compiler ([#310](https://github.com/boostorg/spirit/issues/310)) + - Spirit was accidentally relaying on `types` + typedef of `boost::optional`. + The typedef was removed in the new optional implementation + ([#271](https://github.com/boostorg/spirit/issues/271)) ([#12349](https://svn.boost.org/trac/boost/ticket/12349)) + - Fixed problems with `BOOST\_SPIRIT\_NO\_PREDEFINED\_TERMINALS` + (`attr\_cast`, + `confix`, `distinct`, `keywords`, + and `flush\_multi\_pass`) + ([#314](https://github.com/boostorg/spirit/issues/314)) ([#13311](https://svn.boost.org/trac/boost/ticket/13311)) + - Added missing copy assignment operator to `hold\_any` + ([#361](https://github.com/boostorg/spirit/issues/361)) ([#8268](https://svn.boost.org/trac/boost/ticket/8268)) + + Spirit.Qi: + + - Fixed alternate operator ([#201](https://github.com/boostorg/spirit/issues/201)) ([#271](https://github.com/boostorg/spirit/issues/271)) ([#12349](https://svn.boost.org/trac/boost/ticket/12349)) + - Fixed signed integer overflow in real parser ([#245](https://github.com/boostorg/spirit/issues/245)) + - Fixed overflow problem in `uint\_parser` + ([#297](https://github.com/boostorg/spirit/issues/297)) + - Fixed `get\_current\_line`, + `get\_line\_start`, + and added `get\_line\_end` + ([#304](https://github.com/boostorg/spirit/issues/304)) + - Permutations parser were always initializing optionals ([#319](https://github.com/boostorg/spirit/issues/319)) + ([#12473](https://svn.boost.org/trac/boost/ticket/12473)) + - Changed iterator concept static assert from `ForwardIterator` + to `ReadableIteratorConcept` + && `ForwardTraversalConcept` + ([#320](https://github.com/boostorg/spirit/issues/320)) + - Added assertations to real parsers to ensure that the `parse\_frac\_n` from user defined + real policy does not return negative values and also to prevent + static analyzers false-positives ([#358](https://github.com/boostorg/spirit/issues/358)) + + Spirit.Karma: + + - Fixed alternate operator ([#271](https://github.com/boostorg/spirit/issues/271)) + - Fixed `no\_buffering\_policy` + missing copy constructor ([#261](https://github.com/boostorg/spirit/issues/261)) + - The `ostream\_iterator` + was inheriting `std::iterator` + which is deprecated in C++17 ([#345](https://github.com/boostorg/spirit/issues/345)) + + Spirit.Lex: + + - Store id as promoted type to allow out-of-enum values ([#247](https://github.com/boostorg/spirit/issues/247)) + - Fixed C2001 'newline in constant' warning in generated lexers + ([#324](https://github.com/boostorg/spirit/issues/324)) ([#11540](https://svn.boost.org/trac/boost/ticket/11540)) + + Spirit.Classic: + + - Fixed `remove\_reference` + usage without a namespace in Phoenix ([#274](https://github.com/boostorg/spirit/issues/274)) + - Fixed `std::complex` usage without the + include ([#273](https://github.com/boostorg/spirit/issues/273)) + - Fixed compilation of `match` ([#275](https://github.com/boostorg/spirit/issues/275)) + - Fixed compilation with `BOOST\_DISABLE\_THREADS` + defined ([#323](https://github.com/boostorg/spirit/issues/323)) ([#12639](https://svn.boost.org/trac/boost/ticket/12639)) + - Increment scanner through iterator policy ([#336](https://github.com/boostorg/spirit/issues/336)) ([#7371](https://svn.boost.org/trac/boost/ticket/7371)) + - Removed deprecated in C++17 `std::iterator` + usage ([#345](https://github.com/boostorg/spirit/issues/345)) +* [Stacktrace](/libs/stacktrace/): + + + Async safe dumping into files on Windows OS was causing hangs on + some platforms and now is disabled [#33](https://github.com/boostorg/stacktrace/issues/33). Users are encouraged + to update to the latest Boost release. + + [ContainerHash](/libs/container_hash/) library + is now used to reduce dependencies. + + Minor fixes (including [#31](https://github.com/boostorg/stacktrace/issues/31), [#38](https://github.com/boostorg/stacktrace/issues/38), [#39](https://github.com/boostorg/stacktrace/issues/39), + [#40](https://github.com/boostorg/stacktrace/issues/40), [#42](https://github.com/boostorg/stacktrace/issues/42)). +* [Test](/libs/test/): + + + Boost.test v3.7 see the [Changes + log](/doc/libs/1_67_0/libs/test/doc/html/boost_test/change_log.html) for more details. + + Breaking changes + + - Adding test cases with the same name to the same test suite + is now reported as an error. See the changes log for more details. + + New feature: + + - Colour output on by default and available on Windows, + - Improved and clearer command line help + - `BOOST\_AUTO\_TEST\_CASE\_TEMPLATE` + now accepts a sequence of types in an `std::tuple` + + Bug fixes and pull requests: + + - Trac tickets: [#12092](https://svn.boost.org/trac/boost/ticket/12092), [#12596](https://svn.boost.org/trac/boost/ticket/12596), [#12597](https://svn.boost.org/trac/boost/ticket/12597), [#12969](https://svn.boost.org/trac/boost/ticket/12969), + [#13058](https://svn.boost.org/trac/boost/ticket/13058), [#13149](https://svn.boost.org/trac/boost/ticket/13149), [#13170](https://svn.boost.org/trac/boost/ticket/13170) + - Trac tickets: [#13181](https://svn.boost.org/trac/boost/ticket/13181), [#13371](https://svn.boost.org/trac/boost/ticket/13371), [#13387](https://svn.boost.org/trac/boost/ticket/13387), [#13398](https://svn.boost.org/trac/boost/ticket/13398), + [#13407](https://svn.boost.org/trac/boost/ticket/13407), [#13435](https://svn.boost.org/trac/boost/ticket/13435), [#13443](https://svn.boost.org/trac/boost/ticket/13443) + - Pull requests: [#112](https://github.com/boostorg/test/issues/112), [#118](https://github.com/boostorg/test/issues/118), [#118](https://github.com/boostorg/test/issues/118), [#121](https://github.com/boostorg/test/issues/121), + [#122](https://github.com/boostorg/test/issues/122), [#125](https://github.com/boostorg/test/issues/125), [#127](https://github.com/boostorg/test/issues/127) +* [TypeIndex](/libs/type_index/): + + + [ContainerHash](/libs/container_hash/) library + is now used to reduce dependencies. + + Minor fixes (including [#17](https://github.com/boostorg/type_index/issues/17)) +* [TypeTraits](/libs/type_traits/): + + + Added new traits `detected`, + `detected\_or`, `is\_detected`, `is\_detected\_convertible`, + `is\_detected\_exact`, + `is\_complete`. + + Added greatly improved code for detecting binary operators. + + Add assertions for completeness to traits which require complete + types as arguments: this prevents various traits from giving eroneous + results from incomplete types. + + Fix minor issue with mpl compatibility, see [#12212](https://svn.boost.org/trac/boost/ticket/12212). + + Add macro to indicate when `is\_constructible` + is fully implemented, see [#12003](https://svn.boost.org/trac/boost/ticket/12003). + + Update `is\_function` + and `is\_member\_function\_pointer` + to work correctly with C++17 noexcept specifications. + + Add workaround for `is\_default\_constructible` + and `std::pair`. + + Added fallback for `is\_nothrow\_swappable` + on pre-C++11 compilers. +* [Utility](/libs/utility/): + + + **Breaking change:** `` + header no longer includes `boost::next` + and `boost::prior` as they have been moved to + the iterator module. Instead include ``. + Other uses of `` are discouraged, it's better + to use the header for the specific functionality instead. +* [Unordered](/libs/unordered/): + + + Template deduction guides. + + Standard conforming `noexcept` + specifications for `swap`, + `operator=` + and node handles. + + Add `element\_type` + to iterators, so that `std::pointer\_traits` + will work. + + Support `std::piecewise\_construct` on recent Visual + C++ and Dinkumware libraries. + + Use `std::iterator\_traits` rather than the + boost iterator traits in order to remove dependency on Boost.Iterator. + + Iterators no longer inherit from `std::iterator`, + as it's deprecated ([PR#7](https://github.com/boostorg/unordered/pull/7)). + + More detail in the [library + change log](/doc/html/unordered/changes.html#unordered.changes.boost_1_67_0). +* [Units](/libs/units/): + + + Fix sqrt for scaled units [#10270](https://svn.boost.org/trac/boost/ticket/10270) [#27](https://github.com/boostorg/units/issues/27) + + Add constexpr support [#22](https://github.com/boostorg/units/issues/22) + + minor documentation fixes +* [Uuid](/libs/uuid/): + + + **Breaking change:** random\_generator + is no longer copyable ([#61](https://github.com/boostorg/uuid/issues/61)) + + Optimized random\_generator to use OS-provided entropy directly ([PR#53](https://github.com/boostorg/uuid/pull/53)) + + Provide `random\_generator\_mt19937` + for bulk UUID generation + + Handle entropy acquisition errors instead of ignoring them + + Support for Windows UWP ([#24](https://github.com/boostorg/uuid/issues/24)) + + Support for CloudABI +* [Variant](/libs/variant/): + + + Substitute function arguments on compilers with variadic templates + support and do not generate substitution metafunctions using preprocessor + [#42](https://github.com/boostorg/variant/issues/42), [#46](https://github.com/boostorg/variant/issues/46). Many thanks to Nikita Kniazev for providing + an initial fix. + + Perfect forwarding for passing visitor in apply\_visitor [#40](https://github.com/boostorg/variant/issues/40), + [#13288](https://svn.boost.org/trac/boost/ticket/13288). Many thanks to Paweł Dac! + + Minor fixes (including [#41](https://github.com/boostorg/variant/issues/41), [#44](https://github.com/boostorg/variant/issues/44)) + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 4.0.1, 5.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 5.0.1 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.1 + + Clang, C++17: 5.0.1 + + GCC: 4.4.7, 4.5.3, 4.6.3, 5.4.0, 7.2.0 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 7.2.0 + + GCC, C++14: 5.4.0, 5.4.1, 6.3.0, 6.4.0, 7.1.0, 7.2.0, 7.3.0 + + GCC, C++17: 7.2.0 + + Intel, C++14: 18.0 +* OS X: + + + Clang: 9.0.0 + + Clang, C++11: 9.0.0 + + Clang, C++14: 9.0.0 + + Clang, C++1z: 9.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0, 7.1.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.8.1, 4.0.1, 5.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 5.0.1 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.1 + + Clang, C++17: 5.0.1 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.7.2, 4.9.2, 5.4.0, 7.2.0 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 7.2.0 + + GCC, C++14: 5.4.0, 5.4.1, 6.3.0, 6.4.0, 7.1.0, 7.2.0, 7.3.0 + + GCC, C++17: 7.2.0 + + Intel, C++14: 18.0 +* OS X: + + + Clang: 9.0.0 + + Clang, C++11: 9.0.0 + + Clang, C++14: 9.0.0 + + Clang, C++1z: 9.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0, 7.1.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + +### Acknowledgements +[Beman Dawes](/users/people/beman_dawes.html), Daniel James, + Vladimir Prus and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_68_0.html b/users/history/version_1_68_0.html new file mode 100644 index 0000000..b8d8a8e --- /dev/null +++ b/users/history/version_1_68_0.html @@ -0,0 +1,420 @@ +--- +title: Version 1.68.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.68.0 + +/\*\*/ + + + + + + + +Version 1.68.0 +============== + +Version 1.68.0 +-------------- + + +August 9th, 2018 03:46 GMT + + +[Documentation](/doc/libs/1_68_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_68\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.68.0/source/boost_1_68_0.tar.bz2) | 7f6130bc3cf65f56a618888ce9d5ea704fa10b462be126ad053e80e553d6d8b7 | +| [boost\_1\_68\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.68.0/source/boost_1_68_0.tar.gz) | da3411ea45622579d419bfda66f45cd0f8c32a181d84adfa936f5688388995cf | +| windows | [boost\_1\_68\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.68.0/source/boost_1_68_0.7z) | 59804d8fad02cf3b09485f3dbc0f9097c05fc1e0123f0c133b35a6c6f601109a | +| [boost\_1\_68\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.68.0/source/boost_1_68_0.zip) | 3b1db0b67079266c40b98329d85916e910bbadfc3db3e860c049056788d4d5cd | + + +### Notes for Windows + users + Boost.WinAPI has been updated to target Windows 7 by default, where possible. + In previous releases Windows Vista was the default. + + Boost.WinAPI is used internally as the Windows SDK abstraction layer in a number + of Boost libraries, including Boost.Beast, Boost.Chrono, Boost.DateTime, Boost.Dll, + Boost.Log, Boost.Process, Boost.Stacktrace, Boost.System, Boost.Thread and + Boost.UUID. To select the target Windows version define `BOOST\_USE\_WINAPI\_VERSION` + to the numeric version similar to `\_WIN32\_WINNT` + while compiling Boost and user's code. For example: + +``` + b2 release define=BOOST\_USE\_WINAPI\_VERSION=0x0501 stage + +``` + + + The list of Windows API version numbers can be seen on [this](https://msdn.microsoft.com/en-us/library/6sehtctf.aspx) + page. + + +### New Libraries + + +* [YAP](/libs/yap/): An expression template library + for C++14 and later, from Zach Laine. + +### Updated Libraries + + +* [Beast](/libs/beast/): + + + This version fixes a missing executor work guard in all composed + operations used in the implementation. Users who are experiencing + crashes related to asynchronous completion handlers are encouraged + to upgrade. + + For a complete list of changes, please view the official [Release + Notes](/libs/beast/doc/html/beast/release_notes.html). +* [Context](/libs/context/): + + + [#78](https://github.com/boostorg/context/issues/78): Linker error with `context-impl=ucontext`: + multiple definition of `boost::context::detail::current\_rec` +* [Coroutine2](/libs/coroutine2/): + + + [#14](https://github.com/boostorg/coroutine2/issues/14): crash while stack unwinding + + [#18](https://github.com/boostorg/coroutine2/issues/18): some guidance on why to use coroutine2 + + [#20](https://github.com/boostorg/coroutine2/issues/20): failes to compile test in due to the error C2039 + + [#22](https://github.com/boostorg/coroutine2/issues/22): undefined behaviour documentation +* [Fiber](/libs/fiber/): + + + [#170](https://github.com/boostorg/fiber/issues/170): buffered\_channel::try\_push has incorrect documentation + + [#172: WIN64](https://github.com/boostorg/fiber/issues/172: WIN64): 'invalid conversion from 'HANDLE' to + 'std::thread::native\_handle\_type' errors for builds using mingw-w64 + + [#175](https://github.com/boostorg/fiber/issues/175): throw exception "Operation not permitted" + + NUMA support moved to extra library (fiber-numa); enabled via property + numa (numa=on) +* [Fusion](/libs/fusion/): + + + Added a workaround for ambiguous call of `fusion::deque` + constructor on GCC 4.4/c++0x ([PR#178](https://github.com/boostorg/fusion/pull/178), [commit](https://github.com/boostorg/fusion/pull/178/commits/9de32721749b635ff3e04e690da89cf06602c122)). + + Fixed a bug with C-style array ([PR#177](https://github.com/boostorg/fusion/pull/177)). + + Fixed a `fusion::for\_each` signature to take functor + by value ([#4427](https://svn.boost.org/trac/boost/ticket/4427)). + + - This may break existing code with non-copyable (non-movable) + functor, but the implementation wasn't correct for a long time; + the documantation was correct from the first. So, please make + sure your usage. + + Fixed unintentional MPL placeholder substitution bug on `fusion::transform` ([#5490](https://svn.boost.org/trac/boost/ticket/5490)). + + Moved description, how to conform Fusion sequence as MPL sequence, + to mpl section ([#4029](https://svn.boost.org/trac/boost/ticket/4029)). + + Added notes regarding IO facility for adapted type ([#6091](https://svn.boost.org/trac/boost/ticket/6091)). +* [Geometry](/libs/geometry/): + + + Improvements + + - [469](https://github.com/boostorg/geometry/pull/469) + Horizontal grid shift (nadgrids) in SRS transformations (undocumented + for now due to potential interface changes). + - [478](https://github.com/boostorg/geometry/pull/478) + Box-Segment distance for spherical and geographic coordinate + systems. + - [487](https://github.com/boostorg/geometry/pull/487) + Missing combinations of geometries in distance for spherical + and geographic cs + - [489](https://github.com/boostorg/geometry/pull/489) + Additional direct geodesic problem formulas for internal use + + Solved issues + + - [470](https://github.com/boostorg/geometry/issues/470) + Assertion failure with short spherical and geographic segments. + - [471](https://github.com/boostorg/geometry/issues/471) + Invalid envelope of spherical polygon + - [498](https://github.com/boostorg/geometry/issues/498) + Unexpected results with expand() and make\_inverse() for spherical + and geographic CS + - [504](https://github.com/boostorg/geometry/issues/504) + Unused parameter warnings. + + Bugfixes + + - [488](https://github.com/boostorg/geometry/pull/488) + Handle non-true-references in closing\_iterator and ever\_circling\_range\_iterator + - [495](https://github.com/boostorg/geometry/pull/495) + VxWorks 7 cross-compilation issue. +* [GIL](/libs/gil/): + + + Added + + - The library now requires a C++11-compliant compiler. + - New top-level all-in-one `include/boost/gil.hpp` + header ([PR#70](https://github.com/boostorg/gil/pull/70)). + - New Toolbox extension, [reviewed + and accepted into Boost](https://lists.boost.org/boost-announce/2011/01/0281.php). + + Changed + + - IO extensions have been entirely rewritten as IO v2, [reviewed + and accepted into Boost](https://lists.boost.org/boost-announce/2011/01/0281.php). + - Documentation has been reformatted and updated. + + Removed + + - IO v1 extension has been replaced with IO v2. +* [Graph](/libs/graph/): + + + Conditionally replace deprecated/removed C++98 `std::bind1st` + by `std::bind`, `std::auto\_ptr` + by `std::unique\_ptr`, and `std::random\_shuffle` + by `std::shuffle`. ([PR#89](https://github.com/boostorg/graph/pull/89)) + + Fix compiler error with release builds on VS2015 ([PR#84](https://github.com/boostorg/graph/pull/84)) + + Fix the Stanford GraphBase examples ([PR#87](https://github.com/boostorg/graph/pull/87)) + + Fix friend declarations for iterator\_core\_access ([PR#103](https://github.com/boostorg/graph/pull/103)) + + Add missing `` include ([PR#104](https://github.com/boostorg/graph/pull/104)) + + Avoid an unused variable warning ([PR#90](https://github.com/boostorg/graph/pull/90)) + + Fix some typos in documentation ([PR#88](https://github.com/boostorg/graph/pull/88), [PR#98](https://github.com/boostorg/graph/pull/98), [PR#102](https://github.com/boostorg/graph/pull/102)) + + Fix some issues in tests and examples ([PR#85](https://github.com/boostorg/graph/pull/85), [PR#105](https://github.com/boostorg/graph/pull/105)) +* [Lexical Cast](/libs/lexical_cast/): + + + Fixes for clang-tidy warnings [#12092](https://svn.boost.org/trac/boost/ticket/12092) +* [Log](/libs/log/): + + + Improved support for VxWorks. ([PR#39](https://github.com/boostorg/log/pull/39)) + + Save and restore `ebx` + register on x86 PIE targets in the `dump` + stream manipulator implementation. +* [Math](/libs/math/): + + + Support for arbitrary precision complex valued quadrature and hence + contour integration + + Improve performance of polynomial addition + + Continue to improve numerical integration routines, and in particular + add support for contour integrals. + + Improve accuracy of erfc function's rational approximations. +* [Multi-index Containers](/libs/multi_index/index.html): + + + Containers of moveable but non-copyable elements can now be serialized + (ticket [#13478](https://svn.boost.org/trac/boost/ticket/13478)). Thanks to Sébastien Paris for the report. + + `multi\_index\_container`'s + default constructor is no longer `explicit` + (ticket [#13518](https://svn.boost.org/trac/boost/ticket/13518)). +* [Multiprecision](/libs/multiprecision): + + + Support added for complex multiprecision numbers. + + Changed conversion to unsigned integer types to be truncating to + match standard defined behaviour. + + Correct bug in MPFR string formatting. + + Fix undefined behaviour in cpp\_dec\_float conversion from long long. + + Add support for Eigen interoperability. + + float128.hpp: Fix Intel on Windows build. + + Fix type used in temporaries when expanding expression templates + containing mixed expressions. + + Fix infinite loop in gmp\_float to fixed-point string conversion. + + Update the expression templates to issue static\_asserts with better + error messages when you try and do something unsupported. + + Fix bug in cpp\_int where incrementing to zero doesn't set the sign + correctly. + + Remove erroneous use of std::move, and rely on NVRO instead. + + Fix up support for changes to MPIR-3.0. + + Fix various conversion errors in cpp\_bin\_float when the exponent + type is a `long long`, + or else we're converting to an integer that is wider than we are. + + Fix compatibility issue with GCC-8 caused by the introduction of + `std::byte`. +* [Optional](/libs/optional/): + + + Added member function `has\_value()` for compatibility with `std::optional` ([issue + #52](https://github.com/boostorg/optional/issues/52)). + + Added member function `map()` for transforming `optional` + into `optional` + using a function of type `T + -> U`. + + Added member function `flat\_map()` for transforming `optional` + into `optional` + using a function of type `T + -> optonal`. +* [Predef](/libs/predef/): + + + Add support for \_\_ARM\_ARCH macro. (from Tim Blechmann) + + Add detection for PTX architecture. (from Benjamin Worpitz) + + Add nvcc compiler detection. (from Benjamin Worpitz) + + Add support for detecting CUDA. (from Benjamin Worpitz) + + Remove reference to obsolete BOOST\_ARCH\_AMD64. (from Peter Kolbus) +* [Program Options](/libs/program_options/): + + + Support for multiple long names for an option, thanks to Eyal Rozenberg + ([PR#53](https://github.com/boostorg/program_options/pull/53)) +* [Python](/libs/python/): + + + Bug fixes to correct autolink support (Windows) ([#193](https://github.com/boostorg/python/issues/193)) +* [Rational](/libs/rational/): + + + Fixed undefined behavior in normalize() ([PR#19](https://github.com/boostorg/rational/pull/19)). +* [System](/libs/system/): + + + Add constexpr to error\_code and error\_condition members under C++14 + and above ([PR#23](https://github.com/boostorg/system/pull/23)). +* [Signals](/libs/signals/): + + + **Removal Notice:** Boost.Signals will + be removed in the next release. Boost.Signals was deprecated in version + 1.54.0. Transition to Boost.Signals2 now to avoid disruption. +* [Spirit](/libs/spirit/): + + + Spirit.X3: + + - Small list parser optimization ([PR#368](https://github.com/boostorg/spirit/pull/368)). + - Pass container attributes through sequence parser or unary + ending down to a sequence parser ([PR#370](https://github.com/boostorg/spirit/pull/370) [#12085](https://svn.boost.org/trac/boost/ticket/12085)). + - More fine grained sequence attribute check message ([PR#371](https://github.com/boostorg/spirit/pull/371)). + - Removed redundant check in `skip\_over` + ([PR#373](https://github.com/boostorg/spirit/pull/373)). + - Workaround constexpr in noexcept VS2015 bug in entire `x3::variant` ([PR#379](https://github.com/boostorg/spirit/pull/379)). + - Fixed calc4b example compilation ([PR#384](https://github.com/boostorg/spirit/pull/384)). + - Minor code improvements ([PR#374](https://github.com/boostorg/spirit/pull/374)). + + Spirit.Qi: + + - Fixed ADT support by permutation and sequence\_or operator ([PR#376](https://github.com/boostorg/spirit/pull/376)). + - Specialize iterator\_source for random access ([PR#383](https://github.com/boostorg/spirit/pull/383)). + - Removed redundant check in `skip\_over` + ([PR#373](https://github.com/boostorg/spirit/pull/373)). + + Spirit.Karma: + + - Fixed UB in `get\_absolute\_value` + function ([PR#246](https://github.com/boostorg/spirit/pull/246)). + - Fixed use after scope bug if ADT getter returns by value ([PR#375](https://github.com/boostorg/spirit/pull/375) [#6126](https://svn.boost.org/trac/boost/ticket/6126)). + + Spirit.Classic: + + - Fixed a regression introduced in [PR#336](https://github.com/boostorg/spirit/pull/336) ([PR#386](https://github.com/boostorg/spirit/pull/386)). + - Minor code improvements ([PR#367](https://github.com/boostorg/spirit/pull/367)). +* [Stacktrace](/libs/stacktrace/): + + + Fixed compilation on Solaris and other platforms that do qualify + address as const in `dladdr` + function (github 54). + + Dropped dependency on Boost.LexicalCast. +* [Test](/libs/test/): + + + Boost.test v3.8 see the [Changes + log](libs/test/doc/html/boost_test/change_log.html) for more details. + + Breaking changes + + - The `master\_test\_suite\_t` + object is no more copyable + + New feature: + + - Dataset test case can now use command line parameters + + Bug fixes and pull requests: + + - Trac tickets: [#12095](https://svn.boost.org/trac/boost/ticket/12095), [#12953](https://svn.boost.org/trac/boost/ticket/12953), [#13504](https://svn.boost.org/trac/boost/ticket/13504), [#13525](https://svn.boost.org/trac/boost/ticket/13525), + [#13528](https://svn.boost.org/trac/boost/ticket/13528) + - Pull requests: [PR#143](https://github.com/boostorg/test/pull/143), [PR#145](https://github.com/boostorg/test/pull/145) +* [TypeIndex](/libs/type_index/): + + + Dropped dependency on Boost.MPL. +* [Uuid](/libs/uuid/): + + + **Breaking change:** sha1 detail namespace + header redirection for backwards compatibility was removed ([PR#69](https://github.com/boostorg/uuid/pull/69)). + + Added support for std::hash ([PR#67](https://github.com/boostorg/uuid/pull/67)). + + Added support for move semantics on random generators ([PR#74](https://github.com/boostorg/uuid/pull/74)). + + Properly handle EINTR when acquiring entropy ([PR#74](https://github.com/boostorg/uuid/pull/74)). + + Use getrandom(2) instead of getentropy(3) on linux ([PR#75](https://github.com/boostorg/uuid/pull/75)). + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 4.0.1, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1 + + Clang, C++17: 5.0.2, 6.0.1 + + GCC: 4.4.7, 4.5.3, 4.6.3, 5.4.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0 + + Apple Clang, C++11: 9.0.0, 9.1.0 + + Apple Clang, C++14: 9.0.0, 9.1.0 + + Apple Clang, C++17: 9.1.0 + + Apple Clang, C++1z: 9.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.8.1, 3.9.1, 4.0.1, 5.0.2, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1, 7.0.0 + + Clang, C++17: 5.0.2, 6.0.1 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.9.4, 5.4.0, 5.5.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.3.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1, 8.1.0 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0 + + Apple Clang, C++11: 9.0.0, 9.1.0 + + Apple Clang, C++14: 9.0.0, 9.1.0 + + Apple Clang, C++17: 9.1.0 + + Apple Clang, C++1z: 9.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + +### Acknowledgements + Daniel James, Vladimir Prus, and Marshall Clow managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_69_0.html b/users/history/version_1_69_0.html new file mode 100644 index 0000000..27e72b7 --- /dev/null +++ b/users/history/version_1_69_0.html @@ -0,0 +1,545 @@ +--- +title: Version 1.69.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.69.0 + +/\*\*/ + + + + + + + +Version 1.69.0 +============== + +Version 1.69.0 +-------------- + + +December 12th, 2018 02:58 GMT + + +[Documentation](/doc/libs/1_69_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_69\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.69.0/source/boost_1_69_0.tar.bz2) | 8f32d4617390d1c2d16f26a27ab60d97807b35440d45891fa340fc2648b04406 | +| [boost\_1\_69\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.69.0/source/boost_1_69_0.tar.gz) | 9a2c2819310839ea373f42d69e733c339b4e9a19deab6bfec448281554aa4dbb | +| windows | [boost\_1\_69\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.69.0/source/boost_1_69_0.7z) | af05616f71006f97833e130aad886c96136457511ace4b5496d6566e69cbe0ca | +| [boost\_1\_69\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.69.0/source/boost_1_69_0.zip) | d074bcbcc0501c4917b965fc890e303ee70d8b01ff5712bae4a6c54f2b6b4e52 | + + +### Notes for non-Windows + users + The Boost build system now supports visibilities. If you are building shared + libraries, they will use hidden visibility by default. As a result Boost shared + libraries become smaller, load faster and have less chances to get a symbol + collision. + + See [Boost.Build + visibility and local-visibility](/build/manual/develop/index.html#bbv2.builtin.features.visibility) for more info. + + To disable that feature you can use use a command line `./b2 visibility=global` to + build. + + +### New Libraries + + +* [Safe Numerics](/libs/safe_numerics/): A library + for guaranteed correct integer arithmetic for C++14 and later, from Robert + Ramey. + +### Updated Libraries + + +* [Any](/libs/any/): + + + Fixed issue with visibility. Now `boost::any` + variables constructed in one shared library with hidden visibility + could be used and destroyed in other shared library with hidden visibility. + + Maintenance: dropped some dependencies on other Boost libraries, + fixes for docs. +* [Asio](/libs/asio/): + + + Fixed a problem with the detection of `std::future` + availability with libstdc++. + + Fixed compile error in regex overload of `read\_until`. + + Fixed a timer heap corruption issue that can occur when moving a + cancelled timer. + + Fixed detection of `std::experimental::string\_view` + and `std::string\_view` with newer clang/libc++. + + Fixed MSVC version detection for availability of `std::invoke\_result`. + + Fixed the buffer sequence traits to test the new requirements, if + `decltype` is available. + + Fixed an MSVC issue when building with exceptions disabled. + + Added SSL context options for TLS v1.3. + + Added a compile-time test for TLS v1 support. + + Fixed the macro used to test for TLS v1.2 support. + + Prevented global objects from being created once per thread on Windows. + + Fixed a crash when using `size()`, `max\_size()` or `empty()` on default-constructed resolver + results. + + Changed to move the return value in `basic\_resolver\_results::begin()` to avoid copying. + + Enabled move support for the Intel Compiler. + + Fixed `std::string\_view` detection issue when + using clang-cl. + + Fixed the handler tracking operation name for `io\_context::executor\_type::dispatch`. + + Fixed a buffer overflow that could occur when parsing an address + string with a 64-bit scope id. + + Added examples showing how to write composed operations. + + Added C++11 versions of the Timeouts, Timers, SOCKS4 and SSL examples. + + Fixed minor issues in documentation and examples. +* [Assign](/libs/assign/): + + + Add rvalue reference, perfect forwarding, and variadic template support + ([PR#6](https://github.com/boostorg/assign/pull/6)) ([#10477](https://svn.boost.org/trac/boost/ticket/10477)) + + Avoid conversion to container's allocator ([PR#29](https://github.com/boostorg/assign/pull/29)) ([#5419](https://svn.boost.org/trac/boost/ticket/5419)) + ([#7364](https://svn.boost.org/trac/boost/ticket/7364)) +* [Beast](/libs/beast/): + + + This version fixes some issues in the examples, and provides a new + experimental socket which supports built-in timeouts on asynchronous + operations. + + New CppCon 2018 [websocket + chat example](https://www.boost.org/doc/libs/master/libs/beast/doc/html/beast/examples.html#beast.examples.cppcon_2018) and [presentation + video](https://www.youtube.com/watch?v=7FQwAjELMek). + + For a complete list of changes, please view the official [Release + Notes](/libs/beast/doc/html/beast/release_notes.html). +* [CircularBuffer](/libs/circular_buffer/): + + + Use the empty base optimization for storing allocators that are empty + and not final (Glen Fernandes). +* [Concept Check](/libs/concept_check/): + + + Removed dependency on mpl. ([PR#14](https://github.com/boostorg/concept_check/pull/14)) +* [Context](/libs/context/): + + + [#85](https://github.com/boostorg/context/issues/85): duplicate alias should be missing GCC alias + + [#87](https://github.com/boostorg/context/issues/87): the clang-win toolset (clang-cl.exe) uses masm from + the underlying msvc + + [#90](https://github.com/boostorg/context/issues/90): remove useless lines in Jamfile.v2 + + [#91](https://github.com/boostorg/context/issues/91): add .file section for \*\_elf\_gas.S files +* [Core](/libs/core/): + + + Implemented `boost::empty\_value`, + for library authors to conveniently leverage the Empty Base Optimization + to store objects of potentially empty types (Glen Fernandes). This + facility is now used in Boost.Beast, Boost.CircularBuffer, Boost.MultiArray, + and more. + + Implemented `boost::quick\_exit` + to provide the C++11 standard library facility `std::quick\_exit` + functionality (Peter Dimov). + + Reduced the number of statics in Lightweight Test, and employ lighter + abort behavior for MSVC compilers upon failure to call `boost::report\_errors` (Glen Fernandes). +* [DLL](/libs/dll/): + + + Resolved link issues with the smart library [#20](https://github.com/boostorg/dll/issues/20). + + Maintenance: fixes for docs and tests. +* [Dynamic Bitset](/libs/dynamic_bitset/): + + + Performance improvements (over 2x in some cases). ([PR#26](https://github.com/boostorg/dynamic_bitset/pull/26)) + + Added range-based set, reset, flip methods ([PR#27](https://github.com/boostorg/dynamic_bitset/pull/27)) +* [Fiber](/libs/fiber/): + + + [#181](https://github.com/boostorg/fiber/issues/181): unbuffered\_channel push not return + + [#182](https://github.com/boostorg/fiber/issues/182): Remove UTF-8 BOM at begining of the file + + [#183](https://github.com/boostorg/fiber/issues/183): Fix boost-install use; should only be issued once +* [Filesystem](/libs/filesystem/): + + + Don't use `readdir\_r` + on Linux and Android since the `readdir` + function is already thread-safe. ([PR#68](https://github.com/boostorg/filesystem/pull/68), [#72](https://github.com/boostorg/filesystem/issues/72)) + + Fixed crashes in `boost::filesystem::copy` + due to undefined behavior in the implementation. ([PR#71](https://github.com/boostorg/filesystem/pull/71)) + + Fixed undefined behavior in `boost::filesystem::directory\_iterator` + implementation. ([PR#77](https://github.com/boostorg/filesystem/pull/77)) + + Fixed compilation errors when using directory iterators with `BOOST\_FOREACH`. + + Removed workarounds for older PGI C++ compiler versions to fix compilation + on the newer ones. ([PR#49](https://github.com/boostorg/filesystem/pull/49)) + + Fixed MSVC warnings about narrowing conversions. ([PR#44](https://github.com/boostorg/filesystem/pull/44)) +* [Flyweight](/libs/flyweight/index.html): + + + Fixed some issues in GCC related to Boost.MPL placeholder expression + handling. + + Maintenance fixes. +* [Function](/libs/function/): + + + Removed dependencies on mpl, test ([PR#20](https://github.com/boostorg/function/pull/20)) ([PR#22](https://github.com/boostorg/function/pull/22)) +* [Geometry](/libs/geometry/): + + + Improvements + + - [PR#486](https://github.com/boostorg/geometry/pull/486) Karney's solution of direct geodesic problem + for internal use (thanks to Adeel Ahmad). + - [PR#490](https://github.com/boostorg/geometry/pull/490) Discrete Frechet and Hausdorff distance algorithms + (thanks to Yaghyavardhan Singh Khangarot). + - [PR#496](https://github.com/boostorg/geometry/pull/496) New run-time and upgraded compile-time SRS + transformation interfaces (undocumented for now due to potential + interface changes). + + Solved issues + + - [#520](https://github.com/boostorg/geometry/issues/520) Missing documentation for dsv(). + - [#521](https://github.com/boostorg/geometry/issues/521) Wrong documentation description for distance(). + - [#524](https://github.com/boostorg/geometry/issues/524) Fixed 'enumeration values not handled in switch' + warnings. + - [#527](https://github.com/boostorg/geometry/issues/527) Workaround for VS 2017 (msvc-15). + + Bugfixes + + - [PR#505](https://github.com/boostorg/geometry/pull/505) Fixed overflow in overlay algorithms (thanks + to Dane Springmeyer). + - [PR#518](https://github.com/boostorg/geometry/pull/518) Fixed passing of temporaries in append() (thanks + to xventura81). + - [PR#522](https://github.com/boostorg/geometry/pull/522) Support python3 in building documentation. +* [GIL](/libs/gil/): + + + Changed + + - Refactored library includes to `#include + ` structure ([PR#145](https://github.com/boostorg/gil/pull/145)). + + Removed + + - Header `include/boost/gil\_all.hpp` + file as deprecated ([PR#145](https://github.com/boostorg/gil/pull/145)). + - Header `include/boost/gil\_concepts.hpp` + file as deprecated ([PR#145](https://github.com/boostorg/gil/pull/145)). + - Header `include/boost/gil\_config.hpp` + file as unnecessary ([PR#144](https://github.com/boostorg/gil/pull/144)). + + Fixed + + - Fixed `point` divide and multiply to + not to hardcode result as `point` ([PR#157](https://github.com/boostorg/gil/pull/157)). + - Fixed conflict between `std::fill\_n` + and `boost::range::fill\_n` ([PR#152](https://github.com/boostorg/gil/pull/152)). + - Fixed issue with re-assignment of functor from `for\_each\_pixel` ([PR#139](https://github.com/boostorg/gil/pull/139)). + - Fixed missing template keyword prior to dependent name `axis\_iterator` ([PR#129](https://github.com/boostorg/gil/pull/129)). +* [Integer](/libs/integer/): + + + `boost/pending/integer\_log2.hpp` header is deprecated and will + be removed in future releases. Use `boost/integer/integer\_log2.hpp` + instead. +* [Iostreams](/libs/iostreams/): + + + Remove call to nonexistent member seekpos() of std::fpos ([PR#58](https://github.com/boostorg/iostreams/pull/58)) +* [Iterator](/libs/iterator/): + + + Fixed compilation problems with ambiguous unqualified calls to `advance` and `distance` + on iterators whose types involve types in the namespace `boost`. ([#43](https://github.com/boostorg/iterator/issues/43)) +* [LexicalCast](/libs/lexical_cast/): + + + Fixed sign-conversion warnings [#8991](https://svn.boost.org/trac/boost/ticket/8991). + + Maintenance: dropped some dependencies on other Boost libraries, + fixed build system warnings. +* [Log](/libs/log/): + + + General changes: + + - Updated syslog sink backend to avoid using deprecated Boost.ASIO + interfaces. ([#59](https://github.com/boostorg/log/issues/59)) + + Bug fixes: + + - Fixed a possible incorrect estimation of the total size of + rotated files in the target directory of a text file sink in + some cases. + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Logic](/libs/logic/): + + + **Breaking change:** Use explicit operator + bool when available ([PR#5](https://github.com/boostorg/logic/pull/5)) +* [Math](/libs/math/): + + + Add LambertW functions. + + Update integration routines to support complex valued integrands + and contour integrals. + + Added the derivative of the Barycentric rational approximation. + + Minor fixes to better support variable precision floating point types. + + Removed use of deprecated Boost.Endian in favour of Predef. + + Updated continued fraction and series evaluation code to support + complex types. + + Prevent logic error leading to infinite loop in toms748\_solve. See + [#138](https://github.com/boostorg/math/issues/138). + + Fix mean and standard\_deviation for extreme\_value\_distribution. See + [#139](https://github.com/boostorg/math/issues/139). + + Improve heuristics used in newton\_raphson\_iterate. See [#145](https://github.com/boostorg/math/issues/145). + + Fix result of `erf(NaN)`. See [#141 #141](https://github.com/boostorg/math/issues/141 #141). + + Big push to reduce GCC warnings. See [#136 #136](https://github.com/boostorg/math/issues/136 #136). + + Refactor polynomial addition. See [PR#132](https://github.com/boostorg/math/pull/132). + + Fix for vxWorks having a `real` + function in the global namespace. See [PR#131](https://github.com/boostorg/math/pull/131). + + Improve `sinc` approximations + and add better tests. + + Fix typo in Student's T hypothesis testing documentation, see [#143](https://github.com/boostorg/math/issues/143). +* [Mp11](/libs/mp11/): + + + Implemented the `mp\_starts\_with` + facility (Glen Fernandes). +* [MultiArray](/libs/multi_array/): + + + Improve C++11 allocator model support including: Support for C++11 + minimal allocators, support for stateful allocators, using the allocator + for construction and destruction of the value type, and using the + empty base optimization for storing empty or stateless allocators + (Glen Fernandes). +* [Multi-index Containers](/libs/multi_index/): + + + Introduced an alternative [terse + key specification syntax](/libs/multi_index/doc/tutorial/key_extraction.html#key) for C++17 compliant environments. +* [Multiprecision](/libs/multiprecision/): + + + Big update to better support variable precision types so that the + precision of the result is always the largest of all the arguments. + + Add support for allocators that are `final` + in \_\_cpp\_int (Glen Fernandes). + + Removed use of deprecated Boost.Endian in favour of Predef. + + Add support for `std::string\_view`. + + Fixed minor bug in constant initialization. See [#67](https://github.com/boostorg/multiprecision/issues/67). + + Make assignment of non-finite value to `cpp\_int` + a runtime errors. See [#58](https://github.com/boostorg/multiprecision/issues/58). + + Added typedefs for `cpp\_bin\_float\_oct` + and `cpp\_complex\_oct`. +* [PolyCollection](/libs/poly_collection/): + + + Added Boost.PolyCollection-specific versions of algorithms `std::for\_each\_n` and `std::sample`. +* [Pool](/libs/pool/): + + + Replace boost::mutex use to avoid a dependency on Boost.Thread ([PR#23](https://github.com/boostorg/pool/pull/23)) +* [Preprocessor](/libs/preprocessor/): + + + Supports the new C++ standard conforming preprocessor in VC++ 14.1, + which is currently enabled by using the /experimental:preprocessor + switch, in Visual Studio 2017 15.8 on up. +* [Rational](/libs/rational/): + + + Add constexpr support ([PR#28](https://github.com/boostorg/rational/pull/28)) ([PR#32](https://github.com/boostorg/rational/pull/32)) +* [Spirit](/libs/spirit/): + + + Spirit.X3: + + - Drop own FP routines in favor of `boost::math` + ([#392](https://github.com/boostorg/spirit/issues/392)) ([#13531](https://svn.boost.org/trac/boost/ticket/13531)) + - Missing visibility mark on exception types ([#409](https://github.com/boostorg/spirit/issues/409)) + - to\_utf8: Fixed wchar\_t handling on Windows ([#413](https://github.com/boostorg/spirit/issues/413)) + ([#395](https://github.com/boostorg/spirit/issues/395)) + + Spirit V2 + + - Drop own FP routines in favor of `boost::math` + ([#392](https://github.com/boostorg/spirit/issues/392)) ([#13531](https://svn.boost.org/trac/boost/ticket/13531)) + - Missing visibility mark on exception types ([#409](https://github.com/boostorg/spirit/issues/409)) + - Fixed transform\_attribute ambiguity ([#407](https://github.com/boostorg/spirit/issues/407)) ([#396](https://github.com/boostorg/spirit/issues/396)) + - to\_utf8: Fixed wchar\_t handling on Windows ([#413](https://github.com/boostorg/spirit/issues/413)) + ([#395](https://github.com/boostorg/spirit/issues/395)) + + Spirit.Classic: + + - Missing visibility mark on exception types ([#409](https://github.com/boostorg/spirit/issues/409)) +* [Stacktrace](/libs/stacktrace/): + + + `libbacktrace` usage + was significantly improved. `BOOST\_STACKTRACE\_USE\_BACKTRACE` + or `boost\_stacktrace\_backtrace` + users are encouraged to update: + + - Memory consumprion dropped down. + - Stack capturing became faster by an order of magnitude. + - `syminfo` fallback + enabled to provide information for visible symbols even without + debug information (thanks to github user driesdeschout!)[#60](https://github.com/boostorg/stacktrace/issues/60), + [#61](https://github.com/boostorg/stacktrace/issues/61). + - Exact location of the `backtrace.h` + header now can be specified via `BOOST\_STACKTRACE\_BACKTRACE\_INCLUDE\_FILE`, + to allow `backtrace.h` + header usage on platforms and compilers where that header is + unreachable otherwise (for example Ubuntu Xenial + Clang) [#59](https://github.com/boostorg/stacktrace/issues/59). + + Optimized stack capturing if `max\_depth` + is set (thanks to Jan Eisenhauer for the PR!) [#67](https://github.com/boostorg/stacktrace/issues/67). + + Added `to\_string(const stacktrace& )` + functions for fast conversion of stacktraces to `std::string` + [#57](https://github.com/boostorg/stacktrace/issues/57). + + Maintenance: updated docs [#62](https://github.com/boostorg/stacktrace/issues/62), tests updated. +* [System](/libs/system/): + + + Boost.System is now header-only. A stub library is still built for + compatibility, but linking to it is no longer necessary. + + Even more functions have been marked `constexpr`. + + The destructor of `error\_category` + is now `protected` and + no longer `virtual`. This + is a potentially breaking change, but its impact is expected to be + limited. + + `error\_category` now + has a constructor that accepts a 64 bit identifier, enabling distinct + category objects to compare equal. + + The constructors of `error\_category` + are now `protected`. + + A non-allocating, nonthrowing overload of `message` + has been added. + + A virtual function `failed` + has been added, allowing categories for which success is not synonymous + with 0. + + The deprecated `boost::system::throws` + object has been removed. + + `boost::throws()` + is now deprecated and its use is discouraged. + + The constructor of `system\_error` + taking a single `error\_code` + argument is now `explicit`. + + `system\_error::code()` + now returns by value. +* [Test](/libs/test/): + + + Boost.test v3.9 see the [Changes + log](libs/test/doc/html/boost_test/change_log.html) for more details. + + New feature: + + - Official support of header-only variant of Boost.Test with + multiple translation units. + - Now possible to manually add a test case by specifying its + name, with `BOOST\_TEST\_CASE\_NAME` + - Better support of `boost::exception` + in the logs + + Bug fixes and pull requests: + + - Trac tickets: [#13380](https://svn.boost.org/trac/boost/ticket/13380), [#13625](https://svn.boost.org/trac/boost/ticket/13625), [#13637](https://svn.boost.org/trac/boost/ticket/13637) + - GitHub Issues: [#149](https://github.com/boostorg/test/issues/149), [#150](https://github.com/boostorg/test/issues/150), [#156](https://github.com/boostorg/test/issues/156), [#158](https://github.com/boostorg/test/issues/158), + [#163](https://github.com/boostorg/test/issues/163) + - GitHub Pull Requests: [PR#147](https://github.com/boostorg/test/pull/147), [PR#148](https://github.com/boostorg/test/pull/148), [PR#151](https://github.com/boostorg/test/pull/151), + [PR#154](https://github.com/boostorg/test/pull/154), [PR#161](https://github.com/boostorg/test/pull/161) +* [TypeIndex](/libs/type_index/): + + + Fix the regression and speed up parsing of the `boost/type\_traits.hpp` + header by 30% (thanks to Nikita Kniazev for the PR!) [#21](https://github.com/boostorg/type_index/issues/21). +* [Utility](/libs/utility/): + + + Added support for non-inheritable empty types to `boost::compressed\_pair` + by avoiding the empty base optimization for types which are declared + as final (Glen Fernandes). +* [Variant](/libs/variant/): + + + Fixed issue with visibility. Now `boost::bad\_visit` + exception could cross the boundaries of shared library with hidden + visibility and could be catched in other shared library with hidden + visibility. +* [YAP](/libs/yap/): + + + Minor changes to support MSVC++ version 14.15 (Visual Studio 2017 + version 15.8). + + Doc fixes. + +### Discontinued Libraries + + +* Signals (v1) is now removed. Its removal was announced in 1.68 and its + deprecation was announced in 1.54. Boost 1.68 is the last release that + provides this library. Users are encouraged to use Signals2 instead. The + Boost community thanks Douglas Gregor for his work on Signals which served + its users well and which also inspired Signals2. + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 4.0.1, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1 + + Clang, C++17: 5.0.2, 6.0.1 + + GCC: 4.4.7, 4.5.3, 4.6.3, 5.4.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++11: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++14: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++17: 9.1.0, 10.0.0 + + Apple Clang, C++1z: 9.0.0 + + Apple Clang, C++2a: 10.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.8.1, 3.9.1, 4.0.1, 5.0.2, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1, 7.0.0 + + Clang, C++17: 5.0.2, 6.0.1 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.9.4, 5.4.0, 5.5.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.3.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1, 8.1.0 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++11: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++14: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++17: 9.1.0, 10.0.0 + + Apple Clang, C++1z: 9.0.0 + + Apple Clang, C++2a: 10.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + +### Acknowledgements + Daniel James, Vladimir Prus, Marshall Clow and Michael Caisse managed this + release. + + + + + + + + + + + + diff --git a/users/history/version_1_70_0.html b/users/history/version_1_70_0.html new file mode 100644 index 0000000..460e455 --- /dev/null +++ b/users/history/version_1_70_0.html @@ -0,0 +1,587 @@ +--- +title: Version 1.70.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.70.0 + +/\*\*/ + + + + + + + +Version 1.70.0 +============== + +Version 1.70.0 +-------------- + + +April 12th, 2019 06:04 GMT + + +[Documentation](/doc/libs/1_70_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_70\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.70.0/source/boost_1_70_0.tar.bz2) | 430ae8354789de4fd19ee52f3b1f739e1fba576f0aded0897c3c2bc00fb38778 | +| [boost\_1\_70\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.70.0/source/boost_1_70_0.tar.gz) | 882b48708d211a5f48e60b0124cf5863c1534cd544ecd0664bb534a4b5d506e9 | +| windows | [boost\_1\_70\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.70.0/source/boost_1_70_0.7z) | ae2bb1b35d1f238e72e3f819b42336f4bd27c9ed2092aab5d87818ccb0c9161a | +| [boost\_1\_70\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.70.0/source/boost_1_70_0.zip) | 48f379b2e90dd1084429aae87d6bdbde9670139fa7569ee856c8c86dd366039d | + + +### Known Issues + These are patches from library authors which were found too late to be fixed + in the release. Be careful as they have not been through the normal testing + process. + + + +* Fix moved-from executor in idle ping timeout ([#1599](https://github.com/boostorg/beast/issues/1599)) + + + [Beast + patch](/patches/1_70_0/0001-beast-fix-moved-from-executor.patch) + +### New Libraries + + +* [Outcome](/libs/outcome/): A set of tools for reporting + and handling function failures in contexts where *directly* + using C++ exception handling is unsuitable, from Niall Douglas. +* [Histogram](/libs/histogram/): Fast and extensible + multi-dimensional histograms with convenient interface for C++14, from + Hans Dembinski. + +### Updated Libraries + + +* [Asio](/libs/asio/): + + + This release includes a number of new features, bug fixes, performance + enhancements, and documentation improvements. Notable changes include: + + - Added the ability to use custom I/O executors with I/O objects + (such as sockets). + - Added a new `async\_result` + form with an `initiate` + static member function. + - Updated the Coroutines TS support and promoted it to the `asio` namespace. + - Added a new `DynamicBuffer\_v2` + concept which is CopyConstructible. + - Added a new `async\_compose` + function that simplifies the implementation of user-defined + asynchronous operations. + - Added a `make\_strand` + helper function. + - Relaxed the completion condition type requirements to only + require move-constructibility rather than copy-constructibility. + - Added a constructor for `local::basic\_endpoint` + that takes a `string\_view`. + - Added the noexcept qualifier to various functions. + - Added a new `BOOST\_ASIO\_DISABLE\_VISIBILITY` + configuration `#define`. + - Enabled recycling of the memory used to type-erase a function + object with the polymorphic executor. + - Changed receive operations to return the correct number of + bytes transferred when truncation (`error::message\_size`) + occurs on a datagram-oriented socket. + - Fixed calculation of absolute timeout when the backend uses + `pthread\_cond\_timedwait`. + - Changed the range-based asynchronous connect operation to deduce + the `EndpointSequence` + iterator type. + - Fixed `buffer\_sequence\_begin` + and `buffer\_sequence\_end` + to prevent implicit conversion. + - Ensured SSL handshake errors are propagated to the peer before + the local operation completes. + - Suppressed the `eof` + error on SSL shutdown as it actually indicates success. + - Added a fallback error code for when we OpenSSL produces an + `SSL\_ERROR\_SYSCALL` + result without an associated error. + - Changed composed asynchronous read and write operations to + move buffer sequence objects. + - Fixed a macOS-specific warning about the deprecation of `OSMemoryBarrier`. + - Fixed compile errors that occur when using the composed read + and write operations with MSVC 11.0. + - Improved `dispatch`, + `post` and `defer` documentation. + - Fixed a Windows-specific memory leak that may occur when `system\_executor` is used. + + Consult the [Revision + History](/doc/libs/1_70_0/doc/html/boost_asio/history.html) for further details. +* [Beast](/libs/beast/): +**BIG + Update!!!** + + + Some APIs have changed. + + The [reference](/libs/beast/doc/html/beast/quickref.html) + shows a star ★ next to each new item. + + Beast needs your help! + + - [Tell + Us](https://github.com/boostorg/beast/wiki/Companies-and-Individuals-Using-Beast) how you or your company use Beast + - Please [report](https://github.com/boostorg/beast/issues/new) + any bugs, feature requests, or general feedback + - Join the [**C++ Slack Workspace**](https://cppalliance.org/slack/) for free + and chat with us in the #beast and #boost channels + - Don't forget to [star + the repository](https://github.com/boostorg/beast) ⭐! + + More tutorials, code like the pros! + + - [Networking + Refresher](/libs/beast/doc/html/beast/using_io/asio_refresher.html) teaches you from the ground up. + - Updated [Asynchronous + Echo](/libs/beast/doc/html/beast/using_io/writing_composed_operations/echo.html) example + - Updated [**Detect SSL**](/libs/beast/doc/html/beast/using_io/writing_composed_operations/detect_ssl.html) composed operation + tutorial + - [websocket-chat-multi](/libs/beast/example/websocket/server/chat-multi) + threaded chat server with a JavaScript [browser + client](/libs/beast/example/websocket/server/chat-multi/chat_client.html) + + [`basic\_stream`](/libs/beast/doc/html/beast/ref/boost__beast__basic_stream.html) and [`tcp\_stream`](/libs/beast/doc/html/beast/ref/boost__beast__tcp_stream.html) offer: + + - Timeouts: `async\_read\_some`, + `async\_write\_some` + complete with [`error::timeout`](/libs/beast/doc/html/beast/ref/boost__beast__error.html) on expiration! + - Traffic-shaping policies [`simple`](/libs/beast/doc/html/beast/ref/boost__beast__simple_rate_policy.html) and [`unlimited`](/libs/beast/doc/html/beast/ref/boost__beast__unlimited_rate_policy.html), or a user-defined + [*RatePolicy*](/libs/beast/doc/html/beast/concepts/RatePolicy.html)! + - Put the strand directly on the socket using [P1322R0](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1322r0.html), + no more `bind\_executor` + at call sites! + + Base classes [`async\_base`](/libs/beast/doc/html/beast/ref/boost__beast__async_base.html) and [`stable\_async\_base`](/libs/beast/doc/html/beast/ref/boost__beast__stable_async_base.html) and handle + all composed operation boilerplate for you. + + [`ssl\_stream`](/libs/beast/doc/html/beast/ref/boost__beast__ssl_stream.html) provides a movable, + assignable SSL stream with a flat write optimization. + + All asynchronous operations use Asio's `async\_initiate` + for efficient integration with Coroutines TS. + + ⚡ ***faster compilation***, + define `BOOST\_BEAST\_SEPARATE\_COMPILATION` + and `#include ` + in one of your .cpp files! + + See the full [Release + Notes](/libs/beast/doc/html/beast/release_notes.html) for a complete list of changes. +* [Context](/libs/context/): + + + [#91](https://github.com/boostorg/context/issues/91): cleanup of stack if creating ucontext fails + + [#97](https://github.com/boostorg/context/issues/97): add missing BOST\_CONTEXT\_DECL in stack\_context + + [#98](https://github.com/boostorg/context/issues/98): fix jump\_i386\_sysv\_macho writing garbage to the x87 + control word +* [Coroutine2](/libs/coroutine2/): + + + [#28](https://github.com/boostorg/coroutine2/issues/28): don't crash on pthread\_cancel +* [DLL](/libs/dll/): + + + New macro [BOOST\_DLL\_USE\_STD\_FS](/libs/dll/BOOST_DLL_USE_STD_FS.html). + Define it to `1` to make + the Boost.DLL use C++17's `std::filesystem::path`, + `std::system\_error` and `std::error\_code` ([#21](https://github.com/boostorg/dll/issues/21)). Note that + exception types change from `boost::system::system\_error` + to `std::system\_error`, so make sure to update + `catch`es. + + Significant rewrite of the dynamic loadable detection and decoration + logic. More precise errors are now reported in case of loading failures. + Added `shared\_library::decorate()` function that returns a decorated + path to the library without doing any platform related queries and + detections. Prefer using `shared\_library::load` + and `shared\_library` + constructors for better results (many thanks to Loïc Touraine for + the work [PR#23](https://github.com/boostorg/dll/pull/23)). + + CI hardening, docs updates, typos fixes, cleanups and many portability + fixes. +* [Dynamic Bitset](/libs/dynamic_bitset/): + + + Disabled hardware-assisted popcount (added in 1.69.0) on MSVC due + to undefined behavior on older CPUs. ([#33](https://github.com/boostorg/dynamic_bitset/issues/33) [PR#35](https://github.com/boostorg/dynamic_bitset/pull/35)) +* [Fiber](/libs/fiber/): + + + [#191](https://github.com/boostorg/fiber/issues/191): ignore unused argument warning + + [#196](https://github.com/boostorg/fiber/issues/196): fix high contention on remote\_ready\_splk\_ +* [Filesystem](/libs/filesystem/): + + + Fixed a few instances of dereferencing `std::string::end()` in `path` + implementation. + + Fixed program termination in case of out of memory condition in directory + iterators constructors and operations accepting a reference to `error\_code`. ([#58](https://github.com/boostorg/filesystem/issues/58)) + + Fixed possible linking errors caused by missing definitions of static + members of `path`. + ([#12759](https://svn.boost.org/trac/boost/ticket/12759)) + + Fixed possible use of uninitialized data in directory iterator increment + operation on Linux. + + Added support for movability to directory iterators. + + Added file status query overloads for `directory\_entry`. + This avoids a relatively expensive OS query when file status is requested + for a result of dereferencing a directory iterator. ([PR#55](https://github.com/boostorg/filesystem/pull/55)) + + Reworked `current\_path` + and `read\_symlink` + implementation to avoid possible memory exhaustion on broken or tampered + with filesystems. The functions now have an internal limit of the + path size they will accept from the OS, which is currently 16 MiB. + + Increased the size of the internal buffer used by `copy\_file`. +* [Integer](/libs/integer/): + + + Added Extended Euclidean Algorithm and Modular Multiplicative Inverse + function. (Nick Thompson, [PR#11](https://github.com/boostorg/integer/pull/11)) +* [Log](/libs/log/): + + + New features: + + - Added support for generating another log file name before collecting + the file in the text file sink backend. This allows to combine + appending to an existing log file with timestamps and file + counters in log filenames, and, consequently, file collection + in general. + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Math](/libs/math/): + + + New features: + + - Add Lanczos smoothing derivatives + - Move `numerical\_differentiation.hpp` + from `boost/math/tools/` to `boost/math/differentiation/finite\_difference.hpp`. + - Add mean, variance, skewness, kurtosis, median, Gini coefficient, + and median absolute deviation to `tools/univariate\_statistics.hpp`. + - Add correlation coefficients and covariance to `tools/bivariate\_statistics.hpp` + - Add absolute Gini coefficient, Hoyer sparsity, oracle SNR, + and the *M*[sub 2]*M*[sub + 4] SNR estimator to `tools/signal\_statistics.hpp`. + - Add total variation, l0, l1, l2, and sup norms, as well as + corresponding distance functions to `tools/norms.hpp`. + - Add move constructors for polynomials, support complex coefficients, + add `.prime()` and `.integrate()` + methods. + - Add `quadratic\_roots` + to `tools/roots.hpp`. + - Add support for complex-valued functions to Newton's method + in `roots.hpp`. + - Add Catmull-Rom interpolator. +* [Mp11](/libs/mp11/): + + + Renamed `mp\_invoke` + to `mp\_invoke\_q` + + Added `mp\_similar` + + Added `mp\_set\_union`, + `mp\_set\_intersection`, + `mp\_set\_difference` + + Added `mp\_not\_fn` + + Added `mp\_transform\_first`, + `mp\_transform\_second`, + `mp\_transform\_third` + + Added `mp\_filter` + + Added `mp\_eval\_if\_not`, + `mp\_eval\_or`, `mp\_valid\_q` + + Added `mp\_back`, `mp\_pop\_back` +* [Multi-index Containers](/libs/multi_index/): + + + `size\_type` and `difference\_type` are now defined + as the allocator's same-named types. This will not make any difference + in the vast majority of cases, but allows for some degree of control + of resulting internal structures via user-defined allocator types + (see issue [#17](https://github.com/boostorg/multi_index/issues/17) for motivation). For the moment being, + this change is not documented in the reference section (i.e., it + has semi-official status). + + Maintenance work. +* [Multiprecision](/libs/multiprecision/): + + + Fix various conversion issues in the traits classes, check for compatibility + with Boost.Optional. + + Prevent instantiation of `std::numeric\_limits` + on any old type when checking for convertibility. See [#98](https://github.com/boostorg/multiprecision/issues/98). + + Update variable precision code to account for arbitrary precision + integers. See [#103](https://github.com/boostorg/multiprecision/issues/103). + + Add support for XML serialization archives. + + Fix bug in fixed precision iostream formatting in `mpf\_float` + and `mpfr\_float`. See + [#113](https://github.com/boostorg/multiprecision/issues/113). + + Add more overloads for special functions which are better handled + natively by MPFR. + + Fixed bug in generic `exp` + implementation which could cause invariant failure. + + Fixed generic conversion from float to integer to avoid undefined + behaviour. See [#110](https://github.com/boostorg/multiprecision/issues/110). +* [PolyCollection](/libs/poly_collection/): + + + Improved handling of stateful allocators and allocator propagation + traits, after an error reported by Billy O'Neal ([PR#9](https://github.com/boostorg/poly_collection/pull/9)). + + Fixed a potentially serious bug with an internal cache structure. +* [Spirit](/libs/spirit/): + + + Removed use of deprecated `boost/detail/iterator.hpp` + header. [PR#432](https://github.com/boostorg/spirit/pull/432) + + X3 + + - Integer parsers should now handle user defined types. [PR#429](https://github.com/boostorg/spirit/pull/429) + - **Note:** The `check\_overflow` + trait default implementation now relies on `std::numeric\_limits::is\_bounded` + instead of `boost::integer\_traits::is\_integral`. + - Removed sequence into plain parsing. Now it triggers a compile + time error instead of silently parsing the the sequence and + taking the last value as a result. [PR#439](https://github.com/boostorg/spirit/pull/439) + - Fixed `parse\_rule` + instantiation with `BOOST\_SPIRIT\_INSTANTIATE` + when: + + * A rule has no attribute. [PR#455](https://github.com/boostorg/spirit/pull/455) + * An actual attribute is not of type a rule was declared + with. [PR#456](https://github.com/boostorg/spirit/pull/456) [#457](https://github.com/boostorg/spirit/issues/457) + - A **huge** thanks goes out to + [Xeverous](https://github.com/Xeverous) for + reporting a regression in [#453](https://github.com/boostorg/spirit/issues/453). + - Fixed unneded attribute synthesization and no-transformation + attribute reference pass-through in rules. [#444](https://github.com/boostorg/spirit/issues/444) [PR#449](https://github.com/boostorg/spirit/pull/449) [PR#452](https://github.com/boostorg/spirit/pull/452) + - Removed broken 1.0#INF parser. It was poorly documented and + never worked. [#415](https://github.com/boostorg/spirit/issues/415) [PR#458](https://github.com/boostorg/spirit/pull/458) [#8699](https://svn.boost.org/trac/boost/ticket/8699) + - The undocumented `make\_attribute` + trait was removed due to bugs [PR#449](https://github.com/boostorg/spirit/pull/449) + and to simplify + attribute transformation. [PR#460](https://github.com/boostorg/spirit/pull/460) + - If you were using it to workaround bugs in attribute transformation + - they should not be needed anymore as of this release. + - The integer value parser now respects `std::numeric\_limits::digits10` + value. [PR#469](https://github.com/boostorg/spirit/pull/469) + - Fixed underflow check for a `(Min % + Base) + == 0` + corner case. [PR#469](https://github.com/boostorg/spirit/pull/469) + - Fixed an output value on overflow of IgnoreOverflowDigits=true + integer parser. [PR#470](https://github.com/boostorg/spirit/pull/470) + - Container attribute elements were copyied, but not moved. [PR#472](https://github.com/boostorg/spirit/pull/472) + - Special handling of references in `transform\_attribute` + was removed. [PR#480](https://github.com/boostorg/spirit/pull/480) + + V2 + + - Macro name collisions and namespace conflicts with Boost.Endian + were fixed. [PR#349](https://github.com/boostorg/spirit/pull/349) [PR#482](https://github.com/boostorg/spirit/pull/482) + - utree + + * Fixed UB in tag getter due to left shift of negative + value. [PR#423](https://github.com/boostorg/spirit/pull/423) + * Fixed double-conversion (`spirit::string + -> std::string + -> spirit::string`). + [PR#462](https://github.com/boostorg/spirit/pull/462) + - Qi + + * Added static asserts for rule skipper type problems. + [PR#427](https://github.com/boostorg/spirit/pull/427) + * The `check\_overflow` + trait default implementation now relies on `std::numeric\_limits::is\_bounded` instead + of `boost::integer\_traits::is\_integral` + [PR#429](https://github.com/boostorg/spirit/pull/429) + * Integer parsers should now handle user defined types. + [PR#429](https://github.com/boostorg/spirit/pull/429) + * **Note:** The `check\_overflow` trait + default implementation now relies on `std::numeric\_limits::is\_bounded` + instead of `boost::integer\_traits::is\_integral`. + * Removed broken 1.0#INF parser. It was poorly documented + and never worked. [#415](https://github.com/boostorg/spirit/issues/415) [PR#458](https://github.com/boostorg/spirit/pull/458) [#8699](https://svn.boost.org/trac/boost/ticket/8699) + * The undocumented `make\_attribute` + trait was merged into `transform\_attribute` + trait. [PR#471](https://github.com/boostorg/spirit/pull/471) + * The `pre\_transform`, + `post\_transform`, + and `fail\_transform` + utility functions were removed in favor of directly using + `pre`/`post`/`fail` of the transform + trait. [PR#467](https://github.com/boostorg/spirit/pull/467) + * The integer value parser now respects `std::numeric\_limits::digits10` + value. [PR#469](https://github.com/boostorg/spirit/pull/469) + * Fixed underflow check for a `(Min % + Base) + == 0` + corner case. [PR#469](https://github.com/boostorg/spirit/pull/469) + * Fixed an output value on overflow of IgnoreOverflowDigits=true + integer parser. [PR#470](https://github.com/boostorg/spirit/pull/470) + * Special handling of references in `transform\_attribute` + was removed. [PR#480](https://github.com/boostorg/spirit/pull/480) + - Lex + + * Fixed UB in default constructor of lexer with user specified + token type. [PR#420](https://github.com/boostorg/spirit/pull/420) + + Classic: + + - Fixed `position\_iterator` + forming reference to local when the underlying iterator dereference + operator returns a non-reference type. [PR#422](https://github.com/boostorg/spirit/pull/422) [#9737](https://svn.boost.org/trac/boost/ticket/9737) +* [Stacktrace](/libs/stacktrace/): + + + Build fix for iOS 32-bit ARM (many thanks to Ivan Ponomarev for providing + the fix [PR#70](https://github.com/boostorg/stacktrace/pull/70)) + + Fixed multiple typos, warnings and updated the docs. +* [Test](/libs/test/): + + + Boost.test v3.10 see the [Changes + log](/libs/test/doc/html/boost_test/change_log.html) for more details. + + Breaking changes: + + - Boost.Test `minimal.hpp` + is now showing a deprecation warning, + - Change in floating point comparison may fail tests that were + silently not using the floating point comparison logic prior + to this release, + - Internal API change to `unit\_test\_log\_formatter`, + see detailed change log, + + New feature: + + - Floating point comparison has been extended to capture non-floating + point and arithmetic operands: expressions like `BOOST\_TEST(3.0001 == + 3)` + now use floating point support of Boost.Test, + - Custom datasets are not required to declare the `sample` type field anymore, + - Extending template test cases from `std::tuple` + to any variadic definition, + - Windows support for timed tests, + - Timed test on test-suites, + - Removed dependency to Boost.Timer, + - New macro `BOOST\_TEST\_INFO\_SCOPE` + for scoped context declaration, + - Improved `BOOST\_TEST\_CONTEXT` + syntax + + Bug fixes and pull requests: + + - Trac tickets: [#7397](https://svn.boost.org/trac/boost/ticket/7397), [#9434](https://svn.boost.org/trac/boost/ticket/9434), [#13106](https://svn.boost.org/trac/boost/ticket/13106), [#13418](https://svn.boost.org/trac/boost/ticket/13418) + - GitHub Issues: [#133](https://github.com/boostorg/test/issues/133), [#138](https://github.com/boostorg/test/issues/138), [#141](https://github.com/boostorg/test/issues/141), [#157](https://github.com/boostorg/test/issues/157), + [#160](https://github.com/boostorg/test/issues/160), [#174](https://github.com/boostorg/test/issues/174), [#176](https://github.com/boostorg/test/issues/176), [#177](https://github.com/boostorg/test/issues/177), [#180](https://github.com/boostorg/test/issues/180), + [#181](https://github.com/boostorg/test/issues/181), [#194](https://github.com/boostorg/test/issues/194), [#196](https://github.com/boostorg/test/issues/196), [#198](https://github.com/boostorg/test/issues/198), [#199](https://github.com/boostorg/test/issues/199), + [#202](https://github.com/boostorg/test/issues/202), [#203](https://github.com/boostorg/test/issues/203), [#204](https://github.com/boostorg/test/issues/204) + - GitHub Pull Requests: [PR#171](https://github.com/boostorg/test/pull/171), [PR#172](https://github.com/boostorg/test/pull/172), [PR#182](https://github.com/boostorg/test/pull/182), + [PR#183](https://github.com/boostorg/test/pull/183), [PR#184](https://github.com/boostorg/test/pull/184), [PR#190](https://github.com/boostorg/test/pull/190), [PR#195](https://github.com/boostorg/test/pull/195), + [PR#195](https://github.com/boostorg/test/pull/195), [PR#197](https://github.com/boostorg/test/pull/197), [PR#205](https://github.com/boostorg/test/pull/205) +* [TypeIndex](/libs/type_index/): + + + Support for the GHS C++ compiler added (many thanks to Brandon Castellano + for providing the patch [PR#28](https://github.com/boostorg/type_index/pull/28)) + + Optimized string and type comparisons (many thanks to Andrey Semashev + for providing the patch [PR#23](https://github.com/boostorg/type_index/pull/23)) + + Fixed clang-win compilation (many thanks to Peter Dimov for providing + the patch [PR#25](https://github.com/boostorg/type_index/pull/25)) + + CI hardening. +* [TypeTraits](/libs/type_traits/): + + + Added is\_bounded\_array and is\_unbounded\_array (Glen Fernandes). + + Added copy\_reference and copy\_cv\_ref (Glen Fernandes). + + Improved support for msvc with /clr option. + + Misc compiler compatibility fixes. +* [Variant](/libs/variant/): + + + Many cleanups and internal improvements, many thanks to Nikita Kniazev + ([PR#55](https://github.com/boostorg/variant/pull/55), [PR#56](https://github.com/boostorg/variant/pull/56), [PR#57](https://github.com/boostorg/variant/pull/57)) and Louis Dionne + ([PR#51](https://github.com/boostorg/variant/pull/51)) + + CI hardening. +* [uBlas](/libs/numeric/ublas/): + + + Addition of tensor framework (many thanks to Cem Bassoy [PR#65](https://github.com/boostorg/ublas/pull/65)) + + Addition of basic OpenCL support (many thanks to Fady Essam [PR#59](https://github.com/boostorg/ublas/pull/59)) + + Integration of basic benchmark suite (many thanks to Stefan Seefeld + [PR#57](https://github.com/boostorg/ublas/pull/57)) + + CI integration and hardening + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 4.0.1, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1, 7.0.0, 8.0.0 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1, 7.0.0, 8.0.0 + + Clang, C++17: 5.0.2, 6.0.1, 7.0.0, 8.0.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 5.4.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++11: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++14: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++17: 9.1.0, 10.0.0 + + Apple Clang, C++1z: 9.0.0 + + Apple Clang, C++2a: 10.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.8.1, 3.9.1, 4.0.1, 5.0.2, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1, 7.0.0, 8.0.0 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1, 7.0.0, 8.0.0 + + Clang, C++17: 5.0.2, 6.0.1, 7.0.0, 8.0.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.9.4, 5.4.0, 5.5.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.3.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1, 8.1.0 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++11: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++14: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++17: 9.1.0, 10.0.0 + + Apple Clang, C++1z: 9.0.0 + + Apple Clang, C++2a: 10.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + +### Acknowledgements + Daniel James, Vladimir Prus, Marshall Clow and Michael Caisse managed this + release. + + + + + + + + + + + + diff --git a/users/history/version_1_71_0.html b/users/history/version_1_71_0.html new file mode 100644 index 0000000..5cbed70 --- /dev/null +++ b/users/history/version_1_71_0.html @@ -0,0 +1,658 @@ +--- +title: Version 1.71.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.71.0 + +/\*\*/ + + + + + + + +Version 1.71.0 +============== + +Version 1.71.0 +-------------- + + +August 19th, 2019 15:31 GMT + + +[Documentation](/doc/libs/1_71_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_71\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.71.0/source/boost_1_71_0.tar.bz2) | d73a8da01e8bf8c7eda40b4c84915071a8c8a0df4a6734537ddde4a8580524ee | +| [boost\_1\_71\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.71.0/source/boost_1_71_0.tar.gz) | 96b34f7468f26a141f6020efb813f1a2f3dfb9797ecf76a7d7cbd843cc95f5bd | +| windows | [boost\_1\_71\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.71.0/source/boost_1_71_0.7z) | 1b3949ffddf56129141032542523920034f2e69775fb9332a52ba37c548dbf35 | +| [boost\_1\_71\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.71.0/source/boost_1_71_0.zip) | 85a94ac71c28e59cf97a96714e4c58a18550c227ac8b0388c260d6c717e47a69 | + + +### New Libraries + + +* [Variant2](/libs/variant2/): A never-valueless, + strong guarantee implementation of `std::variant`, + from Peter Dimov. + +### Updated Libraries + + +* [Align](/libs/align/): + + + Support for any integral type in the integral versions of `align\_up` and `align\_down`. + + Revised the implementation of `aligned\_allocator` + to no longer require a specialization for `void`. + + Define `propagate\_on\_container\_move\_assignment` + and `is\_always\_equal` + in `aligned\_allocator`. +* [Asio](/libs/asio/): + + + Improved performance slightly by eliminating a redundant move construction + when completed handlers are dispatched. + + Eliminated a compiler warning by annotating a `case` + fall-through in the free function `connect()` implementation. + + Fixed the `is\_\*\_buffer\_sequence` detection traits + for user-defined sequence types. + + Fixed some Windows-specific warnings about an incompatible pointer + cast when obtaining the `CancelIoEx` + entry point. + + Changed to automatically set the defaults when opening a serial port + on Windows. + + Changed the serial port `get\_option()` member function to be const. + + Fixed a name hiding issue with the WinRT stream-oriented socket backend's + `shutdown` function. + + Applied a minor fix to the documentation for `is\_dynamic\_buffer`. + + Added some support for Haiku OS. + + Added wolfSSL compatability. + + Changed to require C++17 or later for coroutines TS support with + clang. + + Fixed a doxygen generation problem in the tutorial. + + Ensured example programs are correctly incorporated into the documentation. +* [Any](/libs/any/): + + + Static initialization of the default constructed `boost::any` + is now possible. + + Fixed performance regression in assignment on a compilers without + move-semantics. + + Maintenance work. +* [Beast](/libs/beast/): + + + This version consists mostly of bug fixes and performance improvements. + + Substantial work included for the split compilation mode, to reduce + compile time when defining `BOOST\_BEAST\_SEPARATE\_COMPILATION`. + + We'd love to know how you or your company use Beast, consider adding + an item to the [Companies + and Individuals Using Beast](https://github.com/boostorg/beast/wiki/Companies-and-Individuals-Using-Beast) list. + + See the full [Release + Notes](/libs/beast/doc/html/beast/release_notes.html) for a complete list of changes. +* [Circular Buffer](/libs/circular_buffer/): + + + Correct doxygen generated reference to no longer show internal members. + (Glen Fernandes) + + Eliminate ubsan warning on `add` + and `sub`. (Glen Fernandes) + + Fix incorrect check in `is\_uninitialized`. + (Niklas Fejes) +* [Container](/libs/container/): + + + Fixed bugs: + + - [GitHub + #47: *"added alignment specification for small\_vector"*](https://github.com/boostorg/container/pull/47). + - [GitHub + #88: *"Implement C++17 MoveAssignable requirements + for self-move assignments"*](https://github.com/boostorg/container/issues/88). + - [GitHub + #107: *"Alignment ignored in resource\_adaptor"*](https://github.com/boostorg/container/issues/107). + - [GitHub + #109: *"Get rid of integer overflow in copy\_move\_algo.hpp + (-fsanitize=integer)"*](https://github.com/boostorg/container/pull/109). + - [GitHub + #110: *"Avoid gcc 9 deprecated copy warnings + in new\_allocator.hpp"*](https://github.com/boostorg/container/pull/110). + - [GitHub + #112: *"vector::resize() compilation error with + msvc-10..12: data is not a member of boost::detail::aligned\_storage"*](https://github.com/boostorg/container/issues/112). + - [GitHub + #114: *"Fix small\_vector noexcept specification"*](https://github.com/boostorg/container/issues/114). + - [GitHub + #116: *"MSVC + boost 1.70 compilation error when + windows.h is already included (detail/thread\_mutex.hpp)"*](https://github.com/boostorg/container/issues/116). + - [GitHub + #117: *"flat\_map/map::insert\_or\_assign with hint + has wrong return types"*](https://github.com/boostorg/container/issues/117). + - [GitHub + #118: *"Non-unique inplace\_set\_difference used + in in flat\_tree\_merge\_unique and iterator invalidation in insert\_unique"*](https://github.com/boostorg/container/issues/118). + - [GitHub + #122: *"Fix has\_trivial\_destructor\_after\_move"*](https://github.com/boostorg/container/issues/122). + - [GitHub + #123: *"With heterogeneous lookup, `equal\_range` can result in + a range with length greater than 1"*](https://github.com/boostorg/container/issues/123). + + `deque` can now + have options, using `deque_options`. + The block size/bytes can be be specified. + + `static_vector` + can now have options, using `static_vector_options`. + Alignment and throwing behaviour can be be specified. + + `small_vector` + can now have options, using `small_vector_options`. + Alignment and growth factor can be be specified. +* [Context](/libs/context/): + + + Add support for RISC-V LP64D + + [#72](https://github.com/boostorg/context/issues/72): Fix ABI violation on ppc64 ELFv2 + + [#99](https://github.com/boostorg/context/issues/99): cleanup of stack if creating ucontext fails +* [Conversion](/libs/conversion/): + + + Maintenance work. +* [Core](/libs/core/): + + + Added functions `alloc\_construct`, + `alloc\_construct\_n`, + `alloc\_destroy`, and + `alloc\_destroy\_n` in + `` for allocator aware and exception + safe construction and destruction of objects and arrays. (Glen Fernandes) + + Added constexpr functions `first\_scalar` + in `` for obtaining a pointer to the + first scalar element of an array. Given a pointer of type `T\*` + they return a pointer of type `remove\_all\_extents\_t\*`. (Glen Fernandes) + + Added class template `noinit\_adaptor` + in `` which is an allocator adaptor + that converts any allocator into one whose `construct(ptr)` performs default initialization + via placement new, and whose `destroy(ptr)` invokes the `value\_type` + destructor directly. (Glen Fernandes) + + Added class template `default\_allocator` + in ``, which can serve as a minimal + default allocator that has interface similar to C++20 `std::allocator`, supports configurations + with disabled exceptions and does not have `std` + as an associated namespace. The allocator uses `operator + new` and `operator + delete` for allocation. (Glen + Fernandes) + + In `` header, added workarounds for + better compatibility with QNX SDP 7.0 when libc++/libc++abi libraries + are used. (Andrey Semashev, [#59](https://github.com/boostorg/core/issues/59)) + + The `` header is now marked as deprecated + and will be removed in a future release. `` + should be used instead. (Peter Dimov) +* [Dynamic Bitset](/libs/dynamic_bitset/): + + + Enabled hardware-assisted popcount on MSVC ([PR#38](https://github.com/boostorg/dynamic_bitset/pull/38)). + + Added support for boost::hash and std::hash ([PR#45](https://github.com/boostorg/dynamic_bitset/pull/45)). + + Support copy-initialization with default constructor ([PR#48](https://github.com/boostorg/dynamic_bitset/pull/48)). +* [Endian](/libs/endian/): + + + Clarified requirements on the value type template parameter + + Added support for `float` + and `double` + + Added `endian\_load`, + `endian\_store` + + Updated `endian\_reverse` + to correctly support all non-`bool` + integral types + + Moved deprecated names to the deprecated header `endian.hpp` +* [Fiber](/libs/fiber/): + + + documentation for shared\_work updated +* [Filesystem](/libs/filesystem/): + + + Fixed incorrect `error\_code` + returned from directory iterator increment when `readdir\_r` + is used. + + For `path`, fixed rvalue-aware + `operator/` + return type to return an rvalue instead of rvalue reference. This + fixes leaving a dangling reference in the user's code if the result + of `operator/` + is bound to a const reference. ([#110](https://github.com/boostorg/filesystem/issues/110)) + + Fixes for better compatibility with Windows CE. ([PR#24](https://github.com/boostorg/filesystem/pull/24)) + + Added minimal support for CMake. ([PR#106](https://github.com/boostorg/filesystem/pull/106)) +* [Flyweight](/libs/flyweight/index.html): + + + Maintenance work. +* [Histogram](/libs/histogram/index.html): + + + New features: + + - Support for thread-safe storages and new thread-safe accumulators + - Support for compiling without exceptions/RTTI (increases performance + by 10-20 %) (with Glen Fernandes) + - Performance improvements for 1D and 2D histograms + - boost::histogram::indexed now returns forward iterator range + instead of input iterator range + - boost::histogram::indexed\_range::accessor is now non-copyable + and acts like reference to cell value, making more algorithms + from the C++ stdlib work + - boost::histogram::algorithm::reduce with new slice option and + option fusion + - boost::histogram::algorithm::project accepts runtime indices + for static histograms + + Bug Fixes: + + - boost::histogram::algorithm::reduce also works on histograms + that have some axis types without reduction support + - boost::histogram::axis::traits::update now works correctly + for boost::histogram::axis::variant + + Other: + + - 100 % test coverage + - Reduced internal Boost dependencies + - Improved documentation and examples + - Guaranteed no-throw moves for all builtin axis types + - Compile cleanly at higher warning levels + + See [changelog](/libs/histogram/doc/html/histogram/history.html) + for more details. +* [IoStreams](/libs/iostreams/): + + + Fixed processing of multi-stream files ([PR#87](https://github.com/boostorg/iostreams/pull/87)). + + Added support for multi-threaded LZMA ([PR#95](https://github.com/boostorg/iostreams/pull/95)). +* [Interprocess](/libs/interprocess/): + + + [GitHub + #85 (*"warning: Implicit conversion loses integer precision"*)](https://github.com/boostorg/interprocess/pull/85). + + [GitHub + #86 (*"warning: Possible misuse of comma operator"*)](https://github.com/boostorg/interprocess/pull/86). +* [Intrusive](/libs/intrusive/): + + + [GitHub + #42: *Documentation does not describe treap priority\_of\_value + changes*](https://github.com/boostorg/intrusive/pull/42) + + [GitHub + #43: *Fix tests with BOOST\_INTRUSIVE\_VARIADIC\_TEMPLATES + enabled*](https://github.com/boostorg/intrusive/pull/43) + + [GitHub + #45: *Disable variadic templates for MSVC-12 to avoid ICEs*](https://github.com/boostorg/intrusive/pull/45) +* [LexicalCast](/libs/lexical_cast/): + + + Added tests for `boost::filesystem::path` + conversions [#25](https://github.com/boostorg/lexical_cast/issues/25). + + Maintenance work, including [#28](https://github.com/boostorg/lexical_cast/issues/28). +* [Log](/libs/log/): + + + New features: + + - Improved support for C++17 `std::string\_view` + in `basic\_formatting\_ostream`. + The string view can now participate in character code conversion + on output. + - Added `auto\_newline` + formatter and stream manipulator. It can be used to ensure + that formatted output always ends with a newline while avoiding + duplicate newlines. + - In the output stream, text file and text multi-file sink backends + added support for configuring behavior with regard to appending + a trailing newline to every formatted log record. Use `auto\_newline\_mode` named parameter + of the backend constructor or call the `set\_auto\_newline\_mode` + method on the sink backend. + - **Note:** The default behavior + with regard to trailing newlines added by sink backends has + changed slightly compared to the previous Boost.Log releases. + The backends will now only add a trailing newline if there + isn't one in the formatted log message string already. In previous + releases a newline was added unconditionally. + - Added support for passing arbitrary function objects in the + `filter` and + `format` named + parameters to sink constructors and convenience functions for + initializing sinks. For example, it is now possible to specify + C++11 lambda functions directly in these parameters. ([#63](https://github.com/boostorg/log/issues/63)) + - In the default filter and formatter factories used in filter + and formatter parsers, added support for severity level attribute + values of type `boost::log::trivial::severity\_level`. + For filters, the support is limited to attributes with "Severity" + name. + + Bug fixes: + + - Fixed incorrect parsing of components of the rotated file names + while scanning for files in the text file sink backend. If + the file name pattern ended with a placeholder (for example, + a file counter), the `scan\_for\_files` + method would not find files matching that pattern in the target + storage, leaving them unmanaged. In particular, such files + would not be deleted to free target storage. ([#78](https://github.com/boostorg/log/issues/78)) + - Updated `basic\_formatting\_ostream` + and `basic\_record\_ostream` + to make it possible to overload stream output operators for + pointers to user-defined types. User-defined `operator<<` + overloads taking `std::basic\_ostream` + and a pointer argument should now be picked up by the compiler + when the pointer is being written to one of Boost.Log streams. + ([#84](https://github.com/boostorg/log/issues/84)) + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Math](/libs/math/): + + + New features: + + - Catmull-Rom interpolator now works in C++11 + - Cardinal quadratic B-spline interpolation + - Domain of elliptic integrals extended + - sin\_pi and cos\_pi performance improvements + - Forward-mode automatic differentiation + - Vector valued barycentric rational interpolation + - Ooura's method for evaluation of Fourier integrals + + Bug fixes: + + - Multiple compatibility issues with Multiprecision fixed + - Lambert-W fixed on a rare architecture +* [Metaparse](/libs/metaparse/): + + + New features: + + - In C++11 variadic template support for the following: `sequence`, `one\_of\_c`, + `one\_of`, `repeated\_one\_of`, `repeated\_one\_of1`, `one\_char\_except\_c`, `one\_char\_except`. + + Bug fixes: + + - `BOOST\_METAPARSE\_STRING` + does not use out of range character values as template arguments. + - `any\_of\_c<>` + does not create empty array in C++14. +* [Move](/libs/move/): + + + [Git Issue + #26: *"Invalid iterator increment/decrement in the + last iteration of adaptive\_sort\_combine\_blocks"*](https://github.com/boostorg/move/issues/26). +* [Multi Array](/libs/multi_array/): + + + Simplify allocator support by using new `alloc\_construct\_n` + and `alloc\_destroy\_n` + facilities from Core. (Glen Fernandes) +* [Multi-index Containers](/libs/multi_index/): + + + Added [variants + of `const\_mem\_fun` + and `mem\_fun`](/libs/multi_index/doc/tutorial/key_extraction.html#x_mem_fun) + for differently qualified member functions (issue [#24](https://github.com/boostorg/multi_index/issues/24)). + + Terse [`key`](/libs/multi_index/doc/reference/key_extraction.html#key) specification syntax + now correctly handles `noexcept`-specified + member functions (issue [#24](https://github.com/boostorg/multi_index/issues/24)). +* [Outcome](/libs/outcome/): + + + Enhancements: + + - [#184](https://github.com/ned14/outcome/issues/184) + As per request from Boost release managers, relocated `version.hpp` and `revision.hpp` + into detail, and added the Boost licence boilerplate to the + top of every source file which was missing one (I think). Also + took the opportunity to run the licence restamping script over + all Outcome, so copyright dates are now up to date. + - [#185](https://github.com/ned14/outcome/issues/185) + Add FAQ item explaining issue #185, and why we will do nothing + to fix it right now. + - [#189](https://github.com/ned14/outcome/issues/189) + Refactored the `OUTCOME\_TRY` + implementation to use more clarified customisation points capable + of accepting very foreign inputs. Removed the `std::experimental::expected` + specialisations, as those are no longer necessary. Fixed the + documentation for the customisation points which previously + claimed that they are ADL discovered, which they are not. Added + a recipe describing how to add in support for foreign input + types. + - [#183](https://github.com/ned14/outcome/issues/183) + Added a separate `motivation/plug\_error\_code` + specifically for Boost. + + Bug fixes: + + - `OUTCOME\_VERSION\_MINOR` + hadn't been updated to 1. + - [#181](https://github.com/ned14/outcome/issues/181) + Fix issue #181 where Outcome didn't actually implement the + strong swap guarantee, despite being documented as doing so. + - [#190](https://github.com/ned14/outcome/issues/190) + Fix issue #190 in Boost edition where unit test suite was not + runnable from the Boost release distro. + - [#182](https://github.com/ned14/outcome/issues/182) + Fix issue #182 where `trait::is\_exception\_ptr\_available` was always true, thus causing + much weirdness, like not printing diagnostics and trying to + feed everything to `make\_exception\_ptr()`. + - [#192](https://github.com/ned14/outcome/issues/192) + Fix issue #192 where the `std::basic\_outcome\_failure\_exception\_from\_error()` was being defined twice for + translation units which combine standalone and Boost Outcome's. +* [Parameter](/libs/parameter/doc/html/index.html): + + + Upgraded keyword generation macro `BOOST\_PARAMETER\_TEMPLATE\_KEYWORD` + ([PR#15](https://github.com/boostorg/parameter/pull/15)). + + Moved keyword generation macro `BOOST\_PARAMETER\_NESTED\_KEYWORD` + from [Accumulators](/libs/accumulators/doc/html/index.html) + to this library ([PR#28](https://github.com/boostorg/parameter/pull/28)). + + Added support for `std::reference\_wrapper` + and `std::ref()` + ([PR#16](https://github.com/boostorg/parameter/pull/16)). + + Moved `boost::parameter::required`, `boost::parameter::optional`, + and `boost::parameter::deduced` metafunction definitions + to their own header files in directory boost/parameter ([PR#18](https://github.com/boostorg/parameter/pull/18)). + + Added support for Boost.[Parameter](/libs/parameter/doc/html/index.html)-enabled + function call operators ([PR#20](https://github.com/boostorg/parameter/pull/20)). + + Added support for parameter category qualifiers "forward", + "consume", and "move\_from" (current qualifiers + are "in", "out", and "in\_out") ([PR#21](https://github.com/boostorg/parameter/pull/21)) + ([PR#23](https://github.com/boostorg/parameter/pull/23)) based on . + Added new usage syntax `BOOST\_PARAMETER\_NAME((object-name), namespace-name) qualifier(tag-name))` and `BOOST\_PARAMETER\_NAME(qualifier(name))`. (Existing code that uses qualifiers + directly and correctly with `BOOST\_PARAMETER\_FUNCTION` + and other code generation macros should remain unaffected for now, + so no breaking changes.) The reason for the change in usage is to + enable applying of parameter category constraints to Boost.[Parameter](/libs/parameter/doc/html/index.html)-enabled + functions and constructors invoked through argument composition. + (Otherwise, it is currently possible to use argument composition + to bypass parameter category constraints applied in `BOOST\_PARAMETER\_FUNCTION` et. al.) + + Added support for perfect forwarding ([PR#23](https://github.com/boostorg/parameter/pull/23)) ([PR#26](https://github.com/boostorg/parameter/pull/26)), + so that `parameter::parameters::operator()` can accept non-`const` + rvalues. As a positive side effect, Boost.[Parameter](/libs/parameter/doc/html/index.html)-enabled + functions and constructors are no longer bound by `BOOST\_PARAMETER\_MAX\_ARITY` + on compilers that support perfect forwarding. User code can now check + for this support by detecting the configuration macro `BOOST\_PARAMETER\_HAS\_PERFECT\_FORWARDING`, + or manually turn off this support by defining the configuration macro + `BOOST\_PARAMETER\_DISABLE\_PERFECT\_FORWARDING`. + + Added metafunctions `boost::parameter::is\_argument\_pack` + ([PR#27](https://github.com/boostorg/parameter/pull/27)), `boost::parameter::are\_tagged\_arguments` + ([PR#52](https://github.com/boostorg/parameter/pull/52)), and `boost::parameter::result\_of::compose` + ([PR#75](https://github.com/boostorg/parameter/pull/75)). + + Added variadic function template `boost::parameter::compose()` which takes in named arguments + and returns them in an argument pack ([PR#52](https://github.com/boostorg/parameter/pull/52)). For compilers + that do not support perfect forwarding, the configuration macro + `BOOST\_PARAMETER\_COMPOSE\_MAX\_ARITY` + determines the maximum number of arguments that `boost::parameter::compose()` can take in ([PR#61](https://github.com/boostorg/parameter/pull/61)). + + Added code generation macros `BOOST\_PARAMETER\_BASIC\_FUNCTION\_CALL\_OPERATOR`, + `BOOST\_PARAMETER\_BASIC\_CONST\_FUNCTION\_CALL\_OPERATOR`, + `BOOST\_PARAMETER\_NO\_SPEC\_FUNCTION`, + `BOOST\_PARAMETER\_NO\_SPEC\_MEMBER\_FUNCTION`, + `BOOST\_PARAMETER\_NO\_SPEC\_CONST\_MEMBER\_FUNCTION`, + `BOOST\_PARAMETER\_NO\_SPEC\_FUNCTION\_CALL\_OPERATOR`, + `BOOST\_PARAMETER\_NO\_SPEC\_CONST\_FUNCTION\_CALL\_OPERATOR`, + `BOOST\_PARAMETER\_NO\_SPEC\_CONSTRUCTOR`, + and `BOOST\_PARAMETER\_NO\_SPEC\_NO\_BASE\_CONSTRUCTOR` + ([PR#52](https://github.com/boostorg/parameter/pull/52)). + + Added support for Boost.[MP11](/libs/mp11/doc/html/mp11.html) + ([PR#47](https://github.com/boostorg/parameter/pull/47)) ([PR#66](https://github.com/boostorg/parameter/pull/66)) ([PR#70](https://github.com/boostorg/parameter/pull/70)). User code + can now check for this support by detecting the configuration macro + `BOOST\_PARAMETER\_CAN\_USE\_MP11`, + or manually turn off this support by defining the configuration macro + `BOOST\_PARAMETER\_DISABLE\_MP11\_USAGE`. + + Improved support for parameter-dependent return types via SFINAE + ([PR#73](https://github.com/boostorg/parameter/pull/73)). +* [PtrContainer](/libs/ptr_container/): + + + Fix a ptr\_vector regression introduced in 1.66.0 ([PR#24](https://github.com/boostorg/ptr_container/pull/24)). +* [PolyCollection](/libs/poly_collection/): + + + Maintenance work. +* [SmartPtr](/libs/smart_ptr/): + + + Added aliasing constructors to `weak\_ptr` + + Added `weak\_ptr::empty()` + + Added `enable\_shared\_from`, + `shared\_from`, and + `weak\_from` +* [Stacktrace](/libs/stacktrace/): + + + Fixed output of `name()`, `source\_location()` and `source\_line()` for the default constructed `frame` with thread sanitizer builds + in C++98 mode. + + Fixed output of long strings from `name()` and `source\_location()` on MSVC [#78](https://github.com/boostorg/stacktrace/issues/78). + + Maintenance work. +* [Test](/libs/test/): + + + Boost.test v3.11 see the [Changes + log](libs/test/doc/html/boost_test/change_log.html) for more details. + + Breaking changes: + + - Boost.Test shows deprecation warnings if some very old headers + as deprecated. If you encounter such warnings, please follow + the indications: those headers will be removed in a future + release. + + New feature: + + - Now `BOOST\_TEST` + can be used to compare abstract types + + Bug fixes and pull requests: + + - GitHub Issues: [#209](https://github.com/boostorg/test/issues/209), [#218](https://github.com/boostorg/test/issues/218) + - GitHub Pull Requests: [PR#219](https://github.com/boostorg/test/pull/219), [PR#224](https://github.com/boostorg/test/pull/224) +* [Utility](/libs/utility/): + + + Implemented function template `ostream\_string` + in `` to optimally write any kind of + string content to an output stream. It satisfies the requirements + of [ostream.formatted.reqmts]. (Glen Fernandes) + + Optimized the stream output operators of `basic\_string\_view` + and `basic\_string\_ref` + to write directly to the `rdbuf` + stream buffer. (Glen Fernandes) +* [Uuid](/libs/uuid/): + + + **Breaking change:** MD5 name-based + uuid generation was corrected to be identical on all endian systems. + Define `BOOST\_UUID\_COMPAT\_PRE\_1\_71\_MD5` + to keep the result in a format compatible with 1.66 through 1.70. + This does not affect the default name-based uuid generation which + is based on SHA1. ([PR#109](https://github.com/boostorg/uuid/pull/109)) +* [Variant](/libs/variant/): + + + Fixed compilation of `boost::apply\_visitor` + with variants passed by non const reference in [PR#68](https://github.com/boostorg/variant/pull/68). Many + thanks to Ed Catmur for providing the fix. + + Added support for std::hash ([PR#49](https://github.com/boostorg/variant/pull/49)). Macro `BOOST\_VARIANT\_DO\_NOT\_SPECIALIZE\_STD\_HASH` + could be defined to avoid those specializations. + + Added micro optimizations for binary size and performance by Nikita + Kniazev in [PR#63](https://github.com/boostorg/variant/pull/63) and [PR#66](https://github.com/boostorg/variant/pull/66). + + Maintenance work, including [PR#64](https://github.com/boostorg/variant/pull/64) by Nikita Kniazev and [PR#67](https://github.com/boostorg/variant/pull/67) by + Hans Dembinski. +* [YAP](/libs/yap/): + + + Added an example showing how to make self-evaluating YAP expressions + (that is, expressions that don't need an explicit call to `evaluate()` + or `transform()`). + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 4.0.1, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1, 7.0.0, 8.0.0 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1, 7.0.0, 8.0.0 + + Clang, C++17: 5.0.2, 6.0.1, 7.0.0, 8.0.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 5.4.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++11: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++14: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++17: 9.1.0, 10.0.0 + + Apple Clang, C++1z: 9.0.0 + + Apple Clang, C++2a: 10.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.8.1, 3.9.1, 4.0.1, 5.0.2, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1, 7.0.0, 8.0.0 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1, 7.0.0, 8.0.0 + + Clang, C++17: 5.0.2, 6.0.1, 7.0.0, 8.0.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.9.4, 5.4.0, 5.5.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.3.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1, 8.1.0 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++11: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++14: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++17: 9.1.0, 10.0.0 + + Apple Clang, C++1z: 9.0.0 + + Apple Clang, C++2a: 10.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + +### Acknowledgements + Marshall Clow and Michael Caisse managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_72_0.html b/users/history/version_1_72_0.html new file mode 100644 index 0000000..bf987d5 --- /dev/null +++ b/users/history/version_1_72_0.html @@ -0,0 +1,526 @@ +--- +title: Version 1.72.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.72.0 + +/\*\*/ + + + + + + + +Version 1.72.0 +============== + +Version 1.72.0 +-------------- + + +December 11th, 2019 18:06 GMT + + +[Documentation](/doc/libs/1_72_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_72\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.72.0/source/boost_1_72_0.tar.bz2) | 59c9b274bc451cf91a9ba1dd2c7fdcaf5d60b1b3aa83f2c9fa143417cc660722 | +| [boost\_1\_72\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.72.0/source/boost_1_72_0.tar.gz) | c66e88d5786f2ca4dbebb14e06b566fb642a1a6947ad8cc9091f9f445134143f | +| windows | [boost\_1\_72\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.72.0/source/boost_1_72_0.7z) | 247a91dd7e4d9dd3c4b954b532fbc167ba62dc15ab834e5ad893d7c3f9eb5f0f | +| [boost\_1\_72\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.72.0/source/boost_1_72_0.zip) | 8c20440aaba21dd963c0f7149517445f50c62ce4eb689df2b5544cc89e6e621e | + + +### Known Issues + These are patches from library authors which were found too late to be fixed + in the release. Be careful as they have not been through the normal testing + process. + + + +* Revert cease dependence on range + + + [Coroutine + patch](/patches/1_72_0/0001-revert-cease-dependence-on-range.patch) + +### Updated Libraries + + +* [Asio](/libs/asio/): + + + Changed the `async\_initiate` + helper function to automatically deduce its return type, for C++11 + or later. + + Changed all asynchronous operations to use automatically deduced + return types, for C++14 or later. + + Introduced concepts to support `async\_initiate`. + + Added the nested template type `rebind\_executor` + to all I/O object types. + + Changed the initiation function objects to report their associated + I/O executor via the nested type `executor\_type` + and member function `get\_executor()`. + + Added the `default\_completion\_token` + trait, giving I/O executor types an associated default completion + token type for use with asynchronous operations. This trait is specialised + for the `use\_awaitable` + completion token, for example, to allow asynchronous operations to + be used as follows: `co\_await + socket.async\_connect(my\_endpoint)`. + + Added missing `async\_initiate` + to the Windows-specific I/O objects' asynchronous operations. + + Ensured that the executor type is propagated to newly accepted sockets. + + Changed to require that `Protocol` + copy and move operations never throw. + + Changed to require that `Endpoint` + default constructor and move operations never throw. + + Added the `noexcept` qualifier + to protocol accessors. + + Added the `noexcept` qualifier + to socket move constructors. + + Fixed issues associated with opening serial ports on Windows: + + - Use the correct constant to initialise the RTS control flag. + - Specify a default baud rate (9600). + + Fixed a lost "outstanding work count" that can occur when + an asynchronous accept operation is automatically restarted. + + Consult the [Revision + History](/doc/libs/1_72_0/doc/html/boost_asio/history.html) for further details. +* [Atomic](/libs/atomic/): + + + Added a workaround for `\_\_float128` + not being considered as a floating point type by some versions of + libstdc++. + + Improved compatibility with clang-win compiler. +* [Beast](/libs/beast/): + + + This is a maintenance update containing bug fixes, and updates to + use the new features delivered in Boost.Asio. + + We'd love to know how you or your company use Beast, consider adding + an entry to the [Companies + and Individuals Using Beast](https://github.com/boostorg/beast/wiki/Companies-and-Individuals-Using-Beast) list. + + See the full [Release + Notes](/libs/beast/doc/html/beast/release_notes.html) for a complete list of changes. +* [Circular Buffer](/libs/circular_buffer/): + + + Fix issue [#29](https://github.com/boostorg/circular_buffer/issues/29): `max\_size()` now takes the allocator's `max\_size()` + into account. (Glen Fernandes) +* [Context](/libs/context/): + + + architecture s390x supported + + execution\_context removed +* [Endian](/libs/endian/): + + + Made `endian\_reverse`, + `conditional\_reverse` + and `\*\_to\_\*` `constexpr` + on GCC and Clang + + Added convenience load and store functions + + Added floating point convenience typedefs + + Added a non-const overload of `data()`; changed its return type to `unsigned char\*` + + Added `\_\_int128` support + to `endian\_reverse` + when available + + Added a convenience header `boost/endian.hpp` +* [Filesystem](/libs/filesystem/): + + + Extracted `filesystem\_error` + to `exception.hpp`; `file\_status` + and associated enums and functions to `file\_status.hpp`; + `directory\_entry`, + `directory\_iterator` + and `recursive\_directory\_iterator` + to `directory.hpp`. + + **Deprecated:** For backward compatibility + `operations.hpp` still includes the new headers + `exception.hpp`, `file\_status.hpp` + and `directory.hpp`, unless `BOOST\_FILESYSTEM\_NO\_DEPRECATED` + macro is defined. These implicit includes are considered deprecated + and will be removed in a future release. Users are encouraged to + include the new headers directly or include `filesystem.hpp`. + + The `filesystem\_error` + exception is now implemented in the compiled library of Boost.Filesystem. + Users may need to add linking with Boost.Filesystem library in their + projects. + + On POSIX.1-2008 platforms, use `utimensat` + instead of `utime`. + `utime` is declared + obsolete in POSIX.1-2008 and can be disabled e.g. in uClibc-ng. ([PR#115](https://github.com/boostorg/filesystem/pull/115)) + + `directory\_iterator` + is now left in the end state on memory allocation errors. + + In `directory\_iterator` + on POSIX systems, support for `readdir`/`readdir\_r` has been reworked to + avoid memory allocations for `dirent` + structures when `readdir` + is used. This reduces memory consumption and eliminates the possibility + of buffer overruns in case if `readdir` + produces a very long directory name. + + On Windows, use Boost.WinAPI to select the target Windows version. + + **New:** Added `directory\_options` + enum, which reflects the same named enum from C++20. The enum is + supported in `directory\_iterator` + and `recursive\_directory\_iterator` + to customize iteration behavior. In particular, the iterators now + support skipping directories that can't be opened due to insufficient + permissions. The `symlink\_option` + enum is now deprecated and should be replaced with `directory\_options`. + + By default, `recursive\_directory\_iterator` + is now reset to the end state in case of errors, as required by C++20. + ([#112](https://github.com/boostorg/filesystem/issues/112)) + + **New:** Added `directory\_options::pop\_on\_error` + option, which configures `recursive\_directory\_iterator` + so that it attempts to recover from iteration errors by repeatedly + invoking `pop()` + until it succeeds or the end state is reached. ([#113](https://github.com/boostorg/filesystem/issues/113)) + + **New:** Added `directory\_options::skip\_dangling\_symlinks` + option, which configures `recursive\_directory\_iterator` + so that it doesn't follow dangling directory symlinks and continues + iteration instead of reporting an error. + + **Deprecated:** The following members + of `recursive\_directory\_iterator` + are now marked as deprecated: `level()`, `no\_push\_pending()`, `no\_push\_request()`, `no\_push()`. Users are advised to replace their + use with the standard counterparts: `depth()`, `recursion\_pending()`, `disable\_recursion\_pending()`. Note that `recursion\_pending()` has the opposite meaning compared + to `no\_push\_pending()` and `no\_push\_request()`. Deprecated methods will be removed + in a future release. + + Fixed `path::lexically\_relative` (and any dependent + algorithms) to correctly handle empty, dot and dot-dot path elements + in its argument. The behavior is made closer to C++17 `std::path::lexically\_relative` in that empty + and dot path elements are ignored and dot-dot path elements are accounted + by decreasing the number of dot-dot path elements to generate in + the resulting relative path. ([#76](https://github.com/boostorg/filesystem/issues/76)) +* [Functional/Factory](/libs/functional/factory/): + + + Glen Fernandes rewrote the implementations of `factory` + and `value\_factory` + to provide the following features: + + - Support r-value arguments when possible + - Support arbitrary number of arguments via variadic templates + when possible + - Support allocators that are final + - Support allocators that use fancy pointers + - Support for disabled exceptions (`BOOST\_NO\_EXCEPTIONS`) + - Improved compilation times + + The following features have been removed: + + - Increasing limits for C++03 compilers through `BOOST\_FUNCTIONAL\_VALUE\_FACTORY\_MAX\_ARITY` + - Using `boost::none\_t` + in place of `void` + through `BOOST\_FUNCTIONAL\_FACTORY\_SUPPORT\_NONE\_T` +* [GIL](/libs/gil/): + + + Added + + - GSoC 2019: Lanczos resampling for image down scaling ([PR#309](https://github.com/boostorg/gil/pull/309)). + - GSoC 2019: Methods for binary thresholding, inverted binary + thresholding and truncation thresholding ([PR#313](https://github.com/boostorg/gil/pull/313)). + - GSoC 2019: Otsu thresholding method ([PR#314](https://github.com/boostorg/gil/pull/314)). + - GSoC 2019: Adaptive thresholding using mean or gaussian-weighted + sum of the neighbourhood area ([PR#315](https://github.com/boostorg/gil/pull/315)). + - GSoC 2019: Harris response calculation (corner detector without + non-maximum filtering) ([PR#350](https://github.com/boostorg/gil/pull/350)). + - GSoC 2019: Hessian corner detector ([PR#364](https://github.com/boostorg/gil/pull/364)). + - GSoC 2019: Types for defining 2D kernel, `kernel\_2d` + and `kernel\_2d\_fixed`, + in Numeric extension ([PR#361](https://github.com/boostorg/gil/pull/361)). + - GSoC 2019: Implementation of 2D convolution as new function + `convolve\_2d` + ([PR#367](https://github.com/boostorg/gil/pull/367)). + - GSoC 2019: Box filtering using the average filter ([PR#383](https://github.com/boostorg/gil/pull/383)). + - GSoC 2019: Blur function based on normalized mean filter ([PR#383](https://github.com/boostorg/gil/pull/383)). + - GSoC 2019: Sobel and Scharr operators ([PR#392](https://github.com/boostorg/gil/pull/392)). + - GSoC 2019: Median filter to remove noise from image ([PR#393](https://github.com/boostorg/gil/pull/393)). + - Continued adding new test cases and significantly improved + overall test coverage. + - Documented purpose of `cached\_location\_t` + ([PR#287](https://github.com/boostorg/gil/pull/287)). + - Function `convolve\_1d` + in Numeric extension for convenient use of `convolve\_rows` + and `convolve\_cols` + ([PR#347](https://github.com/boostorg/gil/pull/347)) and [PR#367](https://github.com/boostorg/gil/pull/367)). + - Function `extend\_boundary` + in Numeric extension to perform image boundary extension ([PR#386](https://github.com/boostorg/gil/pull/386)). + - Project release notes maintained in Markdown file `RELEASES.md` ([PR#404](https://github.com/boostorg/gil/pull/404)). + + Changed + + - Move all tests, core features and extensions, inside `test/` + directory ([PR#302](https://github.com/boostorg/gil/pull/302)). + + Removed + + - Replace Boost.MPL with Boost.MP11 ([PR#274](https://github.com/boostorg/gil/pull/274)). + - Removed use of Boost.TypeTraits ([PR#274](https://github.com/boostorg/gil/pull/274)). + - Dropped support for GCC <= 4.8 ([PR#296](https://github.com/boostorg/gil/pull/296)). + - Remove `include/boost/gil/version.hpp` + file as unused ([PR#403](https://github.com/boostorg/gil/pull/403)). + + Fixed + + - Undetermined value of default-initialized channel and pixel + objects ([PR#273](https://github.com/boostorg/gil/pull/273)). + - Undefined behaviour due to `std::is\_trivially\_default\_constructible` + specializations ([PR#284](https://github.com/boostorg/gil/pull/284)). + - Crash when reading PNG files with an invalid header ([PR#385](https://github.com/boostorg/gil/pull/385)). + - Applied the Rule of Three for numerous types. + - Removed uses of deprecated implicit definition of defaulted + copy assignment operator or copy constructor. +* [Histogram](/libs/histogram/): + + + Several new features and performance improvements, some bug-fixes + + See the full [Release + Notes](/libs/histogram/doc/html/histogram/history.html) for a complete list of changes +* [Log](/libs/log/): + + + Improved compatibility with clang-win compiler. +* [MPI](/libs/mpi/): + + + Documentation clarifications. + + Fixed scatterv bug when using explicit input buffer offsets. + + Enable usage of MPI\_Probe and friend with Intel MPI >= 2019.4 + + Symbol visibility on Windows +* [Math](/libs/math/): + + + Added Hypergeometric functions 1F0, 0F1, 2F0, 1F1 and pFq. + + Added Jacobi polynomial (and derivatives) evaluation. + + Added Gegenbauer polynomial (and derivatives) evaluation. + + Added Cardinal B-Splines (and derivatives) as polynomial functions + in their own right. + + Added Cardinal Trigonometric Interpolation. + + Added new statistics sub-section. + + Added One Sample Student's T Test. + + Added Anderson Darling test for normality. + + Added Ljung Box test for auto-correlation. + + Added Runs test for random sequences. + + The headers `boost/math/tools/univariate\_statistics.hpp` + and `boost/math/tools/bivariate\_statistics.hpp`, have been deprecated in favor + of `boost/math/statistics/univariate\_statistics.hpp` and `boost/math/statistics/bivariate\_statistics.hpp`. + + Added The Empirical CDF distribution. + + Reworked the Sterling approximation used by multiprecision gamma + functions to be applicable to all the function that use the Lanczos + approximation at regular precision. Also extended Lanczos approximations + up to 100 decimal digit precision. +* [Multiprecision](/libs/multiprecision/): + + + Big `constexpr` update + allows cpp\_int and float128 arithmetic to be fully `constexpr` with gcc and clang 9 or + later, or any compiler supporting `std::is\_constant\_evaluated()`. + + Fix bug in variable precision mpf\_float which causes it to go into + a tailspin trying to select the correct precision - see https://github.com/boostorg/multiprecision/issues/164. +* [Outcome](/libs/outcome/): + + + Enhancements: + + - Standalone outcome is now `make + install`-able, and + cmake `find\_package()` can find it. Note that you + must separately install and `find\_package()` Outcome's dependency, quickcpplib, + else `find\_package()` of Outcome will fail. + - The git submodule mechanism used by standalone Outcome of specifying + dependent libraries has been replaced with a cmake superbuild + of dependencies mechanism instead. Upon cmake configure, an + internal copy of quickcpplib will be git cloned, built and + installed into the build directory from where an internal + `find\_package()` uses it. This breaks the + use of the unconfigured Outcome repo as an implementation of + Outcome, one must now do one of: 1. Add Outcome as subdirectory + to cmake build. 2. Use cmake superbuild (i.e. `ExternalProject\_Add()`) + to build and install Outcome into a local installation. 3. + Use one of the single header editions. + - For standalone Outcome, the current compiler is now checked + for whether it will compile code containing C++ Concepts, and + if it does, all cmake consumers of Outcome will enable C++ + Concepts. Set the cmake variable `CXX\_CONCEPTS\_FLAGS` + to an empty string to prevent auto detection and enabling of + C++ Concepts support occurring. + - `OUTCOME\_TRY` + operation now hints to the compiler that operation will be + successful. [P1886 **Error speed benchmarking**](https://wg21.link/P1886) showed + that there is considerable gain in very small functions by + hinting to the compiler whether the expression is expected + to be successful or not. `OUTCOME\_TRY` + previously did not hint to the compiler at all, but now it + does. A new suite of macros `OUTCOME\_TRY\_FAILURE\_LIKELY` + hint to the compiler that failure is expected. If you wish + to return to the previously unhinted behaviour, define `OUTCOME\_TRY\_LIKELY(expr)` + to `(!!expr)`. + - [#199](https://github.com/ned14/outcome/issues/199) + Support for C++ Coroutines has been added. This comes in two + parts, firstly there is now an `OUTCOME\_CO\_TRY()` operation suitable for performing + the `TRY` operation + from within a C++ Coroutine. Secondly, in the header `outcome/coroutine\_support.hpp` there are implementations + of `eager` + and `lazy` + which let you more naturally and efficiently use `basic\_result` or `basic\_outcome` from within + C++ Coroutines -- specifically, if the result or outcome will + construct from an exception pointer, exceptions thrown in the + coroutine return an errored or excepted result with the thrown + exception instead of throwing the exception through the coroutine + machinery (which in current compilers, has a high likelihood + of blowing up the program). Both `eager` and `lazy` can accept any `T` as well. Both have been + tested and found working on VS2019 and clang 9. + - [#210](https://github.com/ned14/outcome/issues/210) + `make\_error\_code()` and `make\_exception\_ptr()` are now additionally considered + for compatible copy and move conversions for `basic\_result<>`. + This lets you construct a `basic\_result` into a `basic\_result`, where `E` + is a custom type which has implemented the ADL discovered free + function `error\_code + make\_error\_code(E)`, + but is otherwise unrelated to `error\_code`. + The same availability applies for `exception\_ptr` + with `make\_exception\_ptr()` being the ADL discovered + free function. `basic\_outcome<>` has less support for + this than `basic\_result<>` in order to keep constructor + count down, but it will accept via this mechanism conversions + from `basic\_result<>` and `failure\_type<>`. + + Bug fixes: + + - [#184](https://github.com/ned14/outcome/issues/184) + The detection of `[[nodiscard]]` + support in the compiler was very mildly broken. +* [PolyCollection](/libs/poly_collection/): + + + Maintenance work. +* [Preprocessor](/libs/preprocessor/): + + + Topic added which discusses emptiness + + Support for the C++20 `\_\_VA\_OPT\_\_` + construct + + - `BOOST\_PP\_VARIADIC\_HAS\_OPT` + whether `\_\_VA\_OPT\_\_` + is supported at the C++20 level + - `BOOST\_PP\_CHECK\_EMPTY` + test for emptiness using `\_\_VA\_OPT\_\_` + at the C++20 level + - `BOOST\_PP\_VA\_OPT` + more flexible alternative to `\_\_VA\_OPT\_\_` + at the C++20 level +* [Smart Pointers](/libs/smart_ptr/): + + + Implemented `allocate\_unique` + for scalars and arrays. (Glen Fernandes) +* [Test](/libs/test/): + + + Boost.test v3.12 see the [Changes + log](/libs/test/doc/html/boost_test/change_log.html) for more details. + + New feature: + + - Support for C++17 `std::string\_view` + has been added. + - Better diagnostic on `boost::exception` + and no rtti mode (thanks to Mikhail Pilin / [pull\_request 234]) + + Bug fixes and pull requests: + + - GitHub Issues: [#206](https://github.com/boostorg/test/issues/206), [#217](https://github.com/boostorg/test/issues/217), [#223](https://github.com/boostorg/test/issues/223), [#229](https://github.com/boostorg/test/issues/229) + - GitHub Pull Requests: [PR#227](https://github.com/boostorg/test/pull/227), [PR#231](https://github.com/boostorg/test/pull/231), [PR#232](https://github.com/boostorg/test/pull/232), + [PR#234](https://github.com/boostorg/test/pull/234) +* [VMD](/libs/vmd/): + + + `BOOST\_VMD\_IS\_EMPTY` + updated to use `\_\_VA\_OPT\_\_` + at the C++20 level has 100% reliability + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 4.0.1, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1, 7.0.0, 8.0.0 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1, 7.0.0, 8.0.0 + + Clang, C++17: 5.0.2, 6.0.1, 7.0.0, 8.0.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 5.4.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++11: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++14: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++17: 9.1.0, 10.0.0 + + Apple Clang, C++1z: 9.0.0 + + Apple Clang, C++2a: 10.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.8.1, 3.9.1, 4.0.1, 5.0.2, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1, 7.0.0, 8.0.0 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1, 7.0.0, 8.0.0 + + Clang, C++17: 5.0.2, 6.0.1, 7.0.0, 8.0.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.9.4, 5.4.0, 5.5.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.3.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1, 8.1.0 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++11: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++14: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++17: 9.1.0, 10.0.0 + + Apple Clang, C++1z: 9.0.0 + + Apple Clang, C++2a: 10.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + +### Acknowledgements + Marshall Clow and Michael Caisse managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_73_0.html b/users/history/version_1_73_0.html new file mode 100644 index 0000000..94c23d4 --- /dev/null +++ b/users/history/version_1_73_0.html @@ -0,0 +1,633 @@ +--- +title: Version 1.73.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.73.0 + +/\*\*/ + + + + + + + +Version 1.73.0 +============== + +Version 1.73.0 +-------------- + + +April 28th, 2020 03:57 GMT + + +[Documentation](/doc/libs/1_73_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_73\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.73.0/source/boost_1_73_0.tar.bz2) | 4eb3b8d442b426dc35346235c8733b5ae35ba431690e38c6a8263dce9fcbb402 | +| [boost\_1\_73\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.73.0/source/boost_1_73_0.tar.gz) | 9995e192e68528793755692917f9eb6422f3052a53c5e13ba278a228af6c7acf | +| windows | [boost\_1\_73\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.73.0/source/boost_1_73_0.7z) | d2e7501bb04fe7abc09aa93f013ae997604286a882da1bd36ddd96ea1163ea71 | +| [boost\_1\_73\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.73.0/source/boost_1_73_0.zip) | 0909a79524f857ef54570ceef8f397cc0629202532cc997785479c7c08bbc2a4 | + + +### Known Issues + These are patches from library authors which were found too late to be fixed + in the release. Be careful as they have not been through the normal testing + process. + + + +* Outcome `status\_code\_domain` + assertion removal + + + [Outcome patch](/patches/1_73_0/0001-outcome-assert.patch) +* Beast and coroutines + + + [Beast patch](/patches/1_73_0/0002-beast-coroutines.patch) + +### New Libraries + + +* [Nowide](/libs/nowide/): Standard library functions + with UTF-8 API on Windows, from Artyom Beilis. +* [StaticString](/libs/static_string/): A dynamically + resizable string of characters with compile-time fixed capacity and contiguous + embedded storage, from Vinnie Falco and Krystian Stasiowski + +### Updated Libraries + + +* [Align](/libs/align/): + + + Update `aligned\_alloc` + to support older mingw32. +* [Any](/libs/any/): + + + Speedup compilation by not including ``. + + Maintenance work, including CI hardening. +* [Asio](/libs/asio/): + + + Fixed compatibility with C++20 concept syntax. + + Marked the POSIX descriptor classes' move constructors as `noexcept`. + + Added the `ssl::host\_name\_verification` class, which + is a drop-in replacement for `ssl::rfc2818\_verification`. + The `ssl::rfc2818\_verification` class has + been marked as deprecated. As a consequence of this change, SSL support + now depends on functions that were introduced in OpenSSL 1.0.2. + + Added an `ssl::context` constructor to take ownership + of a native handle. + + Changed C++ language version detection with gcc + to use `\_\_cplusplus` + macro. + + Fixed a work counting issue in the asynchronous resolve operation + for endpoints. + + Fixed the `strand<>` converting constructors and + assignment operators. + + Ensured that resolvers are restarted correctly after a fork. + + Fixed compatibility with the current NetBSD release. + + Removed spurious handler requirement checks in some `async\_read` overloads. + + Changed the `ssl::context` class to propagate non-EOF + errors from the `add\_certificate\_authority` + function. + + Fixed a Windows-specific `thread\_pool` + destructor hang that occurred when the pool had an associated I/O + object. + + Changed the select reactor to recreate the "self + pipe trick" sockets on error. This addresses an issue on some + versions of Windows, where these sockets are discconected after a + system sleep. + + Fixed a compile error in the buffered streams due to the lack of + reference collapsing in C++98. + + Changed the `priority\_scheduler` + example to demonstrate calls to `shutdown()` and `destroy()`. + + Removed some unnecessary null pointer checks. + + Changed Windows platform detection to recognise TV titles as Windows + apps. + + Added some emscripten compatibility patches. + + Fixed a compile error in the `use\_awaitable\_t::as\_default\_on` + function. + + Changed all uses of the boost.bind placeholders to use the `boost::placeholders` namespace. + + Fixed a potential compile error in the `async\_compose` + implementation due to incorrect overload selection. + + Suppressed some non-virtual destructor warnings. + + Various documentation fixes and improvements. +* [Assert](/libs/assert/): + + + Added `source\_location`. +* [Atomic](/libs/atomic/): + + + Implemented C++20 `atomic\_ref`. + See [docs](/doc/html/atomic/interface.html#atomic.interface.interface_atomic_ref) + and especially the [caveats](/doc/html/atomic/interface.html#atomic.interface.interface_atomic_ref.caveats) + section. + + Implemented `atomic\_flag::test` + operation, which was introduced in C++20. + + `atomic` + should now take into account alignment requirements of `T`, which makes a difference if + those requirements are higher than that of the internal storage of + `atomic`. + + Added static asserts enforcing the requirements on the value type + `T` used with `atomic` and `atomic\_ref`. + This should prohibit invalid types from being used as atomics. + + Improved internal lock pool implementation. The pool is larger, and + lock selection accounts for atomic object alignment, which should + reduce the potential of thread contention. + + Fixed incorrect x86 code generated for `bit\_test\_and\_\*` operations on 8 and 16-bit arguments. + Other architectures are not affected. + + Fixed a possible unaligned memory access in `compare\_exchange\_\*` operations, if alignment requirements + of `value\_type` are + less than that of the internal storage of `atomic`. + + `boost/atomic/atomic.hpp` no longer includes `boost/atomic/atomic\_flag.hpp` and `boost/atomic/fences.hpp` + and only defines the `boost::atomic` + class template and related typedefs. Include the other headers explicitly + or use `boost/atomic.hpp` to include all parts of Boost.Atomic. + + The `atomic::storage()` + accessor and associated `atomic::storage\_type` + type are deprecated. Instead, users are advised to use `atomic::value()` + and `atomic::value\_type`, respectively. Users + can define `BOOST\_ATOMIC\_SILENCE\_STORAGE\_DEPRECATION` + to disable deprecation warnings for the time of transition. The deprecated + pieces will be removed in a future release. + + Removed support for `BOOST\_ATOMIC\_DETAIL\_HIGHLIGHT\_OP\_AND\_TEST`. + This macro was used as a helper for transition to the updated returned + values of `\*\_and\_test` + operations in Boost.Atomic 1.67, which was released 2 years before + 1.73. +* [Beast](/libs/beast/): + + + This is a maintenance update. + + Nested `mutable\_data\_type` + in Beast dynamic buffers is deprecated. + + We'd love to know how you or your company use Beast, consider adding + an entry to the [Companies + and Individuals Using Beast](https://github.com/boostorg/beast/wiki/Companies-and-Individuals-Using-Beast) list. + + See the full [Release + Notes](/libs/beast/doc/html/beast/release_notes.html) for a complete list of changes. +* [Context](/libs/context/): + + + [#133](https://github.com/boostorg/context/issues/133): IBM Z: Fix fcontext routines + + [#132](https://github.com/boostorg/context/issues/132): mips64/n64: .align 3 + + [#131](https://github.com/boostorg/context/issues/131): Use OSPLAT MIPS32/MIPS64 to set different ABI + + [#129](https://github.com/boostorg/context/issues/129): Fix non-PIC in RISC-V assembly +* [Conversion](/libs/conversion/): + + + Added `boost::polymorphic\_downcast` for references + (thanks to Julien Delacroix for the patch). + + Significant docs update. +* [date\_time](/libs/date_time/): + + + [#123](https://github.com/boostorg/date_time/issues/123): Support constexpr in c++14 and above + + [#134](https://github.com/boostorg/date_time/issues/134): Make date\_time all inline. Users no longer need + to link the library for any functions. Library remains for build + compatibility. + + [#132](https://github.com/boostorg/date_time/issues/132): Deprecate support for legacy io and `USE\_DATE\_TIME\_PRE\_1\_33\_FACET\_IO` + macro + + Misc documentation updates and bugfixes. +* [DLL](/libs/dll/): + + + Fixes and tests for demangling in `boost::dll::smart\_library` + (thanks to Ramil Gauss for [#35](https://github.com/boostorg/dll/issues/35)). + + Make UB sanitizers happy with `boost::dll::load\_mode::type` + [#30](https://github.com/boostorg/dll/issues/30). + + Ceased dependence on MPL improving compile times (thanks to Nikita + Kniazev for [#34](https://github.com/boostorg/dll/issues/34)). + + Clang and ICC on Windows fixes and CI support for those platforms + (thanks to Nikita Kniazev [#33](https://github.com/boostorg/dll/issues/33)). + + Maintenance work, including CI hardening and tests improving. +* [Dynamic Bitset](/libs/dynamic_bitset/): + + + Fixed a portability issue in the definition of the maximum block + limit. +* [Flyweight](/libs/flyweight/index.html): + + + Maintenance work. +* [Geometry](/libs/geometry/): + + + Improvements + + - [PR#650](https://github.com/boostorg/geometry/pull/650) Missing input combinations in `intersection()` + and introduction of tupled-output. + - [PR#671](https://github.com/boostorg/geometry/pull/671) Added `d3::point\_xyz` + geometry model (thanks to Digvijay Janartha). + + Solved issues + + - [#657](https://github.com/boostorg/geometry/issues/657) Incorrect definition of `EPSG:3785`. + + Bugfixes + + - [PR#639](https://github.com/boostorg/geometry/pull/639) R-tree exception-safety improvement. + - [PR#668](https://github.com/boostorg/geometry/pull/668) Andoyer inverse formula fixed for close points. + - [PR#687](https://github.com/boostorg/geometry/pull/687) Fixed dangling reference in distance algorithm. + + Deprecation + + - [#590](https://github.com/boostorg/geometry/issues/590) Support for C++03 has been deprecated and Geometry + will require C++14 from Boost 1.75 onwards. +* [GIL](/libs/gil/): + + + Added + + - Added move constructor and move assignment operator to `image` class ([PR#457](https://github.com/boostorg/gil/pull/457)). + - New member function `size()` in `any\_image\_view` + class ([PR#456](https://github.com/boostorg/gil/pull/456)). + + Changed + + - Replace Boost.Test with Boost.LightweightTest as the only test + framework used in GIL ([PR#459](https://github.com/boostorg/gil/pull/459)) and ([PR#464](https://github.com/boostorg/gil/pull/464)). This + also restructured the `test/extension/io/` sub-tree and targets in related + `Jamfile`-s. + - Removed remaining uses of Boost.MPL ([PR#459](https://github.com/boostorg/gil/pull/459)). + - Renamed all macros using `BOOST\_GIL\_` + prefix ([PR#411](https://github.com/boostorg/gil/pull/411)). + - Renamed all CMake configuration options using `BOOST\_GIL\_` prefix ([PR#419](https://github.com/boostorg/gil/pull/419)). + + Changed + + - Removed `extension/dynamic\_image/reduce.hpp` + as unused and possibly unfinished ([PR#466](https://github.com/boostorg/gil/pull/466)). An implementation + attempt of techniques described in the paper [Efficient + Run-Time Dispatching in Generic Programming with Minimal Code + Bloat](http://lubomir.org/academic/MinimizingCodeBloat.pdf) by Lubomir Bourdev, Jaakko Jarvi. + - Removed direct dependency on Boost.MPL, Boost.System and Boost.Test. + - Started removing public macros for compile-time configuration + of I/O extension tests, i.e. `BOOST\_GIL\_IO\_TEST\_ALLOW\_READING\_IMAGES` + and `BOOST\_GIL\_IO\_TEST\_ALLOW\_WRITING\_IMAGES`. + Instead, if a test target is built, it builds all its test + cases unconditionally. + + Fixed + + - Avoid `longjmp` + interaction during destruction of I/O extension objects ([PR#433](https://github.com/boostorg/gil/pull/433)). + - Fixed missing alignment default value in constructor of `image` class ([PR#429](https://github.com/boostorg/gil/pull/429)). + - Fixed segmentation fault when reading corrupted PNG file ([PR#414](https://github.com/boostorg/gil/pull/414)). + - Fixed illegal initialization of return values in the old IOv1 + interface of I/O extension ([PR#409](https://github.com/boostorg/gil/pull/409)). + + Acknowledgements + + - Samuel Debionne, Thiago Henrique Hüpner, Pranam Lashkari, + Mateusz Loskot, Debabrata Mandal, Olzhas Zhumabek +* [Histogram](/libs/histogram/): + + + New features + + - Added `crop` + command to `reduce` + algorithm + - `slice` command + in `reduce` now + works on `category` + axis + - Added `count` + accumulator, can be used to add arbitrary metadata to each + cell + - `sum` algorithm + gained a new argument to optionally sum only over inner bins + + Several fixes for bugs in corner cases + + Enhanced documentation + + - How to use Boost.Histogram as a backend in an external API + - More on how to use Boost.Histogram with custom accumulators + and Boost.Accumulators + - More on how to use `reduce` + - Updated benchmarks + + See the [full + changelog here](/libs/histogram/doc/html/histogram/history.html) +* [icl](/libs/icl/): + + + [PR#23](https://github.com/boostorg/icl/pull/23): Remove references to date\_time compiled library. + + [PR#17](https://github.com/boostorg/icl/pull/17): Fix forward decl lower and upper less equal. + + Misc bugfixes. +* [IO](/libs/io/): + + + Made all the IOS state saver classes non-copyable. (Glen Fernandes) + + Correctly handle error upon first read from the input stream when + reading a quoted string. (Glen Fernandes) + + Implemented `ostream\_joiner` + for delimiter based joining. (Glen Fernandes) + + Relocated `ostream\_string` + from the Utility library to the IO library as `ostream\_put`. + + Correctly handle stream width and fill in quoted output. (Glen Fernandes) + + Optimize quoted output to write directly to the stream buffer. (Glen + Fernandes) + + Glen Fernandes became the maintainer of the IO library. +* [LexicalCast](/libs/lexical_cast/): + + + Maintenance work, including CI hardening and better workarounds for + broken standard libraries (thanks to Nikita Kniazev [#31](https://github.com/boostorg/lexical_cast/issues/31), + [#32](https://github.com/boostorg/lexical_cast/issues/32)). +* [Log](/libs/log/): + + + New Features: + + - Default sink used in trivial logging, when no sinks are registered + in the logging core, now automatically flushes output after + each log record. ([#103](https://github.com/boostorg/log/issues/103)) + - `core::flush` now performs a flush + on the default sink used for trivial logging, when no sinks + are registered. + + Bug fixes: + + - Added a workaround for some syslog API implementations (e.g. + glibc), which do not save the application identification string + in `openlog` + call. Such implementations could access already freed memory + on each `syslog` + call, resulting in undefined behavior. ([#97](https://github.com/boostorg/log/issues/97)) + - Fixed that log file rotation on a specific day of month (e.g. + `rotation\_at\_time\_point(boost::gregorian::greg\_day(1))`) could be silently ignored + and not happen. ([#98](https://github.com/boostorg/log/issues/98)) + - Fixed that `text\_file\_backend::rotate\_file` + could throw if there were no log records written yet and target + file name pattern was set. + - Ported various components of the library to `std::allocator\_traits` + to improve compatibility with C++20 allocators. + - Fixed compilation errors when building in MSYS2 Cygwin environment. + ([#102](https://github.com/boostorg/log/issues/102)) + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Math](/libs/math/): + + + IMPORTANT: C++03 support is now deprecated and will be removed from + March 2021. + + Added Cubic Hermite Interpolation. + + Added Modified Akima Interpolation. + + Added PCHIP Interpolation. + + Added Quintic Hermite Interpolation. + + Added entropy to numerous distributions. + + Allow trivial quadrature case where the two end points are equal, + and in addition allow bounds to be interchanged. + + Fix exp\_sinh quadrature to work with complex types over a non-native + range. + + Fix miscellaneous compiler warnings in factorial.hpp. + + Use std::chrono rather than boost::chrono in timed pFq calculations. + + Remove much of the old boost::mpl dependencies to improve constexpr + support. +* [Mp11](/libs/mp11/): + + + Added `mp\_unique\_if` + (contributed by Kris Jusiak) + + Added `mp\_flatten` + + Added `mp\_rotate\_left`, + `mp\_rotate\_right` (contributed + by Duncan Barber) + + Added `mp\_compose` + + Added `mp\_power\_set` + + Added `mp\_partial\_sum` + + Added `mp\_iterate` +* [Multi-index Containers](/libs/multi_index/): + + + `multi\_index\_container` + is now [`AllocatorAware`](https://en.cppreference.com/w/cpp/named_req/AllocatorAwareContainer). + + Swapping of internal `KeyFromValue`, + `Compare`, `Hash` and `Pred` + objects now selects the appropriate `swap` + function between `std::swap` + and ADL candidates, in accordance with standard specifications in + **[swappable.requirements]** (issue + [#29](https://github.com/boostorg/multi_index/issues/29)). + + Provided some internal copy constructors and assignment operators + whose default implicit definition is deprecated in C++11 onwards + (**[depr.impldec]**), which was warned + about on some compilers. + + Maintenance work. +* [Multiprecision](/libs/multiprecision/): + + + IMPORTANT: Mark C++03 support as deprecated and due for removal in + 2021. + + Big update to cpp\_int adds faster Karatsuba and Coomba multiplication + routines. + + Fix conversion of gmp\_rational to `long + double` and `\_\_float128`, + fixes #178. + + Fix up libtommath support to function with the latest libtom releases. + + Fix up some incompatibilities with the latest Intel C++ compiler. + + Fix up `constexpr` arithmetic + support for latest MSVC release. +* [Outcome](/libs/outcome/): + + + Enhancements: + + - Performance of Outcome-based code compiled by clang has been + greatly improved. The previous implementation of Outcome's + status bitfield confused clang's optimiser, which caused low + quality codegen. Unlike most codegen issues, this was noticeably + in empirical benchmarks of real world code, as was shown by + [P1886 **Error + speed benchmarking**](https://wg21.link/P1886). + - The safe part of the [`better\_optimisation`](https://github.com/ned14/outcome/tree/better_optimisation) + Outcome v2.2.0 future branch was merged to Outcome v2.1.3 which + includes a new status bitfield implementation. This appears + to not confuse clang's optimiser, and clang 9 produces code + which routinely beats GCC 9's code for various canned use cases. + - Installability is now CI tested per commit. Due to installability + of standalone Outcome (e.g. `make + install`) breaking + itself rather more frequently than is ideal, installability + is now tested on CI per commit. + + Bug fixes: + + - [#214](https://github.com/ned14/outcome/issues/214) + Newer Concepts implementing compilers were unhappy with the + early check for destructibility of `T` + and `E`, so removed + template constraints, falling back to static assert which runs + later in the type instantiation sequence. + - [#220](https://github.com/ned14/outcome/issues/220) + A false positive undefined behaviour sanitiser failure in some + use cases of Experimental Outcome was worked around to avoid + the failure message. +* [PolyCollection](/libs/poly_collection/): + + + Suppressed a potential redundant move warning in `boost::poly\_collection::for\_each`. + + Fixed a bug by which elements were copied rather than moved in allocator-extended + move construction and move assigment between collections with non-propagating, + unequal allocators. + + Allocator-extended move construction no longer decays to allocator-extended + copy construction for the legacy version of libstdc++-v3 shipped + with GCC 4.8 (which can also be used by Clang). +* [Stacktrace](/libs/stacktrace/): + + + Added documentation on distribution of PDBs [#55](https://github.com/boostorg/stacktrace/issues/55), [#47](https://github.com/boostorg/stacktrace/issues/47) (thanks + to emptyVoid and Roger Orr for information and to zlojvavan for testing). + + Fixed msvc-9 build + + Maintenance work, including test fixes [#86](https://github.com/boostorg/stacktrace/issues/86), fixing typos + [#84](https://github.com/boostorg/stacktrace/issues/84), CI improvements and hardening, inspect tool fixes. +* [Test](/libs/test/): + + + Boost.test v3.13 see the [Changes + log](/libs/test/doc/html/boost_test/change_log.html) for more details. + + New feature: It is now possible to combine tolerance indication, + user message and collection comparison modifier in a single `BOOST\_TEST` expression. See change + logs for more details. + + Bug fixes and pull requests: + + - GitHub Issues: [#173](https://github.com/boostorg/test/issues/173), [#179](https://github.com/boostorg/test/issues/179), [#220](https://github.com/boostorg/test/issues/220), [#221](https://github.com/boostorg/test/issues/221), + [#235](https://github.com/boostorg/test/issues/235) + [#237](https://github.com/boostorg/test/issues/237), [#241](https://github.com/boostorg/test/issues/241), [#245](https://github.com/boostorg/test/issues/245), [#246](https://github.com/boostorg/test/issues/246), + [#251](https://github.com/boostorg/test/issues/251), [#253](https://github.com/boostorg/test/issues/253) + [#254](https://github.com/boostorg/test/issues/254), [#263](https://github.com/boostorg/test/issues/263) + - Trac tickets: [#11107](https://svn.boost.org/trac/boost/ticket/11107) + - GitHub Pull Requests: [PR#41](https://github.com/boostorg/test/pull/41), [PR#114](https://github.com/boostorg/test/pull/114), [PR#187](https://github.com/boostorg/test/pull/187), + [PR#239](https://github.com/boostorg/test/pull/239), [PR#247](https://github.com/boostorg/test/pull/247) + [PR#252](https://github.com/boostorg/test/pull/252), [PR#259](https://github.com/boostorg/test/pull/259), [PR#265](https://github.com/boostorg/test/pull/265) +* [ThrowException](/libs/throw_exception/): + + + Added an overload of `throw\_exception` + that takes a `boost::source\_location` + object. + + NOTE: Projects using `BOOST\_THROW\_EXCEPTION` + with exceptions disabled will need to add a definition of this new + overload. +* [TTI](/libs/tti/): + + + Added introspection of function templates for more recent C++ compilers + versions from gcc and vc++. as well as all versions of clang. Older + versions of vc++ before 14.0 and gcc prior to 4.8 may fail. + + Added specific introspection for elements of struct/class, enum, + and union types, which can be used for more fine-grained introspection + than the general 'type' introspection. +* [TypeIndex](/libs/type_index/): + + + Maintenance work, including CI integration with inspect tool. +* [Utility](/libs/utility/): + + + The `ostream\_string` + facility has moved from the Utility library to the IO library as + `ostream\_put`. +* [Variant](/libs/variant/): + + + Removed unused includes (thanks to Nikita Kniazev [#74](https://github.com/boostorg/variant/issues/74)). + + Fixed zero-as-null-pointer-constat warnings (thanks to Bart Siwek + [#77](https://github.com/boostorg/variant/issues/77)). + + Maintenance work, including typo fixes. +* [Variant2](/libs/variant2/): + + + Added support for `std::hash`, + `boost::hash`. + + `variant` + is now trivial when all types in `T...` are trivial. This improves performance + by enabling it to be passed to, and returned from, functions in registers. +* [WinAPI](/libs/winapi/): + + + Headers in `boost/detail/winapi` + are deprecated and will be removed in a future release. + + Boost.WinAPI headers no longer include `winerror.h`. + Include `boost/winapi/error\_codes.hpp` to get Windows error codes. + ([#81](https://github.com/boostorg/winapi/issues/81)) + +### Updated Tools + + +* [Build](/tools/build/): + + + Includes release [4.2.0](https://github.com/boostorg/build/releases/tag/4.2.0) + of B2. + + WARNING: Since version 4.0.0 B2 requires a capable C++11 compiler + to bootstrap. This is only needed to build B2 itself not to build + Boost for your use. + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 4.0.1, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1, 7.0.0, 8.0.0 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1, 7.0.0, 8.0.0 + + Clang, C++17: 5.0.2, 6.0.1, 7.0.0, 8.0.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 5.4.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++11: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++14: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++17: 9.1.0, 10.0.0 + + Apple Clang, C++1z: 9.0.0 + + Apple Clang, C++2a: 10.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.8.1, 3.9.1, 4.0.1, 5.0.2, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1, 7.0.0, 8.0.0 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1, 7.0.0, 8.0.0 + + Clang, C++17: 5.0.2, 6.0.1, 7.0.0, 8.0.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.9.4, 5.4.0, 5.5.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.3.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1, 8.1.0 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++11: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++14: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++17: 9.1.0, 10.0.0 + + Apple Clang, C++1z: 9.0.0 + + Apple Clang, C++2a: 10.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + +### Acknowledgements + Marshall Clow, Michael Caisse and Glen Fernandes managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_74_0.html b/users/history/version_1_74_0.html new file mode 100644 index 0000000..15793c8 --- /dev/null +++ b/users/history/version_1_74_0.html @@ -0,0 +1,709 @@ +--- +title: Version 1.74.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.74.0 + +/\*\*/ + + + + + + + +Version 1.74.0 +============== + +Version 1.74.0 +-------------- + + +August 14th, 2020 05:02 GMT + + +[Documentation](/doc/libs/1_74_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_74\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.74.0/source/boost_1_74_0.tar.bz2) | 83bfc1507731a0906e387fc28b7ef5417d591429e51e788417fe9ff025e116b1 | +| [boost\_1\_74\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.74.0/source/boost_1_74_0.tar.gz) | afff36d392885120bcac079148c177d1f6f7730ec3d47233aa51b0afa4db94a5 | +| windows | [boost\_1\_74\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.74.0/source/boost_1_74_0.7z) | 903fd40074de8dc733d2f0b6b0642e43b714653eaeb79289b12161b9567fae97 | +| [boost\_1\_74\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.74.0/source/boost_1_74_0.zip) | a0e7ce67c52d816708fdeccdd8c9725626ba61254c13c18770498cacd514710a | + + +### New Libraries + + +* [STLInterfaces](/libs/stl_interfaces/): A library + of CRTP bases to ease the writing of STL views, iterators, and sequence + containers, from Zach Laine. + +### Updated Libraries + + +* [Asio](/libs/asio/): + + + Added an implementation of the proposed standard executors ([P0443r13](http://wg21.link/P0443r13), [P1348r0](http://wg21.link/P1348r0), + and [P1393r0](http://wg21.link/P1393r0)). + + Added support for the proposed standard executors to Asio's I/O facilities. + + - The supplied executors now meet the requirements for the proposed + standard executors. These classes also continue to meet the + existing requirements for the Networking TS model of executors. + - All I/O objects, asynchronous operations, and utilities will + interoperate with both new proposed standard executors, and + with existing Networking TS executors. + - The `any\_io\_executor` + type alias has been introduced as the default runtime-polymorphic + executor for all I/O objects. This defaults to the `execution::any\_executor<>` + template. If required for backward compatibility, `BOOST\_ASIO\_USE\_TS\_EXECUTOR\_AS\_DEFAULT` + can be defined to use the old `asio::executor` + polymorphic wrapper instead. + - Support for the existing Networking TS model of executors can + be disabled by defining `BOOST\_ASIO\_NO\_TS\_EXECUTORS`. + + Added converting move construction and assignment to `basic\_waitable\_timer`. + + Enabled C++20 coroutine support when using gcc + 10. + + Added overloads of `co\_spawn` + that launch an awaitable. + + Added a new constructor overload to `use\_awaitable\_t`'s + default executor adapter, to enable conversion between executor types. + + Added support for using `detached\_t` + as a default completion token, by adding members `as\_default\_on()` and `as\_default\_on\_t<>`. + + Added a move constructor to `ssl::stream<>`. + + Changed `ssl::stream<>` + write operations to linearise gather-write buffer sequences. + + Added compile-time detection of the deprecated `asio\_handler\_invoke`, + `asio\_handler\_allocate`, + and `asio\_handler\_deallocate` + hooks, when `BOOST\_ASIO\_NO\_DEPRECATED` + is defined. + + Implemented a number of performance optimisations. + + Added source location support to handler tracking. + + Implemented various improvements to the handlerviz.pl + tool. + + Added the handlerlive.pl tool, which processes + handler tracking output to produce a list of "live" handlers. + + Added the handlertree.pl tool, which filters handler + tracking output to include only those events in the tree that produced + the nominated handlers. + + Added changes for clang-based Embarcadero C++ compilers. + + Fixed a deadlock that can occur when multiple threads concurrently + initialise the Windows I/O completion port backend. + + Fixed `async\_compose` + to work with copyable handlers when passed by lvalue. + + Fixed completion signature deduction in `co\_spawn`. + + Removed a spurious `Executor` + base class from the `executor\_binder` + implementation. + + Various fixes and improvements in the documentation and examples. + + Consult the [Revision + History](/doc/libs/1_74_0/doc/html/boost_asio/history.html) for further details. +* [Atomic](/libs/atomic/): + + + Added missing `const` + qualifiers to some operations in `atomic\_ref`. + + Added support for `yield` + instruction on ARMv8-A. The instruction is used internally in spin + loops to reduce CPU power consumption. + + Added support for C++20 [waiting + and notifying operations](/doc/html/atomic/interface.html#atomic.interface.interface_wait_notify_ops). The implementation includes generic + backend that involves the internal lock pool, as well as specialized + backends for Windows, Linux, FreeBSD, DragonFly BSD and NetBSD. Atomic + types provide a new method `has\_native\_wait\_notify`, + a static boolean constant `always\_has\_native\_wait\_notify` + and a set of capability macros that allow to detect if the implementation + supports native waiting and notifying operations for a given type. + + Changed internal representation of `atomic\_flag` + to use 32-bit storage. This allows for more efficient waiting and + notifying operations on `atomic\_flag` + on some platforms. + + Added support for build-time configuration of the internal lock pool + size. The user can define the `BOOST\_ATOMIC\_LOCK\_POOL\_SIZE\_LOG2` + macro to specify binary logarithm of the size of the lock pool. The + default value is 8, meaning that the size of the lock pool is 256, + up from 64 used in the previous release. + + Added support for a new set of atomic types dedicated for [inter-process + communication](/doc/html/atomic/interface.html#atomic.interface.interface_ipc): `ipc\_atomic\_flag`, + `ipc\_atomic` and `ipc\_atomic\_ref`. Users are recommended + to port their code using non-IPC types for inter-process communication + to the new types. The new types provide the same set of operations + as their non-IPC counterparts, with the following differences: + + - Most operations have an added precondition that `is\_lock\_free` returns `true` for the given atomic object. + The library will issue a compile time error if this precondition + is known to be not satisfied at compile time. + - All provided operations are address-free, meaning that the + atomic object (in case of `ipc\_atomic\_ref` + - the referenced object) may be located in process-shared memory + or mapped into the same process at multiple different addresses. + - The new `has\_native\_wait\_notify` + operation and `always\_has\_native\_wait\_notify` + constant indicate support for native inter-process waiting + and notifying operations. When that support is not present, + the operations are implemented with a busy loop, which is less + efficient, but still is address-free. A separate set of capability + macros is also provided to indicate this support. + + Added new `atomic\_unsigned\_lock\_free` + and `atomic\_signed\_lock\_free` + types introduced in C++20. The types indicate the atomic object type + for an unsigned or signed integer, respectively, that is lock-free + and preferably has native support for waiting and notifying operations. + + Added new gcc assembler backends for ARMv8-A (for both AArch32 and + AArch64). The new backends are used to implement operations not supported + by compiler intrinsics (including 128-bit operations on AArch64) + and can also be used when compiler intrinsics are not available. + Both little and big endian targets are supported. AArch64 backend + supports extensions defined in ARMv8.1 and ARMv8.3. + + Added support for big endian targets in the legacy ARM backend based + on gcc assembler blocks (this backend is used on ARMv7 and older + targets). Previously, the backend assumed little endian memory layout, + which is significant for 64-bit operations. + + Improved performance of seq\_cst stores and thread fences on x86 by + using `lock`-prefixed + instructions instead of `mfence`. + This means that the operations no longer affect non-temporal stores, + which was also not guaranteed before. Use specialized instructions + and intrinsics to order non-temporal memory accesses. + + Fixed capability macros for 80-bit `long + double` on x86 targets not + indicating lock-free operations even if 128-bit atomic operations + were available. + + Fixed compilation of gcc asm blocks on Alpha targets. + + In the gcc `\_\_sync\*` intrinsics backend, fixed that store + and load operations of large objects (larger than a pointer size) + could be non-atomic. The implementation currently assumes that small + objects can be stored with a single instruction atomically on all + modern architectures. +* [Beast](/libs/beast/): + + + This update brings bug fixes and support for the following changes + changes in Boost.Asio: + + Beast supports `BOOST\_ASIO\_NO\_DEPRECATED`. + Define this to help identify areas of your Beast and Asio code which + use deprecated Asio interfaces. + + Beast also supports `BOOST\_ASIO\_NO\_TS\_EXECUTORS`. + Define this to identify uses of executors from the now potentially + outdated [Networking + TS](https://cplusplus.github.io/networking-ts/draft.pdf) + + Asio will use the [Standard + Executors](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0443r11.html) model by default. You can prevent this behaviour + by defining `BOOST\_ASIO\_USE\_TS\_EXECUTOR\_AS\_DEFAULT` + in which the Networking TS model will be used by default. Setting + this flag does not prevent a program from using executors from the + Standard Executors model explicitly. + + We'd love to know how you or your company use Beast, consider adding + an entry to the [Companies + and Individuals Using Beast](https://github.com/boostorg/beast/wiki/Companies-and-Individuals-Using-Beast) list. + + See the full [Release + Notes](/libs/beast/doc/html/beast/release_notes.html) for a complete list of changes. +* [Bimap](/libs/bimap/): + + + Correct allocator usage (fixes C++20 compilation). (Glen Fernandes) +* [Config](/libs/config/): + + + Implement `BOOST\_NO\_CXX11\_OVERRIDE` + and `BOOST\_OVERRIDE`. + (Glen Fernandes) +* [Core](/libs/core/): + + + Implemented the allocator access utilities which provide a replacement + for `allocator\_traits` + with individual traits and functions for each facility. They support + the C++11 allocator model when possible and provide a fallback for + C++98 compatibility. These are now used in Circular\_Buffer, Wave, + Lockfree, Heap, Smart\_Ptr, Dynamic\_Bitset, Format, Bimap and more. + (Glen Fernandes) +* [DLL](/libs/dll/): + + + Multiple fixes for the `library\_info` + work on empty shared objects. + + Compilation fixes for C++98 and C++11 modes ([#28](https://github.com/boostorg/dll/issues/28)). + + Fixes for `smart\_library` + manglings (thanks to XiaLiChao82 [#37](https://github.com/boostorg/dll/issues/37)). +* [Endian](/libs/endian/): + + + Enabled scoped enumeration types in `endian\_reverse`. + + Enabled `bool`, `enum`, `float`, + `double` in `endian\_reverse\_inplace`. + + Added an overload of `endian\_reverse\_inplace` + for arrays. +* [Filesystem](/libs/filesystem/): + + + Removed compile-time checks for support for symlinks and hardlink + on Windows. Instead, a runtime check is used. ([PR#142](https://github.com/boostorg/filesystem/pull/142)) + + Fixed handling of reparse points in `canonical` + and `read\_symlink` + on Windows. This also affects other algorithms that involve `canonical` and `read\_symlink` + in their implementation. ([PR#100](https://github.com/boostorg/filesystem/pull/100), [#85](https://github.com/boostorg/filesystem/issues/85), [#99](https://github.com/boostorg/filesystem/issues/99), + [#123](https://github.com/boostorg/filesystem/issues/123), [#125](https://github.com/boostorg/filesystem/issues/125)) + + Fixed that `read\_symlink` + on Windows could potentially fail or cause failures elsewhere with + a sharing violation error, if the same symlink was opened concurrently. + ([#138](https://github.com/boostorg/filesystem/issues/138)) + + Fixed that `is\_symlink(directory\_entry)` would always return `false`, even if the directory entry + actually referred to a symlink. ([PR#148](https://github.com/boostorg/filesystem/pull/148)) + + Added missing status inspection operation overloads for `directory\_entry` and `error\_code` (e.g. `is\_directory(directory\_entry, + error\_code&)`). + Removed incorrect `noexcept` + specifications for the overloads not taking the `error\_code` + arguments. + + `copy\_file` implementation + has been updated to perform checks on the source and target files, + as required by C++20 ([fs.op.copy.file]/4.1). In particular, the + operation will fail if the source or target file is not a regular + file or the source and target paths identify the same file. + + `copy\_file` on POSIX + systems will now also copy the source file permissions to the target + file, if the target file is overwritten. + + **New:** Added `copy\_file` + implementations based on `sendfile` + and `copy\_file\_range` + system calls on Linux, which may improve file copying performance, + especially on network filesystems. + + **Deprecated:** The `copy\_option` + enumeration that is used with the `copy\_file` + operation is deprecated. As a replacement, the new enum `copy\_options` (note the trailing + 's') has been added. The new enum contains values similar to the + `copy\_options` enum + from C++20. The old enum values are mapped onto the new enum. The + old enum will be removed in a future release. + + **New:** Added `copy\_options::skip\_existing` + option, which allows `copy\_file` + operation to succeed without overwriting the target file, if it exists. + + **New:** Added `copy\_options::update\_existing` + option, which allows `copy\_file` + operation to conditionally overwrite the target file, if it exists, + if its last write time is older than that of the replacement file. + + **New:** `copy\_file` + now returns `bool`, which + indicates whether the file was copied. + + **New, breaking change:** `copy` operation has been extended + and reworked to implement behavior specified in C++20 [fs.op.copy]. + This includes support for `copy\_options::recursive`, + `copy\_options::copy\_symlinks`, `copy\_options::skip\_symlinks`, + `copy\_options::directories\_only`, `copy\_options::create\_symlinks` and `copy\_options::create\_hard\_links` options. The + operation performs additional checks based on the specified options. + Applying `copy` to + a directory with default `copy\_options` + will now also copy files residing in that directory (but not nested + directories or files in those directories). + + **New:** Added `create\_directory` + overload taking two paths. The second path is a path to an existing + directory, which is used as a source of permission attributes to + use in the directory to create. + + **Deprecated:** `copy\_directory` + operation has been deprecated in favor of the new `create\_directory` + overload. Note that the two operations have reversed order of the + path arguments. + + `equivalent` on POSIX + systems now returns the actual error code from the OS if one of the + paths does not resolve to a file. Previously the function would return + an error code of 1. ([#141](https://github.com/boostorg/filesystem/issues/141)) + + `equivalent` no longer + considers file size and last modification time in order to test whether + the two paths refer to the same file. These checks could result in + a false negative if the file was modified during the `equivalent` call. + + **New:** Added `absolute` + overloads taking `error\_code` + argument. + + Operations that have `current\_path()` as the default value of their arguments + and also have an `error\_code` + argument will use the `current\_path(error\_code& ec)` overload to obtain the current path, + so that its failure is reported via the `error\_code` + argument instead of an exception. + + `space` now initializes + the `space\_info` structure + members to -1 values on error, as required by C++20 ([fs.op.space]/1). + + `space` on Windows + now accepts paths referring to arbitrary files, not only directories. + This is similar to POSIX systems and corresponds to the operation + description in C++20. ([#73](https://github.com/boostorg/filesystem/issues/73)) + + **New:** Added implementation of `temp\_directory\_path` for Windows + CE. ([PR#25](https://github.com/boostorg/filesystem/pull/25)) + + **New:** Improved compatibility with + [WASI](https://wasi.dev/) platform. ([PR#144](https://github.com/boostorg/filesystem/pull/144)) + + **New:** Improved support for Embarcadero + compilers. ([PR#130](https://github.com/boostorg/filesystem/pull/130)) + + **New:** Added implementations of `unique\_path` operation based on + `getrandom` (Linux), + `arc4random\_buf` (OpenBSD/FreeBSD/CloudABI) + and BCrypt (Windows) system APIs. + + **Deprecated:** Auto-linking against + system libraries on Windows with MSVC-compatible compilers is deprecated + and will be removed in a future release. This affects users linking + against static library of Boost.Filesystem. Users are advised to + update their project build systems to either use a shared library + of Boost.Filesystem, or explicitly specify the dependencies of Boost.Filesystem + in the linker command line. Users of shared library of Boost.Filesystem + are not affected. +* [Flyweight](/libs/flyweight/index.html): + + + Maintenance work. +* [Format](/libs/format/): + + + Correct allocator usage (fixes C++20 compilation). (Glen Fernandes) +* [Geometry](/libs/geometry/): + + + Improvements + + - [PR#720](https://github.com/boostorg/geometry/pull/720) Additional R-tree constructors (thanks to + Caian Benedicto). + - Various improvements in buffer, set and relational operations. + + Solved issues + + - [#709](https://github.com/boostorg/geometry/issues/709) memcpy called for object with no trivial copy-assignment. + - [#721](https://github.com/boostorg/geometry/issues/721) Compilation error in bgi::detail::rtree::visitors::insert. + - [#727](https://github.com/boostorg/geometry/issues/727) MSVC warning: conditional expression is constant. + + Bugfixes + + - [PR#700](https://github.com/boostorg/geometry/pull/700) Missing cases for default strategies in distance + algorithm. + - [PR#738](https://github.com/boostorg/geometry/pull/738) Longitudes out of range in direct geodesic + formulas. +* [GIL](/libs/gil/): + + + Added + + - Added new constructor initializing `any\_image` + from r-value reference to any image ([PR#486](https://github.com/boostorg/gil/pull/486)). + - Implemented mechanism to reverse `kernel\_2d` + ([PR#489](https://github.com/boostorg/gil/pull/489)). + + Changed + + - BREAKING: Replace Boost.Variant with Boost.Variant2 ([PR#474](https://github.com/boostorg/gil/pull/474)) + which completes removal on uses of Boost.MPL (missing from + Boost 1.72.0 change added [PR#274](https://github.com/boostorg/gil/pull/274)). + - Use perfect forwarding from apply\_operation to visit ([PR#491](https://github.com/boostorg/gil/pull/491)). + + Removed + + - BREAKING: Removed dependency on Boost.Variant + + Fixed + + - Fixed invalid conversion from RGB8 to CMYK32 due to overflow + ([PR#470](https://github.com/boostorg/gil/pull/470)). + - Fixed `image` + constructor from other image ([PR#477](https://github.com/boostorg/gil/pull/477)). + - Fixed error `plane\_view\_t` + is not a class or namespace name ([PR#481](https://github.com/boostorg/gil/pull/481)). + - Fixed `interleaved\_view` + factory using `point` for dimension ([PR#487](https://github.com/boostorg/gil/pull/487)). + - Fixed documentation replacing uses MPL with MP11 in tutorial + ([PR#494](https://github.com/boostorg/gil/pull/494)). + - Fixed missing header in `numeric/kernel.hpp` + to make it self-contained ([PR#502](https://github.com/boostorg/gil/pull/502)). + + Acknowledgements + + - Samuel Debionne, Pranam Lashkari, Mateusz Loskot, Debabrata + Mandal +* [Heap](/libs/heap/): + + + Correct destruction of top node in `skew\_heap`. + (Glen Fernandes) + + Correct and simplify allocator use. (Glen Fernandes) +* [Integer](/libs/integer/): + + + Fixed compilation of `gcd` + in C++20 mode with clang 10. + + Improved support for Embarcadero compilers. ([PR#21](https://github.com/boostorg/integer/pull/21)) +* [Iterator](/libs/iterator/): + + + `boost/function\_output\_iterator.hpp` header is now deprecated. Users + should replace its inclusion with `boost/iterator/function\_output\_iterator.hpp`. + ([PR#51](https://github.com/boostorg/iterator/pull/51)) + + Improved support for Embarcadero compilers. ([PR#55](https://github.com/boostorg/iterator/pull/55)) +* [LexicalCast](/libs/lexical_cast/): + + + Fixed warnings on missing `override` + (thanks to EugeneZelenko [#35](https://github.com/boostorg/lexical_cast/issues/35), [#34](https://github.com/boostorg/lexical_cast/issues/34)). + + Fixes for the the Embarcadero compilers (thanks to Edward Diener). +* [Log](/libs/log/): + + + Bug fixes: + + - The syslog sink backend now verifies the IP version of the + local and target addresses set by user. The addresses must + have the same IP version as was specified in the `ip\_version` named parameter + on the sink backend construction (by default, IPv4 is assumed). + When an address is obtained as a result of host name resolution, + only addresses with matching IP version are considered. ([#119](https://github.com/boostorg/log/issues/119)) + + New Features: + + - Move constructors and assignment operators of various components + were marked `noexcept`. + - Added a new `range\_manip` + stream manipulator that can be used for outputting elements + of a range, optionally separated by a delimiter. + - Added a new `tuple\_manip` + stream manipulator that can be used for outputting elements + of a tuple or any other heterogeneous sequence, optionally + separated by a delimiter. + - Added a new `optional\_manip` + stream manipulator that can be used for outputting optionally + present values. + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Mp11](/libs/mp11/): + + + Improved compilation performance of `mp\_with\_index` for large `N`. + + Added `tuple\_transform` + (contributed by Hans Dembinski.) +* [Multi-index Containers](/libs/multi_index/): + + + Added [node + extraction and insertion](/libs/multi_index/doc/tutorial/basics.html#node_handling) following the analogous interface + of associative containers as introduced in C++17. This feature has + also been extended to non key-based indices, in contrast to C++ standard + library sequence containers, which do not provide such functionality. + + Clarified documentation on read/write key extractors (issue [#32](https://github.com/boostorg/multi_index/issues/32)). + + Maintenance work. +* [Nowide](/libs/nowide/): + + + The library now requires a C++11-compliant compiler and stdlib + + LFS: Add support for files > 2 GB where the underlying system + supports it + + Generic UTF conversion functions are now available in the `boost::nowide::utf namespace` + + Add support for `stat` + with UTF-8 paths +* [Outcome](/libs/outcome/): + + + Announcements: + + - The v2.1 branch is expected to be retired end of 2020, with + the v2.2 branch becoming the default. You can use the future + v2.2 branch now using [`better\_optimisation`](https://github.com/ned14/outcome/tree/better_optimisation). + This branch has a number of major breaking changes to Outcome + v2.1, see the front page for details. + + Enhancements: + + - BREAKING CHANGE `void` + results and outcomes no longer default construct types during + explicit construction. Previously if you explicitly constructed + a `result` + from a non-errored `result`, it default constructed + `T`. This was + found to cause unhelpful surprise, so it has been disabled. + - New macro `OUTCOME\_ENABLE\_LEGACY\_SUPPORT\_FOR`. + The macro `OUTCOME\_ENABLE\_LEGACY\_SUPPORT\_FOR` + can be used to enable aliasing of older naming and features + to newer naming and features when using a newer version of + Outcome. + - Concepts now have snake case style naming instead of camel + case style. When Outcome was first implemented, it was thought + that C++ 20 concepts were going to have camel case style. This + was changed before the C++ 20 release, and Outcome's concepts + have been renamed similarly. This won't break any code in Outcome + v2.1, as compatibility aliases are provided. However code compiled + against Outcome v2.2 will need to be upgraded, unless `OUTCOME\_ENABLE\_LEGACY\_SUPPORT\_FOR` + is set to `210` or + lower. + - Concepts now live in `OUTCOME\_V2\_NAMESPACE::concepts` + namespace. Previously concepts lived in the `convert` + namespace, now they live in their own namespace. + - New concepts `basic\_result` and `basic\_outcome` added. End users were finding + an unhelpful gap in between `is\_basic\_result` and `value\_or\_error` where they wanted a concept + that matched types which were `basic\_result`, + but not exactly one of those. Concepts filling that gap were + added. + - Operation `TRY` + works differently from Outcome v2.2 onwards. This is a severely + code breaking change which change the syntax of how one uses + `OUTCOME\_TRY()`. A regular expression suitable + for upgrading code can be found in the list of changes between + Outcome v2.1 and v2.2. + + Bug fixes: + + - [#224](https://github.com/ned14/outcome/issues/224) + The clang Apple ships in Xcode 11.4 (currently the latest) + has not been patched with the fixes to LLVM clang that fix + `noexcept(std::is\_constructible)` + failing to compile which I originally submitted years ago. + So give up waiting on Apple to fix their clang, add a workaround + to Outcome. + - Spare storage could not be used from within no-value policy + classes. Due to an obvious brain fart when writing the code + at the time, the spare storage APIs had the wrong prototype + which prevented them working from within policy classes. Sorry. +* [PolyCollection](/libs/poly_collection/): + + + Fixed internal ambiguity problem between `boost::type\_erasure::any` + and `boost::any` (issue [#17](https://github.com/boostorg/poly_collection/issues/17)). + + Maintenance work. +* [SmartPtr](/libs/smart_ptr/): + + + Added `owner\_equals` + to `shared\_ptr`, `weak\_ptr`, `local\_shared\_ptr`. + + Added `owner\_hash\_value` + to `shared\_ptr`, `weak\_ptr`. + + Added `owner\_equal\_to`, + `owner\_hash`. + + Added `std::hash` specializations for `shared\_ptr`, `local\_shared\_ptr`. + + Added `boost::hash` support to, and `std::hash`, `std::equal\_to` + specializations for, `weak\_ptr`. +* [Stacktrace](/libs/stacktrace/): + + + Fixed a build error when compiled with `-fno-exceptions` (thanks to Jeremiah + Rodriguez [#91](https://github.com/boostorg/stacktrace/issues/91)). +* [System](/libs/system/): + + + `operator bool()` now returns `failed()` instead of `value() != 0`. +* [Type\_Traits](/libs/type_traits/): + + + Implemented `conjunction`, + `disjunction`, `negation`, `is\_trivially\_copyable`, + `is\_scoped\_enum`, and + `is\_unscoped\_enum`. + (Glen Fernandes) +* [Variant](/libs/variant/): + + + Fixed warnings on missing `override` + (thanks to EugeneZelenko [#78](https://github.com/boostorg/variant/issues/78)). + + Fixes for the the Embarcadero compilers (thanks to Edward Diener + [#79](https://github.com/boostorg/variant/issues/79)). + + Updated header locations to avoid warnings about using deprecated + headers (thanks to Andrey Semashev [#80](https://github.com/boostorg/variant/issues/80)) +* [Variant2](/libs/variant2/): + + + Added support for derived types in `visit`. + + Improved compilation performance for many (hundreds of) alternatives. + + Added support for `visit`. +* [Wave](/libs/wave/): + + + Implement C++20 features for variadics, including `\_\_VA\_OPT\_\_` + ([PR#75](https://github.com/boostorg/wave/pull/75)) + + Implement `\_\_has\_include` + ([PR#102](https://github.com/boostorg/wave/pull/102)) + + Introduce new sample: `check\_macro\_naming`, + useful with Boost itself ([PR#97](https://github.com/boostorg/wave/pull/97)) + + Fix compilation issue caused by `std::allocator` + member removal in C++20 ([PR#72](https://github.com/boostorg/wave/pull/72)) + + Repair Xpressive lexer and `token\_statistics` + sample ([PR#79](https://github.com/boostorg/wave/pull/79)) + + Repair lexertl lexer ([PR#78](https://github.com/boostorg/wave/pull/78)) + + Ensure hooks are run on predefined macros as well ([PR#87](https://github.com/boostorg/wave/pull/87)) + + Various minor bug fixes + + C++98/03 support is now deprecated and will be removed in 1.77 +* [YAP](/libs/yap/): + + + Fixed compilation errors for placeholders; they now work in the general + case, and in particular work with yap::print(). + + constexpr all the YAP. + + Fix printing of correct value category in yap::print(). + + Doc clarification. + +### Updated Tools + + +* [Boostbook](/tools/boostbook/): + + + Change encoding of generated documentation from US-ASCII to UTF-8. + (Glen Fernandes) + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 4.0.1, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1, 7.0.0, 8.0.0 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1, 7.0.0, 8.0.0 + + Clang, C++17: 5.0.2, 6.0.1, 7.0.0, 8.0.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 5.4.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++11: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++14: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++17: 9.1.0, 10.0.0 + + Apple Clang, C++1z: 9.0.0 + + Apple Clang, C++2a: 10.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.8.1, 3.9.1, 4.0.1, 5.0.2, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1, 7.0.0, 8.0.0 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1, 7.0.0, 8.0.0 + + Clang, C++17: 5.0.2, 6.0.1, 7.0.0, 8.0.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.9.4, 5.4.0, 5.5.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.3.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1, 8.1.0 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++11: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++14: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++17: 9.1.0, 10.0.0 + + Apple Clang, C++1z: 9.0.0 + + Apple Clang, C++2a: 10.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + +### Acknowledgements + Marshall Clow, Michael Caisse and Glen Fernandes managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_75_0.html b/users/history/version_1_75_0.html new file mode 100644 index 0000000..713fca4 --- /dev/null +++ b/users/history/version_1_75_0.html @@ -0,0 +1,527 @@ +--- +title: Version 1.75.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.75.0 + +/\*\*/ + + + + + + + +Version 1.75.0 +============== + +Version 1.75.0 +-------------- + + +December 11th, 2020 19:50 GMT + + +[Documentation](/doc/libs/1_75_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_75\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.75.0/source/boost_1_75_0.tar.bz2) | 953db31e016db7bb207f11432bef7df100516eeb746843fa0486a222e3fd49cb | +| [boost\_1\_75\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.75.0/source/boost_1_75_0.tar.gz) | aeb26f80e80945e82ee93e5939baebdca47b9dee80a07d3144be1e1a6a66dd6a | +| windows | [boost\_1\_75\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.75.0/source/boost_1_75_0.7z) | 3a8b314871646e7404886736273c053278ba71b11347f72d4751411d65d6d1a5 | +| [boost\_1\_75\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.75.0/source/boost_1_75_0.zip) | caf36d7c13b3d8ce62282a64a695113945a13b0f1796a45160726d04295f95ed | + + +### Known Issues + Boost.Operators is currently **incompatible with C++20** + compilers, which in some cases may manifest as an infinite recursion or infinite + loop in runtime when a comparison operator is called. The problem is caused + by the new operator rewriting behavior introduced in C++20. As a workaround, + users are advised to target C++17 or older C++ standard. More details can be + found in [#65](https://github.com/boostorg/utility/issues/65). + + +### New Libraries + + +* [JSON](/libs/json/): JSON parsing, serialization, + and DOM in C++11, from Vinnie Falco and Krystian Stasiowski. + + + Fast compilation requiring only C++11 + + Easy and safe modern API with allocator support + + Compile without Boost, define `BOOST\_JSON\_STANDALONE` + + Optional header-only, without linking to a library +* [LEAF](/libs/leaf/): A lightweight error-handling + library for C++11, from Emil Dotchevski. + + + Small single-header format, no dependencies. + + Designed for maximum efficiency ("happy" path and "sad" + path). + + No dynamic memory allocations, even with heavy payloads. + + O(1) transport of arbitrary error types (independent of call stack + depth). + + Can be used with or without exception handling. +* [PFR](/libs/pfr/): Basic reflection without macro + or boilerplate code for user defined types, from Antony Polukhin. + +### Updated Libraries + + +* [Asio](/libs/asio/): + + + Enabled support for UNIX domain sockets on Windows. + + Added executor-converting construction and assignment to `ip::basic\_resolver`. + + Added compatibility between polymorphic executors and the (deprecated) + handler invocation hook. + + Added the `experimental::as\_single` + completion token adapter. + + Added support for `MSG\_NOSIGNAL` + on more platforms by using `\_POSIX\_VERSION` + to detect whether it is supported. + + Added the ability to compile using libpthread on Windows. + + Added workarounds for the Intel C++ compiler. + + Added more support for detecting and optimising for handlers that + have no custom executor. + + Reduced lock contention for timer cancellation on Windows. + + Reinstated a previously removed null-pointer check, as it had a measurable + impact on performance. + + Fixed the `executor` + concept to test for a const-qualified `execute()`. + + Fixed `any\_executor` + support for builds without RTTI support. + + Fixed the `thread\_pool` + unit test to work without RTTI support. + + Fixed C++20 coroutines compatibility with clang on Windows. + + Fixed some compatibility issues with Windows Runtime. + + Fixed shadow name warnings caused by addition of `asio::query`. + + Fixed a "logical ‘or’ of equal expressions" warning + on linux. + + Fixed a benign switch fallthrough warning. + + Added missing `push/pop\_options.hpp` + includes. + + Suppressed zero-as-null-pointer-constant warnings. + + Fixed a comma-operator warning. + + Updated the documentation to clarify when the select + reactor is used on Windows. + + Fixed potential ambiguity caused by `any\_executor` + comparisons and conversion. + + Added detection of non-experimental C++20 coroutines on MSVC 19.8. + + Fixed compatibility with uClibc. + + Fixed `strand<>` + adaptation of Networking TS executors when targeting older C++ versions + or less conformant compilers. + + Consult the [Revision + History](/doc/libs/1_75_0/doc/html/boost_asio/history.html) for further details. +* [Atomic](/libs/atomic/): + + + Implemented SSE2 and SSE4.1 versions of address lookup algorithm, + which is used in the internal lock pool implementation. This may + improve performance of waiting and notifying operations in heavily + contended cases. + + Fixed a possible compilation error on AArch64 targets caused by incorrect + instructions generated for bitwise (logical) operations with immediate + constants. ([#41](https://github.com/boostorg/atomic/issues/41)) +* [Beast](/libs/beast/): + + + This update brings bug fixes and support for the `BOOST\_ASIO\_ENBALE\_HANDLER\_TRACKING` + compile flag from Boost.Asio: + + We'd love to know how you or your company use Beast, consider adding + an entry to the [Companies + and Individuals Using Beast](https://github.com/boostorg/beast/wiki/Companies-and-Individuals-Using-Beast) list. + + See the full [Release + Notes](/libs/beast/doc/html/beast/release_notes.html) for a complete list of changes. +* [Container](/libs/container/): + + + New `devector` + container. + + Fixed bugs/issues: + + - [#152](https://github.com/boostorg/container/issues/152) Tree-based containers have troubles with move-only + types. + - [#156](https://github.com/boostorg/container/issues/156) Compile error with vector. + - [PR#157](https://github.com/boostorg/container/pull/157) Add missing include. + - [#159](https://github.com/boostorg/container/issues/159): pmr::monotonic\_buffer\_resource crashes on + large single allocations. + - [#160](https://github.com/boostorg/container/issues/160): Usage of uses\_allocator needs a remove\_cvref\_t. + - [#162](https://github.com/boostorg/container/issues/162): small\_vector on MSVC x86 call-by-value crash. + - [#161](https://github.com/boostorg/container/issues/161): polymorphic\_allocator(memory\_resource\*) non-standard + extension causes headache. + - [PR#163](https://github.com/boostorg/container/pull/163): container\_rebind for small\_vector with + options. + - [#165](https://github.com/boostorg/container/issues/165): Link error with shared library and memory\_resource + inline members. + - [PR#166](https://github.com/boostorg/container/pull/166): Fix encoding error in copyright headers. + - [PR#167](https://github.com/boostorg/container/pull/167): error: the address of 'msg' will always + evaluate as 'true' warning with GCC 4.4. + - [#169](https://github.com/boostorg/container/issues/169): flood of warnings building dlmalloc\_ext\_2\_8\_6.c + on clang11. +* [Endian](/libs/endian/): + + + `endian\_arithmetic` + no longer inherits from `endian\_buffer` + + When `BOOST\_ENDIAN\_NO\_CTORS` + is defined, the unaligned `endian\_buffer` + and `endian\_arithmetic` + are C++03 PODs, to enable use of `\_\_attribute\_\_((packed))` +* [Filesystem](/libs/filesystem/): + + + **New:** Added `creation\_time` + operation, which allows to obtain file creation time. (Inspired by + [PR#134](https://github.com/boostorg/filesystem/pull/134)) + + The returned value of `last\_write\_time(p, ec)` operation in case of failure has + been changed to a minimal value representable by `std::time\_t` + instead of -1. + + The returned value of `hard\_link\_count(p, ec)` operation in case of failure has + been changed to `static\_cast(-1)` instead of 0. + + On POSIX systems, `file\_size` + will now indicate error code `errc::function\_not\_supported` + if the path resolves to a non-regular file. Previously, `errc::operation\_not\_permitted` was reported. + + On Linux, many operations now use `statx` + system call internally, when possible, which allows to reduce the + amount of information queried from the filesystem and potentially + improve performance. The `statx` + system call was introduced in Linux kernel 4.11. + + Removed `const`-qualification + from return types of some `path` + methods. This could prevent move construction and move assignment + at the call site in some cases. ([#160](https://github.com/boostorg/filesystem/issues/160)) + + On OpenBSD 4.4 and newer, use `statvfs` + system call to obtain filesystem space information. (Inspired by + [PR#162](https://github.com/boostorg/filesystem/pull/162)) + + On Windows, `space` + now returns with an error if the provided path does not idendify + an existing file. ([#167](https://github.com/boostorg/filesystem/issues/167)) +* [Geometry](/libs/geometry/): + + + WARNING: Following the deprecation notice of C++03 issued with Boost + 1.73, from now on the Boost.Geometry requires a capable C++14 compiler. + + Improvements + + - [PR#726](https://github.com/boostorg/geometry/pull/726) Umbrella strategies for area, envelope, expand + (undocumented for now). + - [PR#733](https://github.com/boostorg/geometry/pull/733) Added example of adaptation of std::array<> + to Point concept (thanks to Ben FrantzDale). + - [PR#745](https://github.com/boostorg/geometry/pull/745) constexpr added in geometries and arithmetic. + - [PR#747](https://github.com/boostorg/geometry/pull/747) Added optional traits::make (undocumented + for now). + - [PR#748](https://github.com/boostorg/geometry/pull/748) Modernized usage of type traits. + - [PR#759](https://github.com/boostorg/geometry/pull/759) MPL\_ASSERT replaced with standard static\_assert. + - [PR#767](https://github.com/boostorg/geometry/pull/767) Modernized usage of tuple. + + Solved issues + + - [#716](https://github.com/boostorg/geometry/issues/716) Dangling proxy references. + + Bugfixes + + - Various fixes in set operations and buffer. +* [GIL](/libs/gil/): + + + BREAKING: In next release, we are going to drop support for GCC 5. + We may also change the required minimum C++ version from C++11 to + C++14. +* [Histogram](/libs/histogram/): + + + This update brings + + - Bug-fixes for corner-cases + - Small documentation improvements + - Fixes for new warnings from latest compilers and when compiling + against the C++20 standard + + See the full [Release + Notes](/libs/histogram/doc/html/histogram/history.html) for a complete list of changes. +* [Interprocess](/libs/interprocess/): + + + Fixed bugs: + + - [#127](https://github.com/boostorg/interprocess/issues/127): static assertion failure with boost interprocess + 1.74 and basic\_managed\_shared\_memory. +* [Intrusive](/libs/intrusive/): + + + Fixed bugs: + + - [PR#48](https://github.com/boostorg/intrusive/pull/48): MSVC "assignment within conditional" + warning fix. + - [PR#49](https://github.com/boostorg/intrusive/pull/49): Fix empty control statement warnings. + - [#52](https://github.com/boostorg/intrusive/issues/52): Invalid casting in BOOST\_INTRUSIVE\_BSR\_INTRINSIC. +* [Log](/libs/log/): + + + Bug fixes: + + - Corrected the file counter that would be used in `text\_file\_backend` when generating + the target file name (based on the pattern set by `set\_target\_file\_name\_pattern` + method) when the log file is rotated. ([#125](https://github.com/boostorg/log/issues/125)) + - Replaced a volatile version counter in `basic\_sink\_frontend` + with an atomic. ([#128](https://github.com/boostorg/log/issues/128)) + - In the `asynchronous\_sink` + frontend, resolved a possible conflict between `flush` and `run` + methods, if `run` + is called from a user's thread instead of the internal dedicated + thread spawned by the frontend. ([#131](https://github.com/boostorg/log/issues/131)) + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Move](/libs/move/): + + + Fixed bugs: + + - [#30](https://github.com/boostorg/move/issues/30): (void) C-cast is a non-portable way of suppressing + compiler warnings. +* [Mp11](/libs/mp11/): + + + Added `mp\_pairwise\_fold` + (suggested by Barry Revzin) + + Removed `mp\_invoke` + (use `mp\_invoke\_q`) +* [Optional](/libs/optional/): + + + `boost::none` is `constexpr`-declared. + + Fixed [issue + #78](https://github.com/boostorg/optional/issues/78). +* [Outcome](/libs/outcome/): + + + Announcements: + + - After a year and three major Boost releases announcing this + upcoming change, this is the FINAL RELEASE of the v2.1 branch. + From Boost 1.76 onwards, the v2.2 branch becomes the default. + This branch has a number of major breaking changes to Outcome + v2.1, see the documentation for details. + + Enhancements: + + - The ADL discovered event hooks have been replaced with policy-specified + event hooks instead. This is due to brittleness (where hooks + would quietly self-disable if somebody changed something), + compiler bugs (a difference in compiler settings causes the + wrong hooks, or some but not all hooks, to get discovered), + and end user difficulty in using them at all. The policy-specified + event hooks can be told to default to ADL discovered hooks + for backwards compatibility: set `OUTCOME\_ENABLE\_LEGACY\_SUPPORT\_FOR` + to less than `220` + to enable emulation. + - Improve configuring `OUTCOME\_GCC6\_CONCEPT\_BOOL`. + Older GCCs had boolean based concepts syntax, whereas newer + GCCs are standards conforming. However the precise logic of + when to use legacy and conforming syntax was not well understood, + which caused Outcome to fail to compile depending on what options + you pass to GCC. The new logic always uses the legacy syntax + if on GCC 8 or older, otherwise we use conforming syntax if + and only if GCC is in C++ 20 mode or later. This hopefully + will resolve the corner case build failures on GCC. + + Bug fixes: + + - Boost.Outcome should now compile with `BOOST\_NO\_EXCEPTIONS` + defined. Thanks to Emil, maintainer of Boost.Exception, making + a change for me, Boost.Outcome should now compile with C++ + exceptions globally disabled. You won't be able to use `boost::exception\_ptr` as it can't + be included if C++ exceptions are globally disabled. + - [#236](https://github.com/ned14/outcome/issues/236) + In the Coroutine support the `final\_suspend()` was not `noexcept`, + despite being required to be so in the C++ 20 standard. This + has been fixed, but only if your compiler implements `noop\_coroutine`. Additionally, + if `noop\_coroutine` + is available, we use the much more efficient coroutine handle + returning variant of `await\_suspend()` which should significantly + improve codegen and context switching performance. +* [Polygon](/libs/polygon/): + + + C++20 fixes for `event\_comparison\_type`, + `vertex\_equality\_predicate\_type`, + and `voronoi\_predicates`. + (Glen Fernandes) +* [Preprocessor](/libs/preprocessor/): + + + When variadic data is empty in C++20 mode with \_\_VA\_OPT\_\_ support + the variadic size has been corrected to be 0. This also means that + in this C++20 mode it is now valid to convert to and from empty arrays + and lists and variadic data. The end-user can read the "C++20 + Support For Variadic Macros" part of the "variadic macros" + topic for more information about empty variadic data in the library. + + The macro BOOST\_PP\_IS\_STANDARD() has been added for identifying if + the currently used preprocessor is a C++ standard conforming preprocessor. + A number of preprocessors which generally work correctly with the + library but need various internal workarounds, including the currently + default VC++ preprocessor, are not considered C++ standard conforming + preprocessors. However most preprocessors, including among others + gcc, clang, and the new but currently non-default VC++ preprocessor + in VS2019, are C++ standard conforming preprocessors. + + For C++ standard conforming preprocessors a number of the limits + defined in the config/limits.hpp can now be changed to higher amounts + for a TU. The end-user should read the "limitations" topic + to understand how and which limits can be changed. + + For C++ standard conforming preprocessors, in order to allow the + maximum number of FOR and WHILE iterations, the beginning 'r' and + 'd' iteration numbers in the user-defined macros start at 1 and not + 2, as it did in previous releases. This could be a breaking change + if these iteration numbers are used in the user-defined macros ( + they probably would not be ), but the change was necessary to fix + some arcane bugs when dealing with numerical/logical operations with + maximum numbers as well to allow the user-defined macros to be called + the correct possible maximum number of times. For non-C++ conforming + preprocessors, this change was not made because those non-conforming + C++ preprocessors generally have limitations which disallow the maximum + number of looping constructs to be run, and it was felt not to introduce + a possible breaking change to those more fragile preprocessors would + be better. It was also felt that besides fixing some arcane preprocessor + bugs and providing the possible maximum number of user-defined macro + invocations, this change could be made because it has never been + documented what the starting 'r' and 'd' iteration numbers actually + are but only that these numbers are incremented for each iteration. + + The library has been upgraded to assume variadic macro support for + any compiler working with the library. Ostensibly this means that + the library is now a C++11 on up library, yet most of the major compilers, + including gcc, clang, and VC++, also support variadic macros in C++98/C++03 + mode as long as strict compliance to C++98/C++03 is not turned on + when using one of those compilers. +* [Rational](/libs/rational/): + + + Fix Rational operators to not break under new C++20 `operator==` + rewriting rules. (Glen Fernandes) +* [Signals2](/libs/signals2/): + + + Correct C++ allocator model support to fix compilation in C++20 standards + mode. (Glen Fernandes) +* [System](/libs/system/): + + + The platform-specific headers `windows\_error.hpp`, + `linux\_error.hpp`, and `cygwin\_error.hpp` + emit deprecation messages and are slated for removal. + + The old names for `generic\_category()` and `system\_category()` emit deprecation messages and are + slated for removal. + + `error\_condition::failed` is deprecated and is slated + for removal. `operator bool()` + for `error\_condition` + has been reverted to its old meaning of `value() != 0`. This is done for compatibility with + `std::error\_condition` as the next release + is expected to improve interoperability with `` + even further. *Note that this does not + affect* `error\_code::failed`, + which is still alive and well. + + The overload of `error\_condition::message` + that takes a buffer is deprecated and is slated for removal, for + the same reasons. *Note that this does + not affect* `error\_code::message`. +* [uBLAS](/libs/numeric/ublas/): + + + Correct C++ allocator model support to fix compilation in C++20 standards + mode. (Glen Fernandes and Conrad Poelman) +* [VMD](/libs/vmd/): + + + The VMD number parsing has been upgraded to support the ability for + the end-user to change the number limits in the Preprocessor library. + + The macro BOOST\_VMD\_IS\_GENERAL\_IDENTIFIER has been added to support + the parsing of input that represents a preprocessor token which matches + the VMD identifier syntax, without having to register the identifier + as a specific identifier. +* [Wave](/libs/wave/): + + + Added new C++20 tokens, including the spaceship operator <=> + + Fixed bugs: + + - [#94](https://github.com/boostorg/wave/issues/94): fix incorrect behavior of \_\_LINE\_\_ and \_\_FILE\_\_ + under rescanning + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 4.0.1, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1, 7.0.0, 8.0.0, + 9.0.0, 10.0.0, 11.0.0 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1, 7.0.0, 8.0.0, 9.0.0, 10.0.0, 11.0.0 + + Clang, C++17: 5.0.2, 6.0.1, 7.0.0, 8.0.0, 9.0.0, 10.0.0, 11.0.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 5.4.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0, 10.0.0, 11.0.0 + + Apple Clang, C++11: 9.0.0, 9.1.0, 10.0.0, 11.0.0 + + Apple Clang, C++14: 9.0.0, 9.1.0, 10.0.0, 11.0.0 + + Apple Clang, C++17: 9.1.0, 10.0.0, 11.0.0 + + Apple Clang, C++1z: 9.0.0 + + Apple Clang, C++2a: 10.0.0, 11.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.8.1, 3.9.1, 4.0.1, 5.0.2, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1, 7.0.0, 8.0.0 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1, 7.0.0, 8.0.0 + + Clang, C++17: 5.0.2, 6.0.1, 7.0.0, 8.0.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.9.4, 5.4.0, 5.5.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.3.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1, 8.1.0 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++11: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++14: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++17: 9.1.0, 10.0.0 + + Apple Clang, C++1z: 9.0.0 + + Apple Clang, C++2a: 10.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + +### Acknowledgements + Marshall Clow, Michael Caisse and Glen Fernandes managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_76_0.html b/users/history/version_1_76_0.html new file mode 100644 index 0000000..331ca97 --- /dev/null +++ b/users/history/version_1_76_0.html @@ -0,0 +1,539 @@ +--- +title: Version 1.76.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.76.0 + +/\*\*/ + + + + + + + +Version 1.76.0 +============== + +Version 1.76.0 +-------------- + + +April 16th, 2021 21:05 GMT + + +[Documentation](/doc/libs/1_76_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_76\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.76.0/source/boost_1_76_0.tar.bz2) | f0397ba6e982c4450f27bf32a2a83292aba035b827a5623a14636ea583318c41 | +| [boost\_1\_76\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.76.0/source/boost_1_76_0.tar.gz) | 7bd7ddceec1a1dfdcbdb3e609b60d01739c38390a5f956385a12f3122049f0ca | +| windows | [boost\_1\_76\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.76.0/source/boost_1_76_0.7z) | 88782714f8701b6965f3fce087a66a1262601dd5ccd5b2e5305021beb53042a1 | +| [boost\_1\_76\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.76.0/source/boost_1_76_0.zip) | 0fd43bb53580ca54afc7221683dfe8c6e3855b351cd6dce53b1a24a7d7fbeedd | + + +### New Libraries + + +* No new libraries + +### Updated Libraries + + +* [Asio](/libs/asio/): + + + Added `ip::scope\_id\_type` type alias. + + Added `ip::port\_type` type alias. + + Added `std::hash` specialisations for IP addresses. + + Added `std::hash` specialisations for `ip::basic\_endpoint<>`. + + Refactored SFINAE usage to improve compile times. + + Added friendship support to customisation points, and made most customisations + private. + + Changed `any\_io\_executor` + to a "strong typedef"-style class. + + Fixed `experimental::as\_single` + to work with handler hook deprecation. + + Ensured pthread condition variable attributes are cleaned up on all + platforms. + + Clarified thread safety notes on sockets and descriptors. + + Ensured `errno` is + not overwritten if `socket()` fails on macOS/FreeBSD. + + Fixed work tracking for `io\_context` + and `thread\_pool` executors + when move-assigned. + + Ensured internal `call\_stack` + objects are accessed only from implementation files. + + Fixed I/O object move-assignment to ensure the executor is left in + a valid state. + + Fixed detection of compiler support for defaulted template argument + on functions with MSVC. + + Prevented the `blocking.always` + property from being used with `strand<>`, as it did not produce the + correct semantics. + + Removed deprecated file asio/impl/src.cpp. +* [Atomic](/libs/atomic/): + + + Fixed compilation with MSVC for ARM. ([PR#49](https://github.com/boostorg/atomic/pull/49)) +* [Beast](/libs/beast/): + + + This update brings minor bug fixes and revamped CI reporting. + + We'd love to know how you or your company use Beast, consider adding + an entry to the [Companies + and Individuals Using Beast](https://github.com/boostorg/beast/wiki/Companies-and-Individuals-Using-Beast) list. + + See the full [Release + Notes](/libs/beast/doc/html/beast/release_notes.html) for a complete list of changes. +* [Bind](/libs/bind/): + + + Add support for using the standard C++11 placeholders with `boost::bind`. + + Update `boost::apply` to use variadic templates + and perfect forwarding. +* [Container](/libs/continer/): + + + Added [[no-discard]] attribute in all containers to catch bugs related + to unused return values. + + Replaced default standard exception classes with Boost.Container + own classes, reducing considerably the included files overhead. Example: + in MSVC 19 `boost/container/vector.hpp` + preprocessed file size reduces from 1,5MB to 930KB. If you still + want to use standard exception classes, you can define `BOOST\_CONTAINER\_USE\_STD\_EXCEPTIONS` + before using any Boost.Container class. + + Fixed bugs/issues: + + - [GitHub + #102: *"flat\_map::insert ambiguous with initializer + list & pairs that need to convert"*](https://github.com/boostorg/container/issues/102). + - [GitHub + #139: *"flat\_map merge and iterators"*](https://github.com/boostorg/container/issues/139). + - [GitHub + #141: *"small\_vector does not propagate no throw + properties of move operation of contained type"*](https://github.com/boostorg/container/issues/141). + - [GitHub + #164: *"Compile error when using `pmr::map` with a `std::pair`; works when using a + `std::tuple`"*](https://github.com/boostorg/container/issues/164). + - [GitHub + #171: *"deque::clear() uses undefined behaviour"*](https://github.com/boostorg/container/issues/171). +* [Core](/libs/core/): + + + Add implicit conversion between compatible reference wrappers. + + Add `boost/core/cmath.hpp`, a portable implementation + of the floating point classification functions from ``. + + Add `boost/core/bit.hpp`, a portable implementation + of the C++20 standard header ``. + + Fix `BOOST\_TEST\_EQ`, + `BOOST\_TEST\_NE` for + character types under C++20. + + Revise allocator access utilities (now support VS2013, and no workarounds + use `allocator\_traits`.) +* [DLL](/libs/dll/): + + + **BREAKING CHANGE**: `boost::dll::import` + was renamed to `boost::dll::import\_symbol` + to avoid collision with C++20 `import` + keyword. + + Updated docs, including FAQ section. +* [Filesystem](/libs/filesystem/): + + + Updated compatibility with WASI platform. ([PR#169](https://github.com/boostorg/filesystem/pull/169)) + + Fixed an exception being thrown by `path::remove\_filename` + if the path is "////". ([#176](https://github.com/boostorg/filesystem/issues/176)) + + Fixed `create\_directories` + disregarding errors from file status query operations issued internally. + This could result in incorrect error codes returned by `create\_directories`. ([#182](https://github.com/boostorg/filesystem/issues/182)) +* [Geometry](/libs/geometry/): + + + Improvements + + - [PR#670](https://github.com/boostorg/geometry/pull/670) New IOs to\_wkt() and from\_wkt() (thanks to + Baidyanath Kundu). + - [PR#756](https://github.com/boostorg/geometry/pull/756) Non cartesian and robust convex hulls. + - [PR#768](https://github.com/boostorg/geometry/pull/768) Umbrella strategies for relops, setops, index, + buffer and more (undocumented for now). + - [PR#797](https://github.com/boostorg/geometry/pull/797) New azimuth() algorithm. + - [PR#801](https://github.com/boostorg/geometry/pull/801) Improved accuracy in geographic area computations. + - [PR#820](https://github.com/boostorg/geometry/pull/820) Parameter scale added to svg\_mapper. + + Bugfixes + + - [PR#808](https://github.com/boostorg/geometry/pull/808) Fixed compilation error with rtree serialization + enabled (thanks to Tristan Carel). + - [PR#815](https://github.com/boostorg/geometry/pull/815) Fixed issue in buffer(). + - Various fixes in set operations and buffer. + + Breaking changes + + - Removed strategy convex\_hull::graham\_andrew. +* [GIL](/libs/gil/): + + + BREAKING: In next release, we are going to drop support for GCC 5. + We will also change the required minimum C++ version from C++11 to + C++14. +* [Histogram](/libs/histogram/): + + + This release contains critical fixes, please check that your results + are not affected. + + See [Release + Notes](/libs/histogram/doc/html/histogram/history.html) for details. +* [Intrusive](/libs/intrusive/): + + + Reduced compile-time dependencies: + + - `linear\_slist\_algorithms` + use a simple node\_ptr instead of std::pair on return. + - `list`/`slist` use `operator + <`/`operator + ==` instead of `std::equal\_to`/`std::less`. + + Fixed [GitHub + #54: *set.rbegin() looks like O(log(N))*](https://github.com/boostorg/intrusive/issues/54) +* [Interprocess](/libs/interprocess/): + + + Added `wchar\_t` API support + for named resources in operating systems that offer native wide character + API (e.g. Windows). The following classes were updated with `wchar\_t` name support: + + - `file\_mapping` + - `managed\_mapped\_file` + - `managed\_shared\_memory` + - `managed\_windows\_shared\_memory` + - `shared\_memory\_object` + - `windows\_shared\_memory\_object` + - `file\_lock` + - `named\_condition` + - `named\_condition\_any` + - `named\_mutex` + - `named\_recursive\_mutex` + - `named\_semaphore` + - `named\_sharable\_mutex` + - `named\_upgradable\_mutex` + - `message\_queue` + + Added `BOOST\_INTERPROCESS\_FORCE\_NATIVE\_EMULATION` + macro option to disable the use of generic emulation code for process + shared synchronization primitives instead of native POSIX or Winapi + functions. + + Fixed bugs: + + - [GitHub + #76 (*"Cygwin compilation errors"*)](https://github.com/boostorg/interprocess/issues/76). + - [GitHub + #83 (*"Add BOOST\_INTERPROCESS\_FORCE\_NATIVE\_EMULATION + option"*)](https://github.com/boostorg/interprocess/pull/83). + - [GitHub + #92 (*"bufferstream: Correct MSVC compilation + warning"*)](https://github.com/boostorg/interprocess/pull/92). + - [GitHub + #106 (*"Use fallocate on truncate\_file"*)](https://github.com/boostorg/interprocess/pull/106). + - [GitHub + #120 (*"segment\_manager customization"*)](https://github.com/boostorg/interprocess/issues/120). + - [GitHub + #122 (*"Mark constructors/assignment/swap noexcept + where possible"*)](https://github.com/boostorg/interprocess/issues/122). + - [GitHub + #126 (*"\_ReadWriteBarrier is deprecated warning + when compiling with clang-cl.exe"*)](https://github.com/boostorg/interprocess/issues/126). +* [JSON](/libs/json/): + + + [Security + Report](https://cppalliance.org/pdf/C%20Plus%20Plus%20Alliance%20-%20Boost%20JSON%20Security%20Assessment%202020%20-%20Assessment%20Report%20-%2020210317.pdf) from Bishop Fox. + + ([#481](https://github.com/boostorg/json/issues/481)) Refactored `value\_from` + implementation; user customizations are now always preferred over + library-provided overloads. + + ([#484](https://github.com/boostorg/json/issues/484)) Fix imprecise parsing for some floating point numbers. + + ([#485](https://github.com/boostorg/json/issues/485)) Fix link errors in standalone mode, when used alongside + Boost. + + ([#497](https://github.com/boostorg/json/issues/497)) Fix Boost.Build builds on GCC 4.8. +* [LexicalCast](/libs/lexical_cast/): + + + Dropped dependency on Boost.Math (thanks to Peter Dimov [#37](https://github.com/boostorg/lexical_cast/issues/37), + [#39](https://github.com/boostorg/lexical_cast/issues/39)). + + Fixes for the CI and coverage (thanks to Sam Darwin from "The + C++ Alliance" [#38](https://github.com/boostorg/lexical_cast/issues/38), [#42](https://github.com/boostorg/lexical_cast/issues/42)). +* [Log](/libs/log/): + + + Bug fixes: + + - Corrected a formal race condition in the thread-safe log record + queue implementation used in the `unbounded\_fifo\_queue` + policy of the `asynchronous\_sink` + frontend. The race could be detected by TSAN, but it was not + a real problem on most current CPU architectures and compilers. + ([#139](https://github.com/boostorg/log/issues/139)) + - When copying a logger with a channel attribute (e.g. `channel\_logger`), the channel + attribute is now deep-copied from the original logger. This + means that modifying the channel in the new logger will no + longer affect the original logger. + - Replaced the use of `std::allocator` in template parameters + with a new tag type `boost::log::use\_std\_allocator` + to silence libc++ warnings about the former being deprecated + in C++17 and later. The tag indicates that the instantiated + template should be using a specialization of `std::allocator` internally to allocate + dynamic memory, so the change has no functional effect. ([#141](https://github.com/boostorg/log/issues/141)) + - Boost.Log no longer defines `\_\_MSVCRT\_VERSION\_\_` + macro on MinGW and MinGW-w64. Defining this macro caused incompatibility + with UCRT, which is available as an option in recent MinGW-w64. + ([PR#149](https://github.com/boostorg/log/pull/149)) + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Math](/libs/math/): + + + **Breaking Change:** C++03 support is + now removed, a C++11 or later conformant compiler is now required + to use this library. + + Added Z-test. + + Added execution policy support to univariate and bivariate statistics: + enables parallel execution (requires C++17 and ``). + + Big update/improvement on CI testing. + + Bivariate statistics now have integer support. + + T-Test now has integer support. + + Linear regression now has integer support. + + Correct PDF of the beta distribution at the endpoints. + + Correct use of Stirling's approximation in certain multiprecision + cases, fixes [#396](https://github.com/boostorg/math/issues/396). + + Eliminate -Wimplicit-int-float-conversion on clang. + + Fix some constexpr issues in quaternion/octonion. + + Minor performance fix to tanh\_sinh integration. + + Update hypergeometric functions internal scaling to allow for 64-bit + (long long) exponents with multiprecision types. +* [Move](/libs/move/): + + + [Git Issue + #35: *"New nothrow move traits are incomplete"*](https://github.com/boostorg/move/issues/35). +* [Multiprecision](/libs/multiprecision/): + + + **BREAKING CHANGE**: Massive refactoring + and code simplification makes C++11 an absolute requirement. + + Use BOOST\_TRY/CATCH in headers so code can be used in exception-free + environments. + + Correct corner case in pow, fixes [#277](https://github.com/boostorg/multiprecision/issues/277). + + Correct exception type thrown to match docs in lsb/msb: fixes [#257](https://github.com/boostorg/multiprecision/issues/257). + + Allow moves and operators between related but different types (ie + types with the same allocator), fixes [#278](https://github.com/boostorg/multiprecision/issues/278). +* [Nowide](/libs/nowide/): + + + Fix discarding of characters for text file streams when seek or sync + functions are used and newlines were converted (e.g. on Windows) + + Fix potential use-after-free bug when reusing (via `open`) a file stream that has been + closed + + Fix potential invalid memory access when using a file stream that + has been moved or swapped to where the source had a put-back character + or was set to unbuffered mode + + Fix compatibility with ucrt runtime by not defining `\_\_MSVCRT\_VERSION\_\_` + + Known issues: Read performance for text files is degraded. Binary + files and writing is unaffected. +* [Optional](/libs/optional/): + + + Fixed MSVC warning C4702. +* [Outcome](/libs/outcome/): + + + Announcements: + + - BREAKING CHANGE: After a year and three major Boost releases + announcing this upcoming change, this is the FIRST RELEASE + of the v2.2 branch. This branch has a number of major breaking + changes to the Outcome v2.1 which shipped in Boost 1.75 and + earlier, see the documentation for details. + + Enhancements: + + - VS2019.8 changed how to enable Coroutines, which caused Outcome + to not compile on that compiler. + - If on C++ 20, we now use C++ 20 `[[likely]]` + instead of compiler-specific markup to indicate when TRY has + likely success or failure. + - BREAKING CHANGE: Previously the value of `spare\_storage(const + basic\_result|basic\_outcome \*) + noexcept` was not propagated + over `BOOST\_OUTCOME\_TRY`, + which causes things like stack backtraces captured at the point + of construction of an errored result to get dropped at every + `TRY` point. + This has been fixed by adding an optional `spare\_storage` + to `success\_type` and `failure\_type`, as well as to `auto success(T + &&, ...)` + and `auto failure(T + &&, ...)`. + + Bug fixes: + + - Boost.Outcome should now compile with `BOOST\_NO\_EXCEPTIONS` + defined. Thanks to Emil, maintainer of Boost.Exception, making + a change for me, Boost.Outcome should now compile with C++ + exceptions globally disabled. You won't be able to use `boost::exception\_ptr` as it can't + be included if C++ exceptions are globally disabled. + - BREAKING CHANGE [#244](https://github.com/ned14/outcome/issues/244) + It came as a shock to learn that `BOOST\_OUTCOME\_TRY` + had been broken since the inception of this library for certain + corner case code, which required a breaking change in how TRY + works. See [the + changelog in the documentation for more detail](https://boostorg.github.io/outcome/changelog.html). +* [Parameter](/libs/parameter/): + + + Added a workaround for MSVC 2015 code miscompilation when an rvalue + was used as a default value of a named parameter of a function. ([PR#109](https://github.com/boostorg/parameter/pull/109), + [#132](https://github.com/boostorg/log/issues/132)) +* [PFR](/libs/pfr/): + + + Fixed reflection of types with missing `const` + in SFINAE expressions in template constructor. Now reflection of + aggregates with `std::optional>` fields works on any + Standard Library implementation, even if LWG3050 is not fixed. + + Comparison functions are now `constexpr` + [#52](https://github.com/boostorg/pfr/issues/52) + + Fixed numerous typos in docs (thanks to Phil Miller [#63](https://github.com/boostorg/pfr/issues/63)) +* [PolyCollection](/libs/poly_collection/): + + + Worked around [GCC + bug](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=95888) affecting GCC versions 9.3-10.2 (issue [#20](https://github.com/boostorg/poly_collection/issues/20)). +* [Predef](/libs/predef/): + + + Version 1.13 + + Add `ARCH\_PPC\_64` predef. + + Fix `ARCH\_WORD\_BITS\*` redefinition warnings/errors. + + Add `ARCH\_E2K`, Elbrus + 2000, architecture from Konstantin Ivlev. + + Fix not handling recent C++ version that go above 10.x version. + + Version 1.12 + + Switch to using the endian.h header on OpenBSD. (Brad Smith) + + Fix not handling recent versions of stdcxx that go above version + 9. + + Fix including sub-BSD OS headers directly causing redef warnings. + + Add CI testing of direct inclusion of all headers. + + Add CI testing on FreeBSD for clang and gcc. + + Add `WORD\_BITS` set + of predefs to detect the architecture word size. Initial implementation + inspired by submission from Mikhail Komarov. + + Add CI testing for Cygwin 32 and 64. +* [PropertyTree](/libs/property_tree/): + + + Property Tree has a new maintainer. + + Fix usage of deprecated Boost.Bind features. + + Link to Wikipedia fixed. + + Use BOOST\_OVERRIDE to fix GCC warnings. + + Add extensive CI testing. +* [Regex](/libs/regex/): + + + Regex is now header only except in C++03 mode. + + Support for C++03 is now deprecated. + + The library can now be used "standalone" without the rest + of Boost being present. +* [Stacktrace](/libs/stacktrace/): + + + Better support for pre-C++11 builds on clang [#102](https://github.com/boostorg/stacktrace/issues/102). + + Bigger warning for **do not use boost::stacktrace::stacktrace + in signal handlers** [#71](https://github.com/boostorg/stacktrace/issues/71). +* [TypeTraits](/libs/type_traits/): + + + Fix for Visual Studio managed code projects. +* [Variant2](/libs/variant2/): + + + Improved generated code for the double buffered case. + +### Updated Tools + + +* [Build](/tools/build/): + + + Includes release of [B2 + version 4.4.1](/tools/build/doc/html/#_version_4_4_1). + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.0, 4.0.1, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1, 7.0.0, 8.0.0, + 9.0.0, 10.0.0, 11.0.0 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1, 7.0.0, 8.0.0, 9.0.0, 10.0.0, 11.0.0 + + Clang, C++17: 5.0.2, 6.0.1, 7.0.0, 8.0.0, 9.0.0, 10.0.0, 11.0.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 5.4.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0, 10.0.0, 11.0.0 + + Apple Clang, C++11: 9.0.0, 9.1.0, 10.0.0, 11.0.0 + + Apple Clang, C++14: 9.0.0, 9.1.0, 10.0.0, 11.0.0 + + Apple Clang, C++17: 9.1.0, 10.0.0, 11.0.0 + + Apple Clang, C++1z: 9.0.0 + + Apple Clang, C++2a: 10.0.0, 11.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + Boost's additional test compilers include: + + + +* Linux: + + + Clang: 3.0, 3.8.1, 3.9.1, 4.0.1, 5.0.2, 6.0.1 + + Clang, C++0x: 3.0 + + Clang, C++11: 3.0, 3.1, 3.2, 3.3, 3.4, 4.0.1, 6.0.1, 7.0.0, 8.0.0 + + Clang, C++14: 3.5.0, 3.6.0, 3.7.1, 3.8.0, 3.9.1, 4.0.0, 4.0.1, 5.0.2, + 6.0.1, 7.0.0, 8.0.0 + + Clang, C++17: 5.0.2, 6.0.1, 7.0.0, 8.0.0 + + GCC: 4.4.7, 4.5.3, 4.6.3, 4.9.4, 5.4.0, 5.5.0, 8.0.1 + + GCC, C++0x: 4.4.7 + + GCC, C++11: 4.7.3, 4.8.5, 4.9.4, 5.4.0, 6.4.0, 7.1.0, 8.0.1 + + GCC, C++14: 5.4.0, 5.5.0, 6.3.0, 6.4.0, 7.1.0, 7.3.0, 8.0.1, 8.1.0 + + GCC, C++17: 7.3.0, 8.0.1 + + Intel, C++14: 18.0 +* OS X: + + + Apple Clang: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++11: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++14: 9.0.0, 9.1.0, 10.0.0 + + Apple Clang, C++17: 9.1.0, 10.0.0 + + Apple Clang, C++1z: 9.0.0 + + Apple Clang, C++2a: 10.0.0 +* Windows: + + + GCC: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 + + GCC, C++0x: 4.6.4 + + GCC, C++11: 4.7.3, 4.8.1, 4.9.3 + + GCC, C++14: 5.1.0, 5.2.0, 5.3.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0 + + GCC, C++17: 7.1.0, 7.2.0, 7.3.0 + + Visual C++: 7.1, 8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 14.1 +* FreeBSD: + + + Clang: 4.0.0 + + Clang, C++11: 4.0.0 + + Clang, C++14: 4.0.0 + + Clang, C++1z: 4.0.0 + +### Acknowledgements + Marshall Clow, Michael Caisse and Glen Fernandes managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_77_0.html b/users/history/version_1_77_0.html new file mode 100644 index 0000000..6a91a4d --- /dev/null +++ b/users/history/version_1_77_0.html @@ -0,0 +1,487 @@ +--- +title: Version 1.77.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.77.0 + +/\*\*/ + + + + + + + +Version 1.77.0 +============== + +Version 1.77.0 +-------------- + + +August 11th, 2021 14:25 GMT + + +[Documentation](/doc/libs/1_77_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_77\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.77.0/source/boost_1_77_0.tar.bz2) | fc9f85fc030e233142908241af7a846e60630aa7388de9a5fafb1f3a26840854 | +| [boost\_1\_77\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.77.0/source/boost_1_77_0.tar.gz) | 5347464af5b14ac54bb945dc68f1dd7c56f0dad7262816b956138fc53bcc0131 | +| windows | [boost\_1\_77\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.77.0/source/boost_1_77_0.7z) | f2dd9722b21450daf5ce8ef82c2d99c7ec304f913ee6c6b7f047d5639503dda1 | +| [boost\_1\_77\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.77.0/source/boost_1_77_0.zip) | d2886ceff60c35fc6dc9120e8faa960c1e9535f2d7ce447469eae9836110ea77 | + + +### New Libraries + + +* [Describe](/libs/describe/): A C++14 reflection + library, from Peter Dimov. Provides macros for describing enumerators and + struct/class members, and primitives for querying this information. +* [Lambda2](/libs/lambda2/): A C++14, dependency-free, + single header lambda library, from Peter Dimov. Allows simple function + objects to be constructed via expressions such as `\_1 ++ 5`, + `\_1 % +2 == 0`, `\_1 +> \_2`, + or `\_1 == +' ' || \_1 == '\t'`. + +### Updated Libraries + + +* [Any](/libs/any/): + + + Added `boost::anys::basic\_any` - a data type with customizable + Small Object Optimization whose instances can hold instances of any + type that satisfies ValueType requirements (many thanks to Ruslan + Arutyunyan @rarutyun). If you are not sure that you really need it, + then use `boost::any` instead. + + Started using GithubActions CI for additional testing +* [Asio](/libs/asio/): + + + Added support for cancellation of individual asynchronous operations. + + Added the `associator` + trait, used to generically forward associators. + + Changed all asynchronous operations implemented in Asio to invoke + their completion handlers as rvalue references. + + Added support for asynchronous operations with multiple completion + signatures. + + Added `operator&&` + and `operator||` + for `awaitable<>`, + to allow coroutines to be trivially awaited in parallel. + + Added the `experimental::as\_tuple` + completion token adapter. + + Added the `experimental::append` + completion token adapter. + + Added the `experimental::prepend` + completion token adapter. + + Added the `experimental::deferred` + completion token, whicih allows deferred execution of asynchronous + operations. + + Added the `experimental::parallel\_group` + class and `experimental::make\_parallel\_group` + function. + + Added `experimental::promise`, + which allows eager execution and synchronisation of asynchronous + operations. + + Added the `experimental::coro` + class template, a C++20 coroutine primitive with the ability to combine + both asynchronous waiting (`co\_await`) + and yielding (`co\_yield`). + + Added move assignment to `ssl::stream<>`. + + Changed `co\_spawn` + to `dispatch` the coroutine's + initial step to the executor. + + Enabled additional optimisations for `any\_executor` + and `any\_io\_executor` + when used with asynchronous operations. + + Added the `nodiscard` + attribute to `awaitable<>`. + + Increased the number of cached slots in the default recycling allocator. + + Changed the default allocator behaviour to respect alignment requirements, + to support over-aligned types. + + Ensured the result strings are always initialised in reverse name + resolution. + + Fixed recursive template instantiation issues in `use\_awaitable\_t::executor\_with\_default`. + + Fixed the `any\_io\_executor` + equality operators to correctly return a result based on the target + executor. + + Fixed `strand<>` + to avoid using a potentially moved-from executor. + + Ensured gcc tests are not used for clang + when detecting compiler features. + + Disabled coroutines support for the clang shipped + with MSVC. + + Fixed compatibility with recent LibreSSL when `OPENSSL\_NO\_SSL\_INTERN` + is defined. + + Fixed `posix::basic\_stream\_descriptor` move operations + to work with non-defaulted executors. + + Consult the [Revision + History](/doc/libs/1_77_0/doc/html/boost_asio/history.html) for further details. +* [Atomic](/libs/atomic/): + + + Added `make\_atomic\_ref` + and `make\_ipc\_atomic\_ref` + factory functions for constructing atomic reference objects. + + Added C++17 template argument deduction guides for `atomic\_ref` and `ipc\_atomic\_ref` + to allow omitting template arguments when they can be deduced from + constructor arguments. +* [Beast](/libs/beast/): + + + This maintenance update brings minor bug fixes and updated CI reporting. + + We'd love to know how you or your company use Beast, consider adding + an entry to the [Companies + and Individuals Using Beast](https://github.com/boostorg/beast/wiki/Companies-and-Individuals-Using-Beast) list. + + See the full [Release + Notes](/libs/beast/doc/html/beast/release_notes.html) for a complete list of changes. +* [Conversion](/libs/conversion/): + + + `boost::implicit\_cast` is now `constexpr` ([#25](https://github.com/boostorg/conversion/issues/25)). + + Fixed broken links ([PR#23](https://github.com/boostorg/conversion/pull/23)). + + Started using GithubActions CI for additional testing +* [Core](/libs/core/): + + + `boost/core/uncaught\_exceptions.hpp` has been modified for compatibility + with Mac OS 10.4 and older. ([PR#92](https://github.com/boostorg/core/pull/92)) +* [DLL](/libs/dll/): + + + More runtime checks for malformed ELFs in `boost::dll::library\_info` + + In `boost::dll::library\_info` use info from `.dynsym` + ELF section if `.symtab` + is empty or missing + + List protected ELF symbols in `boost::dll::library\_info` + as they are available for import ([#50](https://github.com/boostorg/dll/issues/50)) + + Remove unneeded convert from `wchar\_t` + to char on POSIX environment, thanks to Vladislav Shchapov ([PR#49](https://github.com/boostorg/dll/pull/49)) + + Started using GithubAction CI for additional testing +* [Filesystem](/libs/filesystem/): + + + **Introducing Boost.Filesystem v4.** + This new version of the library removes all deprecated features of + v3 and also makes a number of breaking API changes intended to make + Boost.Filesystem more compatible with std::filesystem introduced + in C++17. The differences are described in the release notes and + documentation using **v3** and **v4** tags and are also summarised in a separate + section. Users can select Boost.Filesystem version by defining `BOOST\_FILESYSTEM\_VERSION` macro + to either 3 or 4 when compiling their code. There is no need to separately + compile Boost.Filesystem for each library version - a single binary + supports both v3 and v4. Users should avoid using both v3 and v4 + in the same application as this can lead to subtle bugs. Currently, + v3 is the default. In a future release v4 will become the default, + and eventually v3 will be removed. v4 is functional, but it is still + a work in progress and there may be breaking API changes in the future. + + **v4:** `path::filename`, + `path::stem` and `path::extension` + no longer consider root name or root directory of the path as a filename + if the path only consists of those components. For example, on Windows + `path("C:").filename()` + used to return "C:" and `path("C:\\").filename()` used to return "\" and + both will return an empty path now. ([#88](https://github.com/boostorg/filesystem/issues/88), [#194](https://github.com/boostorg/filesystem/issues/194)) + + **v4:** `path::stem` + and `path::extension` no longer treat a filename + that starts with a dot and has no other dots as an extension. Filenames + starting with a dot are commonly treated as filenames with an empty + extension. The leading dot is used to indicate a hidden file on most + UNIX-like systems. ([#88](https://github.com/boostorg/filesystem/issues/88)) + + **New:** Improved support for various + path prefixes on Windows. Added support for local device prefix ("\\.\") + and experimental support for NT path prefix ("\??\"). The + prefixes will be included in the root name of a path. Note that using + the prefixes with Boost.Filesystem v3 can lead to surprising results + (e.g. `path("\\\\.\\").stem() + == "\\\\"`). + It is recommended to use the prefixes only with Boost.Filesystem + v4. + + Reworked `path::lexically\_normal` implementation + to eliminate some cases of duplicate dot (".") elements + in the normalized paths. + + **New:** Added runtime detection of + the `statx` and `getrandom` system calls on Linux. + This can be useful if the syscall is present at compile time but + fails with `ENOSYS` + at run time (for example, in Docker containers that restrict the + syscall, even if available on the host). ([#172](https://github.com/boostorg/filesystem/issues/172)) + + **New:** Added support for disabling + usage of various system APIs at library build time. This can be useful + when a certain API is detected as present by the library configuration + scripts but must not be used for some reason (for example, when runtime + detection does not work on the target system). See the description + of configuration macros in the library documentationfor for more + details. + + **New:** Added `copy\_options::synchronize\_data` + and `copy\_options::synchronize` + options for the `copy\_file` + operation. These options allow to synchronize the written data and + attributes with the permanent storage. These options are expensive + in terms of performance, but allow to ensure reliability of the copied + data. Note that `copy\_file` + performed implicit data synchronization on POSIX systems since Boost.Filesystem + 1.74.0. This release adds support for more platforms and disables + data synchronization by default while allowing the caller to explicitly + request it. ([#186](https://github.com/boostorg/filesystem/issues/186)) + + Added handling of `EINTR` + error code on POSIX systems for some system calls issued internally. + In particular, `EINTR` + could have been ignored on `close`, + which on HP-UX would result in a leaked file descriptor. + + In the `copy\_file` + implementations based on Linux `sendfile` + and `copy\_file\_range` + system calls, added handling of error codes indicating that a particular + filesystem does not support the system call and fall back to the + generic `read`/`write` loop. This should fix `copy\_file` failing on [eCryptFS](https://www.ecryptfs.org/) + and possibly other filesystems. ([#184](https://github.com/boostorg/filesystem/issues/184)) + + The `copy\_file\_range` + system call is now used since Linux kernel 4.5, whereas previously + it was only enabled since 5.3. The `copy\_file` + implementation will fall back to `sendfile` + or `read`/`write` loop if `copy\_file\_range` + fails to copy a given file across filesystems. + + The `copy\_file` implementations + based on Linux `sendfile` + and `copy\_file\_range` + system calls will not be used on filesystems that are known to contain + files with generated content. These system calls are incompatible + with such files, and copying them would result in zero-sized files. + The generic `read`/`write` loop will be used instead. + Currently, the blacklisted filesystems are: procfs, sysfs, tracefs + and debugfs. + + In the `copy\_file` + implementation based on `read`/`write` loop, increased the maximum + size of the buffer used for temporary storage and take into account + the target filesystem block size for more optimal performance. + + On Windows CE, calling `current\_path` + to obtain the current path for a process will now fail with an error + instead of returning successfully with a root path. This platform + does not support current directory. Changing the current path was + already failing similarly in previous releases of Boost.Filesystem. + + In `canonical`, fixed + the check for a symlink referencing a directory above root, if an + earlier symlink was resolved to an absolute path with a different + root from the original path. + + In `canonical`, added + a limit for the maximum number of symlinks that can be resolved during + the call. The limit is currently at least 40 symlinks. + + On Windows, `canonical` + and `weakly\_canonical` + will now use `path::preferred\_separator` + for the root directory separator in the resulting paths. This fixes + "file not found" errors caused by Windows API not handling + generic separators in UNC paths and paths that start with the Win32 + filesystem prefix ("\\?\"). ([#87](https://github.com/boostorg/filesystem/issues/87), [#187](https://github.com/boostorg/filesystem/issues/187)) + + **New:** Added `weakly\_canonical` + overloads taking `base` + path as an argument. + + On Windows, `weakly\_canonical` + no longer fails with an error if the input path contains elements + that do not exist in the filesystem but are cancelled by a subsequent + dot-dot ("..") element. For example, `weakly\_canonical("C:\\a\\..")` would previously fail if "C:\a" + directory did not exist. ([#201](https://github.com/boostorg/filesystem/issues/201)) + + In `read\_symlink` on + Windows, corrected reparse point handling. The operation would return + an empty path for some mount points (for example, created by [Box](https://www.box.com/) cloud storage driver) and + directory junction points that had empty print names. The new implementation + now parses substitute name of the reparse point and attempts to reconstruct + a Win32 path from it. ([#187](https://github.com/boostorg/filesystem/issues/187)) + + On Windows, file streams provided in `boost/filesystem/fstream.hpp` + will use wide character paths on libc++ versions 7.0 and higher, + when the standard library supports opening files with wide character + paths. ([#181](https://github.com/boostorg/filesystem/issues/181)) + + On Windows, creating symlinks should no longer require elevated privileges, + if Windows is configured in [Developer + mode](https://docs.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development). + + With some compilers, global objects used internally in Boost.Filesystem + are now destroyed after user's global destructors are called. This + allows to call Boost.Filesystem methods during the program termination + stage. In particular, this concerns the path locale that is used + for character code conversion and can be installed by calling `path::imbue`. The supported compilers + include MSVC, GCC and Clang, as well as other compilers that support + customizing program initialization order through `#pragma + section` (for MSVC-compatible + compilers) or `\_\_attribute\_\_ + ((init\_priority))` (for GCC-compatible compilers). +* [Geometry](/libs/geometry/): + + + Improvements + + - [PR#812](https://github.com/boostorg/geometry/pull/812) Umbrella strategies for distance and comparable\_distance + (undocumented for now). + - [PR#840](https://github.com/boostorg/geometry/pull/840) Umbrella strategies for various algorithms + (undocumented for now). + - [PR#850](https://github.com/boostorg/geometry/pull/850) Introduced DynamicGeometry and GeometryCollection + concepts and support in some algorithms (undocumented for now). + - [PR#855](https://github.com/boostorg/geometry/pull/855) Various improvements related to strategies. + Default strategies are now included with algorithms. + + Solved issues + + - [#865](https://github.com/boostorg/geometry/issues/865) Exception thrown in rtree serialization. + - [#439](https://github.com/boostorg/geometry/issues/439) Invalid box spherical area computation. + - [#838](https://github.com/boostorg/geometry/issues/838) Invalid result of union\_(). + - [#851](https://github.com/boostorg/geometry/issues/851) Invalid geographic disjoint segment/box result. + - [#861](https://github.com/boostorg/geometry/issues/861) Invalid result of intersection(). + + Bugfixes + + - [PR#832](https://github.com/boostorg/geometry/pull/832) Fixed box spherical and geographic area computation. + - [PR#853](https://github.com/boostorg/geometry/pull/853) Fixed geographic disjoint segment/box. + - [PR#866](https://github.com/boostorg/geometry/pull/866) Fixed serialization of rtree containing lesser + number of elements in root node than minimum. + - [PR#886](https://github.com/boostorg/geometry/pull/886) Fixed knn rtree query bug causing it to be + slow for big k. + - Various fixes in set operations and buffer. +* [JSON](/libs/json/): + + + `value\_to` supports + `TupleLike` types. + + `value\_to` and `value\_from` support `std::array` and similar types. + + Implicit conversion operator from `string` + to `std::string\_view`. + + `std::hash` specializations for json types. + + Fixed allocation errors in `object` + and `key\_value\_pair`. + + Fixed crash when constructing `array` + from a pair of iterators that form an empty range. +* [LexicalCast](/libs/lexical_cast/): + + + Fixed assignment to an int of a floating point value that is out + of representable range for int. + + Started using GithubActions CI for additional testing +* [Log](/libs/log/): + + + Fixed compilation for riscv32 target. ([PR#150](https://github.com/boostorg/log/pull/150)) +* [Mp11](/libs/mp11/): + + + Added `mp\_intersperse`, + `mp\_split`, `mp\_join` +* [Multi-index Containers](/libs/multi_index/): + + + Maintenance work. +* [Nowide](/libs/nowide/): + + + Allow for usage of `iostream` + classes before `main` + (best effort, works for most environments) + + Fix initialization of `rdbuf` + in `cin/cout/cerr` for redirected input/output + + Fix corner case in `cin::unget()` after using `putback()` + + Fix possibly delayed `close` + of `filebuf` after + move assignment + + Improve performance of `utf8\_codecvt` +* [PFR](/libs/pfr/): + + + A MurMur Hash based implementation of hash\_combine() is now used + to reduce collisions count and improve quality of `boost::pfr::hash\_value()` + + Visual Studio 2017 now supported in C++14 mode (thanks to Denis Mikhailov + aka @denzor200) + + Issues found by inspect tool were fixed + + Fixed some warnings, including removal of extra semicolons in include/boost/pfr/detail/fields\_count.hpp + ([#72](https://github.com/boostorg/pfr/issues/72)) + + Added a compile time assert for inherited types (thanks to Denis + Mikhailov aka @denzor200) + + Reflection of aggregates with non movable fields is now possible + if guaranteed copy elision is on + + Fixed spelling issues + + Started using GithubActions CI for additional testing +* [PropertyTree](/libs/property_tree/): + + + This is a maintenance release. + + Extend compiler coverage in CI. + + Fix Boost compatibility for CMakeLists.txt. +* [System](/libs/system/): + + + The conversion operator from `error\_category` + to `std::error\_category` has been improved + and no longer requires `` + or ``. + + The comparison operators of `error\_category` + are now inline friends instead of member functions (a side effect + of the previous change.) + + `error\_condition` now + defers calling `generic\_category()` to avoid instantiating the object + until it's actually needed. + + `error\_condition::failed` and `error\_condition::message` + have been undeprecated, and `operator + bool()` + now once again returns `failed()`. + + The system category now doesn't call `generic\_category()`, to avoid instantiating the object. + + The return value of `default\_error\_condition` + changes in some cases into an `error\_condition` + from the generic category, instead of from the system category. This + happens on POSIX when the input `error\_code` + is from the system category and does not correspond to any `errc\_t` value. + + The interoperability of `error\_code` + and `std::error\_code` has been improved substantially. + It is now possible to construct `boost::system::error\_code` + from `std::error\_code`, and it's possible to + pass `boost::system::error\_code` to functions taking + `std::error\_code&`. + + A stream insertion operator for `error\_condition` + has been added. +* [Uuid](/libs/uuid/): + + + Added `to\_chars` for + writing uuid strings without allocating ([PR#116](https://github.com/boostorg/uuid/pull/116)) + +### Updated Tools + + +* [Build](/tools/build/): + + + Includes release of [B2 + version 4.6.1](/tools/build/doc/html/#_version_4_6_1). + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 12.0.0 + + Clang, C++11: 3.4, 11.0.0 + + Clang, C++14: 3.5, 3.6, 3.7, 3.8, 3.9, 4.0, 5.0, 12.0.0 + + Clang, C++17: 6.0.1, 7.0.0, 8.0.0, 9.0.0, 10.0.0, 11.0.0, 12.0.0 + + Clang, C++20: 11.0.0, 12.0.0, 13.0.0 + + GCC: 4.6.3, 11 + + GCC, C++11: 4.7.3, 4.8.5, 11 + + GCC, C++14: 5.4.0, 6.4.0, 7.3.0, 8.0.1, 9.1.0, 11 + + GCC, C++17: 7.3.0, 8.0.1, 9.1.0, 11 + + GCC, C++20: 8.0.1, 9.1.0, 10, 11 +* OS X: + + + Apple Clang: 11.0.3 + + Apple Clang, C++11: 11.0.3 + + Apple Clang, C++14: 11.0.3 + + Apple Clang, C++17: 11.0.3 + + Apple Clang, C++20: 11.0.3 +* Windows: + + + Visual C++: 10.0, 11.0, 12.0, 14.0, 14.1, 14.2 + +### Acknowledgements + Marshall Clow, Michael Caisse and Glen Fernandes managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_78_0.html b/users/history/version_1_78_0.html new file mode 100644 index 0000000..75f228a --- /dev/null +++ b/users/history/version_1_78_0.html @@ -0,0 +1,507 @@ +--- +title: Version 1.78.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.78.0 + +/\*\*/ + + + + + + + +Version 1.78.0 +============== + +Version 1.78.0 +-------------- + + +December 8th, 2021 03:45 GMT + + +[Documentation](/doc/libs/1_78_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_78\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.78.0/source/boost_1_78_0.tar.bz2) | 8681f175d4bdb26c52222665793eef08490d7758529330f98d3b29dd0735bccc | +| [boost\_1\_78\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.78.0/source/boost_1_78_0.tar.gz) | 94ced8b72956591c4775ae2207a9763d3600b30d9d7446562c552f0a14a63be7 | +| windows | [boost\_1\_78\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.78.0/source/boost_1_78_0.7z) | 090cefea470bca990fa3f3ed793d865389426915b37a2a3258524a7258f0790c | +| [boost\_1\_78\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.78.0/source/boost_1_78_0.zip) | f22143b5528e081123c3c5ed437e92f648fe69748e95fa6e2bd41484e2986cc3 | + + +### Known Issues + These are patches from library authors which were found too late to be fixed + in the release. + + + +* Boost.Build silently skips installation of library headers and binaries + in some cases, see [#104](https://github.com/bfgroup/b2/issues/104). + + + Fixed in [PR#113](https://github.com/bfgroup/b2/pull/113), + [patch](/patches/1_78_0/0001-b2-fix-install.patch). +* Boost.Atomic fails to build when targeting UWP, see [#54](https://github.com/boostorg/atomic/issues/54). [Patch](/patches/1_78_0/0002-atomic-fix-uwp-build.patch). + +### New Libraries + + +* No new libraries. + +### Updated Libraries + + +* [Asio](/libs/asio/): + + + Added an io\_uring backend that may optionally be used for all I/O + objects, including sockets, timers, and posix descriptors. + + Added support for files, with new new classes for stream-oriented + and random-access files. This feature currently supports I/O completion + ports on Windows, and io\_uring on Linux. + + Added support for portable pipes on POSIX and Windows (when I/O completion + ports are available). + + Added support for registered buffers, which are optimised when using + the io\_uring backend. + + Added experimental support for channels, that may be used to send + and queue completions as messages. + + Implemented improvements to `experimental::coro`. + + Disabled `aligned\_alloc` + on clang when using an MSVC runtime. + + Changed to use a faster implementation for `ip::network\_v4::canonical()`. + + Added template specialisations for common uses to improve compile + time. + + Reduced the size of `io\_context` + executors to a single pointer. + + Increased the small object buffer size for `execution::any\_executor` + and `any\_io\_executor`. + + Fixed multi-signature handling when variadic templates are disabled. + + Fixed compatibility with new versions of gcc and + clang. + + Fixed compilation on Solaris. + + Fixed defence against Qt-defined macros when building with MSVC. + + Improved error messages emitted by `ssl` + facilities. + + Fixed `bind\_executor` + compatibility with completion tokens. + + Fixed build errors when `BOOST\_ASIO\_USE\_TS\_EXECUTOR\_AS\_DEFAULT` + is defined. + + Added missing move assignment operator to `awaitable<>`. + + Fixed an access violation when using coroutines with MSVC, due to + incorrect alignment of allocated memory. + + Fixed a cleanup issue in `experimental::parallel\_group` + that occured when the execution context was shut down with parallel + operations still pending. + + Added clarifications to the documentation on concurrency hints. + + Added documentation on error handling techniques for C++20 coroutines. + + Fixed various warnings. + + Consult the [Revision + History](/doc/libs/1_78_0/doc/html/boost_asio/history.html) for further details. +* [Assert](/libs/assert/): + + + Added `source\_location::to\_string`. +* [Atomic](/libs/atomic/): + + + Use process-local futex operations on Android for non-IPC waiting + and notifying operations. + + Added support for Linux targets that only define `SYS\_futex\_time64` + syscall, such as riscv32. + + Added a workaround for incorrect result of `std::alignment\_of` + on clang 8 for 64-bit types on 32-bit x86 targets. + + Added a ulock backend for waiting and notifying operations on Darwin + systems since Mac OS 10.12, iOS 10.0, tvOS 10.0 or watchOS 3.0. + + On Windows, corrected discrepancy between *atomic-type*::always\_has\_native\_wait\_notify + and the corresponding capability macros when targeting Windows 8 + or later. The library will now directly use `WaitOnAddress` + and related APIs from public headers and therefore require user to + link with `synchronization.lib` + if the user requires Windows 8 or later by defining `BOOST\_USE\_WINAPI\_VERSION`, `\_WIN32\_WINNT` or similar macros. + The library is linked automatically on compilers that support auto-linking + (e.g. MSVC). + + Added support for types with padding bits, except unions, on compilers + that provide a way to clear the padding bits. This feature is supported + by gcc 11 and MSVC 14.2 (compiler version 19.27) and newer, as well + as other compilers supporting similar intrinsics. On compilers that + don't allow to clear the padding bits, types with padding are still + generally not supported with the exception of 80-bit `long double` + on x86 targets. A new `BOOST\_ATOMIC\_NO\_CLEAR\_PADDING` + capability macro is defined to indicate when clearing the padding + is not supported. + + Initializing constructors of `atomic\_ref` + and `ipc\_atomic\_ref` + no longer use atomic instructions to clear the padding bits in the + referenced object. This reduces the cost of the atomic reference + construction. + + Initializing constructors of `atomic` + and `ipc\_atomic` are + now `constexpr` for enums, + classes and floating point types. For classes and floating point + types, the constructors are `constexpr` + if the compiler supports `constexpr` + `std::bit\_cast`, the type has no padding + bytes and no padding is required to implement native atomic operations. + + In accordance with C++20, default constructors of `atomic` + and `ipc\_atomic` now + perform value initialization of the contained object. For types without + a user-defined default constructor, this means the default-constructed + atomic will be zero-initialized. + + Added a workaround for compilation error on AIX caused by the assembler + tool not supporting numeric labels. ([PR#50](https://github.com/boostorg/atomic/pull/50)) + + Added a workaround for compilation error with Visual Studio 2015 + prior to Update 3. ([#52](https://github.com/boostorg/atomic/issues/52)) + + See [changelog](/doc/html/atomic/changelog.html) + for more details. +* [Beast](/libs/beast/): + + + This maintenance update brings minor bug fixes and updated CI reporting. + + Fixed security vulnerability CVE-2016-9840 in zlib implementation. + + Fixed WebSocket permessage\_deflate implementation. This should result + in an increase in compression performance when using Beast WebSockets. + + Removed the test stream and test framework's dependency on RTTI. + You can now use our handy test stream to check your embedded asynchronous + communications code! + + We'd love to know how you or your company use Beast, consider adding + an entry to the [Companies + and Individuals Using Beast](https://github.com/boostorg/beast/wiki/Companies-and-Individuals-Using-Beast) list. + + See the full [Release + Notes](/libs/beast/doc/html/beast/release_notes.html) for a complete list of changes. +* [Core](/libs/core/): + + + Added a generic implementation to ``, + enabled when `BOOST\_CORE\_USE\_GENERIC\_CMATH` + is defined or when the platform does not provide the necessary facilities + in ``. + + Added `boost::core::type\_name`, a utility function that + returns the name of a type as a string. + + Added `boost::span`, a C++11 implementation of + C++20's `std::span` (Glen Fernandes). +* [Describe](/libs/describe/): + + + Added `has\_describe\_enumerators`, + `has\_describe\_bases`, + `has\_describe\_members`. + + Added `enum\_to\_string`, + `enum\_from\_string`. + + Added relational and stream insertion operators. + + Added `descriptor\_by\_name`, + `descriptor\_by\_pointer`. +* [DLL](/libs/dll/): + + + Fixed missing #include, thanks to Denis Blank ([PR#54](https://github.com/boostorg/dll/pull/54)) + + Dropped TravisCI in favor of GithubAction CI +* [Filesystem](/libs/filesystem/): + + + **v4:** `path::filename` + and `path::iterator` no longer return an implicit + trailing dot (".") element if the path ends with a directory + separator. Instead, an empty path is returned, similar to C++17 std::filesystem. + This also affects other methods that are defined in terms of iterators + or filename, such as `path::stem`, + `path::compare` or `lexicographical\_compare`. + For example, `path("a/b/") == path("a/b/.")` + no longer holds true. ([#193](https://github.com/boostorg/filesystem/issues/193)) + + **v4:** `path::lexically\_normal` + no longer produce a trailing dot (".") element and omits + a directory separator after a trailing dot-dot ("..") element + in the normalized paths. + + **v4:** `path` + append operations now consider root name and root directory in the + appended path. If the appended path is absolute, or root name is + present and differs from the source path, the resulting path is equivalent + to the appended path. If root directory is present, the result is + the root directory and relative path rebased on top of the root name + of the source path. Otherwise, the behavior is similar to v3. ([#214](https://github.com/boostorg/filesystem/issues/214)) + + `path::lexically\_normal` now converts directory + separators to preferred separators in the root name of the normalized + paths. + + Optimized overloads of `path::assign`, + `path::append`, `path::concat` + and the corresponding operators to avoid unnecessary path copying + and reduce the amount of code redundancy. + + On POSIX systems, fixed `absolute(p, base)` returning a path with root name + `base.root\_name()` + if `p` starts with + a root directory. In such a case `p` + is already an absolute path and should be returned as is. + + `create\_directories` + no longer reports an error if the input path consists entirely of + dot (".") and dot-dot ("..") elements. The implementation + is no longer using recursion internally and therefore is better protected + from stack overflow on extremely long paths. + + On Windows, `remove` + now supports deleting read-only files. The operation will attempt + to reset the read-only attribute prior to removal. Note that this + introduces a possibility of the read-only attribute being left unset, + if the operation fails and the original value of the attribute fails + to be restored. This also affects `remove\_all`. + ([#216](https://github.com/boostorg/filesystem/issues/216)) + + `remove\_all` now returns + `static\_cast< + uintmax\_t >(-1)` + in case of error, similar to C++17 std::filesystem. + + Fixed a linking error about unresolved references to Boost.ContainerHash + functions when user's code includes `boost/filesystem/path.hpp` + but not `boost/container\_hash/hash.hpp` and the compiler is set to + preserve unused inline functions. ([#215](https://github.com/boostorg/filesystem/issues/215)) + + Added a workaround for MSVC and compatible compilers eliminating + path globals cleanup in release builds. This could lead to a memory + leak if Boost.Filesystem shared library was repeatedly loaded and + unloaded in the process. ([#217](https://github.com/boostorg/filesystem/issues/217)) +* [Geometry](/libs/geometry/): + + + Improvements + + - [PR#894](https://github.com/boostorg/geometry/pull/894) Optimization and refactoring of rtree queries. + - [PR#913](https://github.com/boostorg/geometry/pull/913) DynamicGeometry and GeometryCollection support + in various algorithms (undocumented for now). + - [PR#922](https://github.com/boostorg/geometry/pull/922) DynamicGeometry and GeometryCollection support + in distance (undocumented for now). + + Solved issues + + - [#867](https://github.com/boostorg/geometry/issues/867) Poor performance of rtree query iterator with + nearest predicate for big k. + - [#870](https://github.com/boostorg/geometry/issues/870) Compilation error in boost::geometry::self\_turns. + - [#896](https://github.com/boostorg/geometry/issues/896) Assertion failure in get\_turns with BOOST\_GEOMETRY\_NO\_ROBUSTNESS. + + Bugfixes + + - [PR#906](https://github.com/boostorg/geometry/pull/906) Invalid result of buffer on macos-11 with + clang-12. + - [PR#921](https://github.com/boostorg/geometry/pull/921) Compilation errors with c++20 (various compilers) + and gcc-5. + - Various fixes in set operations and buffer. +* [JSON](/libs/json/): + + + Standalone mode of the library is deprecated. + + Allow external libraries to forward declare `value\_to` + and `value\_from`. + + Fixed signed integer overflow in number parsing. + + Add support for `/Zc:implicitNoexcept-` on MSVC. +* [Lambda2](/libs/lambda2/): + + + Added special cases in `operator<<` and `operator>>` when the first argument is + a stream, to allow `std::cout + << \_1`. + + Added `operator->\*`. + + Added `first`, `second`. +* [Log](/libs/log/): + + + General changes: + + - Updated detection of `std::codecvt` + specializations for `char16\_t` + and `char32\_t` for + compatibility with C++17 and later. ([PR#159](https://github.com/boostorg/log/pull/159)) + - Added support for C++17 `std::byte` + type to receive methods of the inter-process message queue. + - On Windows, when building the library for Windows 8 or later, + the library will use `nt62` + tag in the version namespace to denote the target OS ABI. For + example, the version namespace could be named as `v2\_mt\_nt62`. This name will + be part of all symbols exported by the library. Use the `BOOST\_USE\_WINAPI\_VERSION` + macro consistenly when building Boost and your code to request + the minimum target Windows version. + - Improved performance of SSSE3 and AVX2 implementations of the + `dump` stream + manipulator. + - Added support for CMake build system. Only library build is + supported at this moment, Boost.Build is still used for running + tests. + + Bug fixes: + + - Fixed a race condition on POSIX systems in `reliable\_message\_queue::open\_or\_create` + or the equivalent constructor. Multiple threads or processes + calling `open\_or\_create` + concurrently with sending or receiving messages from the same + queue could end up corrupting the queue contents and potentially + crashing the process. ([#162](https://github.com/boostorg/log/issues/162)) + - Added a workaround for `b2 + install` failing on + Windows because of missing `boost\_log\_setup` + library if `BOOST\_LOG\_WITHOUT\_SETTINGS\_PARSERS` + is defined. ([#164](https://github.com/boostorg/log/issues/164)) + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Math](/libs/math/): + + + Add support for cubic roots. + + Add support for `constexpr` + versions of various standard library math routines. + + Add support for Bezier polynomials. + + Improve worst-case tanh-sinh integration performance. + + Disable inadvertant use of integral types in integration routines. + + Minor update for erf approximations when the result is with 2ulp + of 1. + + Allow Bernoulli code to be used on platforms with no atomic integers. + + Improve the mode of the non-central Chi Squared distribution. + + Improve certain edge cases for complex-valued elementary + functions, see [#507](https://github.com/boostorg/math/issues/507). +* [Multi-index Containers](/libs/multi_index/): + + + Added `contains` to + key-based indices (issue [#35](https://github.com/boostorg/multi_index/issues/35)). + + Added `merge` operations + to key-based indices. The functionality goes beyond the standard + specification for (unordered) associative containers in a number + of ways, most notably: + + - The source index can be of any type, including non key-based + indices. + - Partial merge is provided: for instance, `x.merge(y,first,last)` merges only the elements of + `y` within [`first`,`last`). + + Previous versions of `splice` + for sequenced and random access indices were destructive, i.e. elements + were copy-inserted into the destination and then erased from the + source. Now, `splice` + is based on node transfer much as `merge` + in key-based indices, and has been similarly extended to accept source + indices of any type: in fact, `splice` + can be regarded as a frontend to the same functionality provided + by `merge` in key-based + indices. For reasons of backwards compatibility, the destructive + behavior of `splice` + has been retained in the case that the source and destination containers + have unequal allocators. + + The fact has been documented that index iterator types do only depend + on `node\_type` and + the position of the index in its `multi\_index\_container`, + (except for hashed indices, where uniqueness/non-uniqueness is also + a dependency). This has implications on the validity of iterators + to elements transferred by `merge` + or `splice`. This property + is a variant of what has been called [SCARY + iterators](https://wg21.link/n2980) in the C++ standard mailing lists. SCARYness is + currently (August 2021) not mandated for standard containers. + + Iterator SCARYness is now also preserved in [safe + mode](/libs/multi_index/doc/tutorial/debug.html#safe_mode). +* [Multiprecision](/libs/multiprecision/): + + + Rework rational\_adaptor to remove dependency on Boost.Rational and + improve performance. + + Fix issue with type\_traits and clang, see [#383](https://github.com/boostorg/multiprecision/issues/383). + + Fixed buggy Lehmer's GCD routine, see [#370](https://github.com/boostorg/multiprecision/issues/370). + + Fix mpc\_complex constructors so that lossy conversions are explicit, + see [#363](https://github.com/boostorg/multiprecision/issues/363). + + Correct miscellaneous configuration issues (Intel intrinsic usage + and Apple clang). + + Correct some iostream operators for unsigned char types. + + Correct mpq\_rational conversions to integer types, see [#342](https://github.com/boostorg/multiprecision/issues/342). +* [Nowide](/libs/nowide/): + + + Breaking Change: `do\_unshift` + for the UTF-32 specialization of `utf8\_codecvt` + now correctly returns `noconv` + instead of `ok` + + Remove unnecessary branch in `utf8\_codecvt` + for UTF-16 output + + Suppress deprecation warnings in MSVC when using `utf8\_codecvt` + with unicode char types + + Fix possible double-free when setting a custom buffer (`setbuf`) after `filebuf` + already allocated an internal buffer +* [PFR](/libs/pfr/): + + + Added missing `#include + ` for inclusion of `std::addressof` + + Fixed -Wzero-length-array warning when dealing with empty aggregates + + Fixed compilation on msvc compilers <= 1920 (thanks to Alexey + Romanov aka @alexey-romanov) + + Added basic CMakeLists.txt support (thanks to @pdimov aka Peter Dimov) + + Multiple improvements for docs, including links to https://github.com/apolukhin/pfr\_non\_boost + + Added misc/strip\_boost\_namespace.sh script to remove `boost::` + and `BOOST\_` prefixes +* [Predef](/libs/predef/): + + + Version 1.13.1 + + Fix spelling of "epoch". + + Add missing parenthesis in sparc.h (from tkoecker). + + Update documentation to use Rouge code styling and Amber general + style. +* [Regex](/libs/regex/): + + + **Breaking Change:** Change \B to be + the opposite of \b as per Perl behaviour. + + Change w32\_regex\_traits.hpp so that windows.h is no longer included. + + Fxed fuzzing related issues [#151](https://github.com/boostorg/regex/issues/151), + [#152](https://github.com/boostorg/regex/issues/152), + [#153](https://github.com/boostorg/regex/issues/153), + [#156](https://github.com/boostorg/regex/issues/156). +* [System](/libs/system/): + + + Added support for source locations to `error\_code`. + + Added `error\_code::to\_string`, + `error\_condition::to\_string`, `error\_code::what`. + + `system\_error::what()` + now contains the source location, if present. + + Added `result`, + a class holding either a value or an error, defined in ``. +* [Utility](/libs/utility/): + + + Library documentation converted to QuickBook (thanks to Alan de Freitas, + [PR#79](https://github.com/boostorg/utility/pull/79)). +* [Variant2](/libs/variant2/): + + + Added ``. + + Added `unsafe\_get`. + + Added `visit\_by\_index`. + + Added `operator<<`. + +### Updated Tools + + +* [Build](/tools/build/): + + + Includes release of [B2 + version 4.7.2](/tools/build/doc/html/#_version_4_7_2). + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 12.0.0 + + Clang, C++11: 3.4, 11.0.0 + + Clang, C++14: 3.5, 3.6, 3.7, 3.8, 3.9, 4.0, 5.0, 12.0.0 + + Clang, C++17: 6.0.1, 7.0.0, 8.0.0, 9.0.0, 10.0.0, 11.0.0, 12.0.0 + + Clang, C++20: 11.0.0, 12.0.0, 13.0.0 + + GCC: 4.6.3, 11 + + GCC, C++11: 4.7.3, 4.8.5, 11 + + GCC, C++14: 5.4.0, 6.4.0, 7.3.0, 8.0.1, 9.1.0, 11 + + GCC, C++17: 7.3.0, 8.0.1, 9.1.0, 11 + + GCC, C++20: 8.0.1, 9.1.0, 10, 11 +* OS X: + + + Apple Clang: 11.0.3 + + Apple Clang, C++11: 11.0.3 + + Apple Clang, C++14: 11.0.3 + + Apple Clang, C++17: 11.0.3 + + Apple Clang, C++20: 11.0.3 +* Windows: + + + Visual C++: 10.0, 11.0, 12.0, 14.0, 14.1, 14.2 + +### Acknowledgements + Marshall Clow, Michael Caisse and Glen Fernandes managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_79_0.html b/users/history/version_1_79_0.html new file mode 100644 index 0000000..34c4b95 --- /dev/null +++ b/users/history/version_1_79_0.html @@ -0,0 +1,483 @@ +--- +title: Version 1.79.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.79.0 + +/\*\*/ + + + + + + + +Version 1.79.0 +============== + +Version 1.79.0 +-------------- + + +April 13th, 2022 14:22 GMT + + +[Documentation](/doc/libs/1_79_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_79\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.79.0/source/boost_1_79_0.tar.bz2) | 475d589d51a7f8b3ba2ba4eda022b170e562ca3b760ee922c146b6c65856ef39 | +| [boost\_1\_79\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.79.0/source/boost_1_79_0.tar.gz) | 273f1be93238a068aba4f9735a4a2b003019af067b9c183ed227780b8f36062c | +| windows | [boost\_1\_79\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.79.0/source/boost_1_79_0.7z) | 6c97cf4f4a0eb00ed776c88065ab3f59e183fa5e65f6464ff94f92328352d9d6 | +| [boost\_1\_79\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.79.0/source/boost_1_79_0.zip) | 3634f9a85759311f321e587eace21799c0d0c946ff933e477a2f98885c54bbff | + + +### Known Issues + These are patches from library authors which were found too late to be fixed + in the release. + + + +* Boost.JSON `array::erase` can segfault, see [#692](https://github.com/boostorg/json/issues/692). + [Patch](/patches/1_79_0/0001-json-array-erase-relocate.patch). + +### New Libraries + + +* No new libraries. + +### Updated Libraries + + +* [Asio](/libs/asio/): + + + Added `bind\_allocator`. + + Added `file\_base::sync\_all\_on\_write` flag. + + Added missing implementation of `basic\_file::release()`. + + Added per-operation cancellation support to signal sets. + + Exposed `recycling\_allocator` + as part of the public interface. + + Added the `nodiscard` + attribute to a number of functions. + + Added OpenSSL 3.0 compatibility. + + Added support for adopting an existing `SSL\*` into an `ssl::stream<>`. + + Enabled `executor\_work\_guard<>` in all build configurations. + + Enabled movable socket iostreams when using clang. + + Fixed `bind\_cancellation\_slot` + and `bind\_executor` + compatibility with legacy completion tokens. + + Fixed `associator` + specialisations for `experimental::append` + and `experimental::prepend`. + + Fixed `associated\_allocator` + primary template. + + Fixed io\_uring implementations of `async\_receive\_from` for sockets + and `write\_some\_at` + for files. + + Fixed io\_uring feature detection. + + Fixed `experimental::coro`'s + per-operation cancellation. + + Fixed memory management in `experimental::promise`'s + type-erased completion handlers. + + Fixed move `operator=` implementation for `ssl::stream`. + + Fixed `any\_io\_executor` + implementation to work when both `BOOST\_ASIO\_USE\_TS\_EXECUTOR\_AS\_DEFAULT` + and `BOOST\_ASIO\_SEPARATE\_COMPILATION` + are defined. + + Fixed implementation of `basic\_socket::at\_mark()` when using the `sockatmark()` system call. + + Changed the recycling allocator to use the default alignment as the + minimum alignment for allocations. + + Added a workaround for apparent coroutine codegen bug with Apple's + clang. + + On Windows, changed the file support to open files using the same + sharing mode as `fopen()`. + + On Linux, fixed UNIX domain sockets implementation to correctly handle + `EAGAIN`. + + Fixed implementation of `experimental::basic\_channel::reset()` and `experimental::basic\_concurrent\_channel::reset()`. + + Fixed potential undefined behaviour in the `experimental::promise`. + + Changed the `co\_spawn` + implementation to dispatch cancellation signals through the executor + in some circumstances. + + Fixed various header inclusion issues. + + Fixed various warnings. + + A number of documentation enhancements, including: + + - Added an overview of Asio's asynchronous model. + - Reworked reference and requirements documentation in terms + of asynchronous model. + - Updated documentation for `dispatch()`, `post()`, and `defer()`. + - Documented per-operation cancellation for serial ports. + - Clarified the non-concurrency guarantees made for allocators. + - Reverted the `io\_context` + reference documentation to use `executor\_work\_guard`. + - Added more detailed reference documentation to `make\_strand()`, + `make\_work\_guard()`, `ip::address\_v4`, + `ip::address\_v6`, `experimental::basic\_channel`, and `experimental::basic\_concurrent\_channel`. + - Re-arranged and extended the Overview documentation to cover + recently added features. + + Added a C++11 example showing file descriptor passing over local + sockets. + + Added C++14 examples of wrapping callback-based APIs in asynchronous + operations. + + Consult the [Revision + History](/doc/libs/1_79_0/doc/html/boost_asio/history.html) for further details. +* [Assert](/libs/assert/): + + + `source\_location().file\_name()` + and `source\_location().function\_name()` now return `""` + instead of `"(unknown)"`. + + Added a `source\_location` + constructor from `std::source\_location`. + + Changed `BOOST\_CURRENT\_LOCATION` + to more closely match the behavior of `std::source\_location::current()`, such as being usable at top level + or as a default function argument. +* [Atomic](/libs/atomic/): + + + Fixed compilation for Universal Windows Platform (UWP). ([#54](https://github.com/boostorg/atomic/issues/54)) + + Added `BOOST\_ATOMIC\_NO\_DARWIN\_ULOCK` + configuration macro. The macro affects compilation on Darwin systems + and disables `ulock`-based + implementation of waiting and notifying operations. This may be useful + to comply with Apple App Store requirements. ([#55](https://github.com/boostorg/atomic/issues/55)) +* [Beast](/libs/beast/): + + + Added missing include for file\_body test. + + Fixed WebSocket handshake response on failure. + + Fixed open append mode for `file\_posix` + and `file\_win32`. + + Fixed file open with append/append\_existing flag on Windows + + Fixed clang-cl UTF8 path handling for `file\_win32` + and `file\_stdio`. + + Added ARM64 builds to drone CI. + + Fixed async\_base documentation link. + + Added tests for file open in append/append\_existing mode. + + Updated CI to include gcc 11, clang 12, msvc 14.3. + + Added individual tests to CMake workflow. + + We'd love to know how you or your company use Beast, consider adding + an entry to the [Companies + and Individuals Using Beast](https://github.com/boostorg/beast/wiki/Companies-and-Individuals-Using-Beast) list. + + See the full [Release + Notes](/libs/beast/doc/html/beast/release_notes.html) for a complete list of changes. +* [Core](/libs/core/): + + + Made `boost::pointer\_traits` SFINAE friendly, + addressing LWG3545. (Glen Fernandes) + + Added `boost::allocator\_traits` that uses the + individual allocator access traits. This implementation supports + C++03 and above. (Glen Fernandes) + + Updated the allocator access traits to support most of the C++11 + allocator model in C++03. (Glen Fernandes) + + `boost/iterator.hpp` is deprecated and will be removed + in a future release. The header defines `boost::iterator` + template, which is equivalent to `std::iterator` + in `` header. However, since `std::iterator` is itself deprecated in + C++17, users are advised to remove `boost::iterator` + or `std::iterator` use from their code. + + Added `boost::core::verbose\_terminate\_handler`, a utility + function intended to be passed to `std::set\_terminate` + that prints information about the uncaught exception to `stderr`. +* [Describe](/libs/describe/): + + + Enabled unions in `BOOST\_DESCRIBE\_STRUCT` + and updated examples to check `std::is\_union`. + + Added example of defining a `fmtlib` + class formatter. + + Added example of defining a `fmtlib` + enum formatter. + + Added example of printing pointers to members. +* [Filesystem](/libs/filesystem/): + + + **v3:** `path::replace\_extension` + now works in terms of **v3** definition + of `path::extension` rather than **v4**. + + Fixed compilation of path appending and concatenation operators with + arguments of types convertible to `path` + or compatible string type. ([#223](https://github.com/boostorg/filesystem/issues/223)) + + On POSIX systems that support `fdopendir` + and `O\_NOFOLLOW` and + on Windows, `remove\_all` + is now protected against [CVE-2022-21658](https://www.cve.org/CVERecord?id=CVE-2022-21658). + The vulnerability is a race condition that allows a third party process + to replace a directory that is being concurrently processed by `remove\_all` with a directory symlink + and cause `remove\_all` + to follow the symlink and remove files in the linked directory instead + of removing the symlink itself. ([#224](https://github.com/boostorg/filesystem/issues/224)) + + On Windows, in `remove` + and `remove\_all` implementation, + use POSIX semantics for file removal, when supported by the OS (Windows + 10 1709 and later). When POSIX semantics is supported, the file name + is removed from the filesystem namespace as soon as the file is marked + for deletion, even if it is still open and in use. With legacy Windows + semantics, the file name remains present in the the filesystem namespace + until the last file handle to the file is closed, which allows the + file marked for deletion to be opened and prevents creating new files + with the same name. ([#216](https://github.com/boostorg/filesystem/issues/216)) + + On Windows, `remove` + and `remove\_all` now + support deleting read-only directories. Support for removing read-only + non-directory files was added previously. + + On Windows, `directory\_iterator` + internal implementation has been reworked to better utilize modern + Windows APIs, which may improve performance while handling symlinks. + + On Windows, initialize internal WinAPI function pointers early, if + possible, to allow Boost.Filesystem operations to be invoked in global + constructors. This is only supported on MSVC, GCC, Clang and compatible + compilers. + + On Windows, `resize\_file` + should no longer fail with an error if the file to be resized is + opened. + + Disabled use of the `statx` + syscall on Android prior to 11.0 (API version 30). The syscall is + blacklisted by seccomp and causes process termination in runtime. + ([#229](https://github.com/boostorg/filesystem/issues/229)) + + **Deprecated:** `boost/filesystem/string\_file.hpp` + header is deprecated and will be removed in a future release. The + header is no longer included by `boost/filesystem.hpp` + by default. Users are advised to implement the functionality themselves + or migrate to other implementations. + + **Deprecated:** Windows CE support is + deprecated and will be removed in a future release. Windows CE has + been untested for many years and is likely non-functional. +* [Geometry](/libs/geometry/): + + + Major change + + - [PR#977](https://github.com/boostorg/geometry/pull/977) Rescaling is turned off by default. This avoids + many related bugs in set operations and buffer. + + Improvements + + - [PR#923](https://github.com/boostorg/geometry/pull/923) Added algorithm closest\_points for cartesian + point/geometry. + - [PR#939](https://github.com/boostorg/geometry/pull/939) Added algorithm closest\_points for other coordinate + systems and geometry combinations excl. boxes. + - [PR#961](https://github.com/boostorg/geometry/pull/961) Added Web Mercator projection. + - [PR#966](https://github.com/boostorg/geometry/pull/966) More efficient cartesian distance strategy + used in simplify. + + Solved issues + + - [#956](https://github.com/boostorg/geometry/issues/956) Result of simplify algorithm with incorrect + closure. + - [#962](https://github.com/boostorg/geometry/issues/962) Runtime error in R-tree deserialization due + to load factor. + - [#971](https://github.com/boostorg/geometry/issues/971) R-tree insertion time impacted by use of long + double on ARM platforms. + + Bugfixes + + - [PR#936](https://github.com/boostorg/geometry/pull/936) Envelope of polygon containing pole. + - [PR#948](https://github.com/boostorg/geometry/pull/948) Spherical and geographic envelope for near + meridian segments. + - [PR#974](https://github.com/boostorg/geometry/pull/974) Spheroidal normalization utilities for NaN + coordinates. + - Various fixes in set operations and buffer. +* [Integer](/libs/integer/): + + + Optimized `integer\_log2` + implementation to use bit operations internally. This allows to employ + bit instructions available on most modern CPUs. ([#31](https://github.com/boostorg/integer/issues/31)) +* [IO](/libs/io/): + + + Added `boost::io::basic\_nullbuf`, a null stream buffer, + and `boost::basic\_onullstream`, a null output + stream (Glen Fernandes). +* [Iterator](/libs/iterator/): + + + In `counting\_iterator`, + added support for built-in 128-bit integer types supported by gcc + and clang and compatible compilers on some target platforms. + + Silenced gcc warnings about deprecated implicit copy assignment operator + in `counting\_iterator`. +* [JSON](/libs/json/): + + + Standalone mode of the library is removed. Users who wish to continue + using standalone JSON can switch to [the + C++ Alliance fork](https://github.com/CPPAlliance/standalone-json.git). + + Add `std::error\_code` overloads. + + Add `boost::source\_location` to `error\_codes`. + + Add support for JSON Pointer. + + Naturally grow string during serialization. +* [LEAF](/libs/leaf/): + + + Support for FreeRTOS and other embedded platforms + + Improved diagnostic information + + Improved configuration macros + + BOOST\_LEAF\_CHECK using statement expressions under \_\_GNUC\_\_ + + Fixed symbol demangling bug +* [Log](/libs/log/): + + + General changes: + + - In `text\_file\_backend`, + added support for appending to a previously written log file, + when file rotation is used and log file names use file counters. + - **Breaking change:** The `file\_collector` interface + has changed: + + * `scan\_for\_files` + method returns a `scan\_result` + structure that contains information collected during + the scan; + * `is\_in\_storage` + method added for testing if a path refers to a file within + the target storage directory. + - Added a new `invoke\_manip` + stream manipulator that can be used for injecting user's function + into a stream output expression. + + Bug fixes: + + - Fixed file counter being set to zero if the user calls `text\_file\_backend::scan\_for\_files` multiple times, + and the second and the following calls don't find any new files. + ([#179](https://github.com/boostorg/log/issues/179)) + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Multi-index Containers](/libs/multi_index/): + + + Improved the efficiency of `count` + operations in ranked indices from `O(log(n) + count)` + to `O(log(n))`. + Contributed by Damian Sawicki. + + Maintenance work. +* [Nowide](/libs/nowide/): + + + Fix compilation issues on some platforms (e.g. GCC 11 on MinGW-w64 + and Cygwin) + + Fix missing include when using `BOOST\_USE\_WINDOWS\_H` + and `WIN32\_LEAN\_AND\_MEAN` + + Add sanity check when using `boost::nowide::stat` + with `boost::nowide::stat\_t` +* [Optional](/libs/optional/): + + + Fixed [issue + #98](https://github.com/boostorg/optional/issues/98). + + Fixed [issue + #92](https://github.com/boostorg/optional/issues/92). + + Added support for `BOOST\_NO\_IOSTREAM`. + + Now aligned storage uses `unsigned + char` rather than `char` to avoid UB. + + Now using cv-unqualified `value\_type` + with placement `new` to + avoid UB. +* [Predef](/libs/predef/): + + + Version 1.14.0 + + Add detection of LoongArch (from Zhang Na). +* [QVM](/libs/qvm/): + + + Added constexpr under C++17 + + Improved single header distribution +* [Smart Pointers](/libs/smart_ptr/): + + + Added `boost::get\_allocator\_pointer` to obtain + the Allocator pointer from the result of `boost::allocate\_unique` + (Glen Fernandes). +* [System](/libs/system/): + + + Added a `boost::source\_location` parameter to `throw\_exception\_from\_error`. + + Added `throw\_exception\_from\_error` + overloads for `errc::errc\_t`, + `std::error\_code`, `std::errc`, + `std::exception\_ptr`. + + `result::value` now automatically supplies + `BOOST\_CURRENT\_LOCATION` + to `throw\_exception\_from\_error` + via a default argument. + + Added an `errc::make\_error\_code` overload taking + a source location. +* [ThrowException](/libs/throw_exception/): + + + Added `boost::throw\_with\_location`, a more lightweight + alternative of `BOOST\_THROW\_EXCEPTION` + for programs that do not use Boost.Exception. +* [Unordered](/libs/unordered/): + + + All containers have been updated to support heterogeneous `count`, `equal\_range` + and `find`. + + All containers now implement the member function `contains`. + + `erase\_if` has been + implemented for all containers. + + All containers have been updated to support heterogeneous `erase` and `extract`. + + Changed behavior of `reserve` + to eagerly allocate. + + Various warning fixes in the test suite. + + Update code to internally use `boost::allocator\_traits`. + + Switch to Fibonacci hashing. + + Update documentation to be written in AsciiDoc instead of QuickBook. +* [Variant2](/libs/variant2/): + + + Added `operator<<` + for `monostate`. +* [Wave](/libs/wave/): + + + C++11 now required for building Wave itself + + Fixed bugs: + + - [#135](https://github.com/boostorg/wave/issues/135): Comma operators in array subscripts are deprecated + in C++20 + - [#137](https://github.com/boostorg/wave/issues/137): Simple unknown directive => found\_unknown\_directive + is not called, stripped of pound. + - [#138](https://github.com/boostorg/wave/issues/138): Empty ifdef block does not emit line directive + for missing whitespace + - [#143](https://github.com/boostorg/wave/issues/143): Parsing \_\_has\_include() fails with trailing tokens + - [#145](https://github.com/boostorg/wave/issues/145): Sanitizer complains about reset\_version() + - [#147](https://github.com/boostorg/wave/issues/147): bitwise operations between different enumeration + types are deprecated + +### Updated Tools + + +* [Build](/tools/build/): + + + Includes release of [B2 + version 4.8.2](/tools/build/doc/html/#_version_4_8_2). + +### Compilers Tested + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 12.0.0 + + Clang, C++11: 3.4, 11.0.0 + + Clang, C++14: 3.5, 3.6, 3.7, 3.8, 3.9, 4.0, 5.0, 12.0.0 + + Clang, C++17: 6.0.1, 7.0.0, 8.0.0, 9.0.0, 10.0.0, 11.0.0, 12.0.0 + + Clang, C++20: 11.0.0, 12.0.0, 13.0.0 + + GCC: 4.6.3, 11 + + GCC, C++11: 4.7.3, 4.8.5, 11 + + GCC, C++14: 5.4.0, 6.4.0, 7.3.0, 8.0.1, 9.1.0, 11 + + GCC, C++17: 7.3.0, 8.0.1, 9.1.0, 11 + + GCC, C++20: 8.0.1, 9.1.0, 10, 11 +* OS X: + + + Apple Clang: 11.0.3 + + Apple Clang, C++11: 11.0.3 + + Apple Clang, C++14: 11.0.3 + + Apple Clang, C++17: 11.0.3 + + Apple Clang, C++20: 11.0.3 +* Windows: + + + Visual C++: 10.0, 11.0, 12.0, 14.0, 14.1, 14.2 + +### Acknowledgements + Marshall Clow, Michael Caisse and Glen Fernandes managed this release. + + + + + + + + + + + + diff --git a/users/history/version_1_80_0.html b/users/history/version_1_80_0.html new file mode 100644 index 0000000..50c9217 --- /dev/null +++ b/users/history/version_1_80_0.html @@ -0,0 +1,542 @@ +--- +title: Version 1.80.0 +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Version 1.80.0 + +/\*\*/ + + + + + + + +Version 1.80.0 +============== + +Version 1.80.0 +-------------- + + +August 10th, 2022 21:25 GMT + + +[Documentation](/doc/libs/1_80_0/) + + +Downloads| Platform | File | SHA256 Hash | +| unix | [boost\_1\_80\_0.tar.bz2](https://boostorg.jfrog.io/artifactory/main/release/1.80.0/source/boost_1_80_0.tar.bz2) | 1e19565d82e43bc59209a168f5ac899d3ba471d55c7610c677d4ccf2c9c500c0 | +| [boost\_1\_80\_0.tar.gz](https://boostorg.jfrog.io/artifactory/main/release/1.80.0/source/boost_1_80_0.tar.gz) | 4b2136f98bdd1f5857f1c3dea9ac2018effe65286cf251534b6ae20cc45e1847 | +| windows | [boost\_1\_80\_0.7z](https://boostorg.jfrog.io/artifactory/main/release/1.80.0/source/boost_1_80_0.7z) | d12a2af721e22dbfb984ef061ee4c4ab2387f1904f6d65bc5acebaa34d6366ec | +| [boost\_1\_80\_0.zip](https://boostorg.jfrog.io/artifactory/main/release/1.80.0/source/boost_1_80_0.zip) | e34756f63abe8ac34b35352743f17d061fcc825969a2dd8458264edb38781782 | + + +### Known Issues + These are patches from library authors which were found too late to be fixed + in the release. + + + +* Boost.Filesystem directory iterators may fail to construct for a network + share on Windows prior to 10, see [PR#246](https://github.com/boostorg/filesystem/pull/246) and [#245](https://github.com/boostorg/filesystem/issues/245). + [Patch](/patches/1_80_0/0001-filesystem-win-fix-dir-it-net-share.patch). +* In Boost.Filesystem on Windows, `weakly\_canonical` + fails to process paths that start with the "\\?\" prefix, see + [#247](https://github.com/boostorg/filesystem/issues/247). [Patch](/patches/1_80_0/0002-filesystem-fix-weakly-canonical-long-paths.patch). + +### New Libraries + + +* No new libraries. + +### Updated Libraries + + +* [Asio](/libs/asio/): + + + Added a deduced trailing return type to all asynchronous operations, + to enable the new form of `async\_result` + for C++11. + + Moved `append`, `prepend`, `as\_tuple`, + and `deferred` to the + `boost::asio` namespace, and made them compatible + with C++11. + + Made `experimental::parallel\_group` + compatible with C++11. + + Added `buffer()` + overloads for contiguous containers, such as `std::span`. + + Added the ability for `awaitable<>`-based coroutines to directly + `co\_await` operations + that are packaged as function objects. + + Changed `spawn()` + to be a completion token-based asynchronous operation, and added + support for cancellation. The `basic\_yield\_context` + token now supports move-only and variadic result types. When targeting + C++11 and later, `spawn()` and `basic\_yield\_context` + are implemented in terms of Boost.Context directly. + + Added the `is\_async\_operation` + trait and `async\_operation` + concept. + + Added the `completion\_signature\_of` + trait. + + Added converting move construction/assignment to posix descriptors, + serial ports, pipes, Windows `object\_handle`, + Windows stream handles, and Windows random-access handles. + + Added `release()` + member functions to pipes, Windows stream handles, and Windows random-access + handles. + + Enabled support for `Endpoint` + implementations that return `void` + pointers from their `data()` member functions, as per the documented + `Endpoint` type requirements. + + Removed `all()` + and `race()` + from `experimental::promise`, + as `experimental::parallel\_group` covers this functionality. + + Added source locations to exceptions and error codes produced by + the synchronous and asynchronous operations. + + Fixed compatibility with OpenSSL 3.0.4 and later. + + Fixed compatibility with with -masm=intel. + + Explicitly stated that socket `shutdown()` calls are thread-safe with respect + to certain other synchronous operations on the same socket. + + Optimised the move construction of I/O objects where only the executor + type differs. + + Fixed the detection of `std::invoke\_result` + for clang/libc++. + + Fixed an issue where `experimental::parallel\_group` + initiation incorrectly moved arguments instead of forwarding them. + + Fixed a sequencing issue in the implementation of `post()`, `dispatch()`, and `defer()`. + + Fixed the `awaitable<>` implementation to propagate + exceptions from awaited initiation functions through the current + completion handler. + + Fixed detection of `std::aligned\_alloc` + with gcc 7. + + Changed to avoid using the soon-to-be-deprecated `std::aligned\_storage` + on newer compilers. + + Fixed detection of `std::aligned\_alloc` + for older Apple platforms. + + Removed faulty assertions from `experimental::coro` + implementation. + + Added defence against Qt-defined macros when building with Intel + C++. + + Changed the implementation of the `select\_reactor`, + on Windows, to ensure that any exception resulting from failure to + recreate its interrupter's sockets will be allowed to propagate out + through `io\_context::run()`. + + Fixed various compiler warnings. + + Updated all composed operations examples, and the C++11 timeouts + example, to use the new `async\_result` + form. + + Added composed operation and coroutine examples for C++20. + + Consult the [Revision + History](/doc/libs/1_80_0/doc/html/boost_asio/history.html) for further details. +* [Atomic](/libs/atomic/): + + + Improved portability of endianness checks on ARM, AArch32 and AArch64 + targets. ([#59](https://github.com/boostorg/atomic/issues/59)) + + Fixed compilation with MSVC 14.0 (Visual Studio 2015) in C++17 mode. + ([#61](https://github.com/boostorg/atomic/issues/61)) +* [Filesystem](/libs/filesystem/): + + + On Windows, added a fallback implementation for querying file attributes + in case if the file cannot be opened with `ERROR\_ACCESS\_DENIED` + error. This may allow `status` + and `symlink\_status` + to succeed for system files and directories that are not reparse + points or symlinks. ([#234](https://github.com/boostorg/filesystem/issues/234)) + + On Windows, added a workaround for FAT/exFAT filesystems that produce + `ERROR\_INVALID\_PARAMETER` + when querying file attributes. This affected `status` + and `symlink\_status`, + which reported that files do not exist, and directory iterators, + which failed to construct, as well as other dependent operations. + ([#236](https://github.com/boostorg/filesystem/issues/236), [#237](https://github.com/boostorg/filesystem/issues/237)) + + Worked around a compilation problem on [RTEMS](https://www.rtems.org/). + ([PR#240](https://github.com/boostorg/filesystem/pull/240)) + + On Linux, corrected switching to `sendfile` + `copy\_file` implementation + if `copy\_file\_range` + failed with `ENOSYS` + in runtime. The `sendfile` + fallback implementation used to skip the filesystem type check and + could fail for some filesystems. + + On POSIX systems supporting `openat` + and related APIs defined in POSIX.1-2008 and on Windows Vista and + later, improved protection of `remove\_all` + against [CVE-2022-21658](https://www.cve.org/CVERecord?id=CVE-2022-21658) + that was implemented in the previous release. The previous fix could + still result in removing unintended files in [certain + conditions](https://github.com/boostorg/filesystem/issues/224#issuecomment-1183738097). Other systems remain vulnerable. +* [GIL](/libs/gil/): +**NOTICE:** + We are planning BREAKING switch to C++17 as minimum required C++ language + version in one or two releases after Boost 1.80 ([#676](https://github.com/boostorg/gil/issues/676)) + + + Added + + - GSoC 2020: Added Perona-Malik anisotropic diffusion algorithm + ([PR#500](https://github.com/boostorg/gil/pull/500)) + - GSoC 2020: Added histogram class and related functionality + ([PR#499](https://github.com/boostorg/gil/pull/499)) + - GSoC 2020: Added histogram equalization feature ([PR#514](https://github.com/boostorg/gil/pull/514)) + - GSoC 2020: Added histogram matching algorithm ([PR#515](https://github.com/boostorg/gil/pull/515)) + - GSoC 2020: Added ability to stack images either horizontally + (`hstack`) or + vertically (`vstack`) + ([PR#506](https://github.com/boostorg/gil/pull/506)) + - GSoC 2020: Added adaptive histogram equalization algorithm + ([PR#516](https://github.com/boostorg/gil/pull/516)) + - GSoC 2020: Added Standard Hough Transform and circle rasterization + ([PR#512](https://github.com/boostorg/gil/pull/512)) + - GSoC 2020: Added Bresenham's algorithm for line rasterization + ([PR#512](https://github.com/boostorg/gil/pull/512)) + - GSoC 2021: Added rotation of image by arbitrary angle around + its center ([PR#565](https://github.com/boostorg/gil/pull/565)) + - GSoC 2021: Added rasterization support for ellipse based on + "An Efficient Ellipse-Drawing Algorithm" by Jerry + Van Aken ([PR#585](https://github.com/boostorg/gil/pull/585)) + - Added `image` + constructor from compatible view ([PR#520](https://github.com/boostorg/gil/pull/520)) + - Added inverse function for affine `matrix3x2` + ([PR#527](https://github.com/boostorg/gil/pull/527)) + - Added standard morphological transformations ([PR#541](https://github.com/boostorg/gil/pull/541)) + - Added `for\_each\_pixel` + overload for `any\_image` + ([PR#648](https://github.com/boostorg/gil/pull/648)) + - Added C++17 polymorphic memory resource typedefs for `image` class ([PR#529](https://github.com/boostorg/gil/pull/529)) + + Changed + + - **BREAKING:** The required minimum + C++ version is changed from from C++11 to C++14. Currently, + large parts of GIL still compile with a C++11 compiler. However, + there is no guarantee that it stays that way, and any compilers + that do not support at least C++14 are considered unsupported + as of now. + - **BREAKING:** `any\_color\_converted\_view()` is deprecated and will be + removed in the next release. Use `color\_converted\_view()` instead, which provides the + same feature. + - **BREAKING:** `apply\_operation` + for `any\_image` + is deprecated and will be removed in the next release. Use + `variant2::visit` instead, which provides + the same feature. ([PR#656](https://github.com/boostorg/gil/pull/656)) + - Moved numeric extension to core ([PR#573](https://github.com/boostorg/gil/pull/573)) + - Added support for C++17's `` + ([PR#636](https://github.com/boostorg/gil/pull/636)) The availability of the `std::filesystem` + is detected automatically, unless the `BOOST\_GIL\_IO\_USE\_BOOST\_FILESYSTEM` + macro is defined that forces the preference of the Boost.Filesystem. + - Renamed `pixel\_multiply\_t` + to `pixel\_multiplies\_t` + and `pixel\_divide\_t` + to `pixel\_divides\_t` + ([PR#655](https://github.com/boostorg/gil/pull/655)) + - Renamed `io/dynamic\_io\_new.hpp` + to `io/detail/dynamic.hpp` ([PR#653](https://github.com/boostorg/gil/pull/653)) + - Moved function `construct\_matched` + into `boost::gil::detail` + namespace as it was only used by other implementation details + ([PR#653](https://github.com/boostorg/gil/pull/653)) + - Made `packed\_pixel` + trivially copyable and assignable ([PR#679](https://github.com/boostorg/gil/pull/679)) + - Replace deprecated libtiff v4.3 typedefs with C99 fixed-size + integers ([PR#685](https://github.com/boostorg/gil/pull/685)) + + Removed + + - **BREAKING:** Removed support + for GCC 5 ([PR#572](https://github.com/boostorg/gil/pull/572)) + - Removed deprecated.hpp ([PR#627](https://github.com/boostorg/gil/pull/627)) + + Fixed + + - Fixed conversion from RGB to HSL ([PR#505](https://github.com/boostorg/gil/pull/505)) + - Fixed conversion from RGB to signed CMYK ([PR#522](https://github.com/boostorg/gil/pull/522)) + - Removed unnecessary numeric cast in hsv.hpp ([PR#530](https://github.com/boostorg/gil/pull/530)) + - Fixed default constructor for `homogeneous\_color\_base` + for reference pixel elements ([PR#542](https://github.com/boostorg/gil/pull/542)) + - Fixed returning reference to local temporary object in `subchroma\_image\_view` ([PR#556](https://github.com/boostorg/gil/pull/556)) + - Added missing header guards in diffusion.hpp ([PR#568](https://github.com/boostorg/gil/pull/568)) + - Fixed `any\_image\_view<>::const\_t` + ([PR#526](https://github.com/boostorg/gil/pull/526)) + - Fixed C++20 incompatibilities in I/O extensions ([PR#617](https://github.com/boostorg/gil/pull/617)) + - Ensured all examples build without errors ([PR#628](https://github.com/boostorg/gil/pull/628)) + - Fixed `convolve\_2d` + for images with `float32\_t` + channel model ([PR#577](https://github.com/boostorg/gil/pull/577)) + - Fixed `for\_each\_pixel` + for non-1d iterable views ([PR#621](https://github.com/boostorg/gil/pull/621)) + - Fixed: `is\_equal\_to\_sixteen` + in PNG I/O was less-than test ([PR#650](https://github.com/boostorg/gil/pull/650)) + - Re-allow `devicen\_t` + with two components ([PR#654](https://github.com/boostorg/gil/pull/654)) It was unintentionally removed + in Boost 1.72 + - Fixed memory leak in `image` + class for empty dimensions ([PR#649](https://github.com/boostorg/gil/pull/649)) + + Acknowledgements + + - Cypre55, Samuel Debionne, Mike-Devel, Edward Diener, Peter + Dimov, Omar Emara, Dhruva Gole, Nicolas Herry, Eugene K, Avinal + Kumar, Gaurav Kumar, Marco Langer, Pranam Lashkari, Mateusz + Łoskot, Giovanni Mascellani, Debabrata Mandal, Gopi Krishna + Menon, René Ferdinand Rivera Morell, Felix Morgner, Harshit + Pant, Paul92, André Schröder, Scramjet911, Siddharth, Dirk + Stolle, Prathamesh Tagore, theroyn, Olzhas Zhumabek +* [Histogram](/libs/histogram/): + + + Fixed segfault in `indexed` + when trying to iterate over histogram with axes of zero size (physical + or logical) under certain conditions + + Removed previously deprecated API + + - class `accumulators::thread\_safe`: + use `accumulators::count` + - Methods `accumulators::sum::large` + and `accumulators::sum::small`: + use `accumulators::sum::large\_part` + and `accumulators::sum::small\_part` + - Type alias `algorithm::reduce\_option`: + use `algorithm::reduce\_command` + - Template function `axis::traits::static\_options`: + use `axis::traits::get\_options` + - Template function `axis::traits::static\_is\_inclusive`: + use `axis::traits::is\_inclusive` + - Type alias `indexed::range\_iterator`: + use `indexed::iterator` + - Type alias `indexed::accessor::reference`: + use `indexed::accessor::const\_reference` +* [Iterator](/libs/iterator/): + + + For C++11 and later, added support for perfect forwarding of values + written to `function\_output\_iterator`. + ([PR#73](https://github.com/boostorg/iterator/pull/73)) + + Added protection against writing to `function\_output\_iterator` + a result of dereferencing another `function\_output\_iterator`. +* [JSON](/libs/json/): + + + Added non-const `value::at` + overloads. + + Added the ability to manually choose endianness of the platform. + + Added `string::subview()` + overload. + + Fixed segfault in `array::erase(it)`. + + Fixed low performance of `serialize` + on libc++. + + Fixed ambigious conversion to `std::string\_view` + on GCC 8. + + Fixed parsing on big-endian platforms. + + Fixed handling of comment after trailing comma. +* [LEAF](/libs/leaf/): + + + API breaking change: throw leaf::exception(....) now becomes leaf::throw\_exception(....) + + Fixed a bug in support for a rare build configuration (exception + handling enabled, diagnostics disabled) + + Using nullptr instead of 0 throughout + + Fixed pedantic warnings +* [Locale](/libs/locale/): + + + Deprecated support for C++03 and earlier, C++11 will be required + in the next release + + Provide `-sICU\_LINK\_LOCALE` + as a temporary replacement for `-sICU\_LINK` which is incompatible + with Boost.Regex. `-sICU\_LINK\_LOCALE` and `-sICU\_LINK` + are deprecated and will be replaced by `ICU\_\*\_NAME` + options to be compatible with Boost.Regex + + Fix UB/assertion failure in the ICU `collator` + implementation when transforming empty strings + + Fix some issues related to visibility of classes in shared libraries + (Unix only) + + Fix compatibility with C++20 mode + + Fix compatibility with `BOOST\_USE\_WINDOWS\_H` + + Fix build failures due to missing includes + + Handle or suppress many warnings which makes the build log cleaner +* [Log](/libs/log/): + + + Bug fixes: + + - Fixed binding incorrect local address in UDP socket-based + `syslog\_backend` + when IPv6 address is used for the syslog server. ([#181](https://github.com/boostorg/log/issues/181)) + - Added a workaround for a [bug](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105857) + in libstdc++ from gcc 11.2. When `max\_size\_decor` + was used on a formatting stream, `std::codecvt::do\_length` + incorrectly accessed the input buffer and caused a buffer overflow. + + See [changelog](/libs/log/doc/html/log/changelog.html) + for more details. +* [Math](/libs/math/): + + + **Deprecated C++11 support**: from 2023 + we will require C++14 as a minimum standard. This will mean GCC-5 + or MSVC-14.1 as a minimal requirement. + + Add `constexpr` fma support, + see [734](https://github.com/boostorg/math/pull/734). + + Add support for the Chatterjee Correlation Coefficient, see [770](https://github.com/boostorg/math/pull/770). + + Added support for the logarithm of the PDF for all the distributions. + + Improve support for building with no exception or RTTI support. + + Some minor bug fixes for [sub 1]F[sub 1] corner cases, see [778](https://github.com/boostorg/math/pull/778). +* [Multiprecision](/libs/multiprecision/): + + + **Mark C++11 support as deprecated**: + from 2023 we will move to requiring C++14 as a minimum standard level. + That will drop support for GCC versions prior to 5 and MSVC prior + to 14.1. + + Fix conflict between `boost/cstdfloat.hpp` + and this library. + + Clean up lots of gcc and clang warnings. + + Fix input streaming of composite types (complex, interval rational) + where there is a trailing delimeter in the stream and no whitespace. + + Fix `constexpr` integer + square root where the input is 1, 2 or 3. + + Add missing `#include` + of `` to float128.hpp. + + Correct 2-arg constructor for class `number` + to prevent ambiguity in some cases. + + Correct and make more consistent behaviour of divide-by-zero in gmp.hpp. +* [Multi-index Containers](/libs/multi_index/): + + + Maintenance work. +* [Nowide](/libs/nowide/): + + + Major performance improvement for Bulk I/O with files + + `basic\_filebuf`: Fix + wrong return value of `sync` + when `fflush` failed + + `basic\_filebuf`: Fix + possible undefined behavior in a corner case when nothing was actually + written but buffer is in "write" mode + + `basic\_filebuf`: Limit + putback of characters (i.e. `pbackfail`) + only allowing putback of buffered characters (may be only 1 character) +* [Optional](/libs/optional/): + + + Added specializations for `std::hash>`. This is a breaking change + for programs that define such specializations themselves. For more + details see [specs](/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___std__hash_specializations.html#reference_std_hash_spec). +* [STLInterfaces](/libs/stl_interfaces/): + + + Fix [#53](https://github.com/boostorg/stl_interfaces/issues/53): "missing 'typename' prior to dependent + type name 'C::const\_iterator'" + + Fix [#54](https://github.com/boostorg/stl_interfaces/issues/54): "Concept check fails on .data() of + a view on contiguous iterator\_interface instantiations" + + New additions to make it easy to write views and view adaptors that + work like, and interoperate with, the ones in the standard library: + + - Add workalikes for C++23's `std::bind\_back()` and `std::range\_adaptor\_closure` + for pre-C++23 code. + - Add templates `closure` + and `adaptor` + to make writing view adaptors easier, following the examples + in [P2387](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2387r3.html). +* [System](/libs/system/): + + + When an `error\_code` + is converted to `std::error\_code` + and then back to `error\_code`, + the original is now restored, if possible. + + Reworked the conversion from `error\_category` + to `std::error\_category` to avoid the one-time + allocation that shows up on leak checkers. + + Added a constructor that allows replacing the source location of + an `error\_code`, and + a corresponding `assign`. + + Added a converting constructor to `result`. +* [Unordered](/libs/unordered/): + Major update: + + + [Refactor](/libs/unordered/doc/html/unordered.html#buckets_fast_closed_addressing_implementation) + internal implementation to be dramatically faster + + Allow `final` `Hasher` and `KeyEqual` + objects + + Update documentation, adding benchmark graphs and notes on the new + internal data structures +* [Utility](/libs/utility/): + + + In `string\_view`/`string\_ref`, fixed `max\_size` returning incorrect value. + ([#91](https://github.com/boostorg/utility/issues/91)) + + Removed `noexcept` specifier + from `string\_view::compare` + as it may throw on some input arguments. ([#94](https://github.com/boostorg/utility/issues/94)) + + In `string\_view`/`string\_ref`, added support for calling + `substr` with no arguments. + ([#96](https://github.com/boostorg/utility/issues/96)) + + Added `string\_view::contains` + methods that were introduced in C++23. ([#93](https://github.com/boostorg/utility/issues/93)) + + In `string\_view`, added + asserts in `remove\_prefix`/`remove\_suffix` methods to enforce + the precondition that the prefix/suffix length does not exceed the + string view size. The previous (undocumented) behavior of silently + clamping the prefix/suffix length is deprecated and will be removed + in a future release. ([#92](https://github.com/boostorg/utility/issues/92)) +* [Wave](/libs/wave/): + Fixed bugs: + + + [#24](https://github.com/boostorg/wave/issues/24): Line numbers wrong after conditional section + + [#160](https://github.com/boostorg/wave/issues/160): one test fails with error C2660 and error C2440 under + msvc /permissive- mode + + [#161](https://github.com/boostorg/wave/issues/161): BOOST\_WAVE\_THROW\_NAME\_CTX does not result in a context + callback and always throws + + [#162](https://github.com/boostorg/wave/issues/162): When Boost headers are included in the preprocessed + translation unit, Wave fails in boost/integer.hpp(99) + +### Updated Tools + + +* [Build](/tools/build/): + + + Includes release of [B2 + version 4.9.2](/tools/build/doc/html/#_version_4_9_2). + +### Compilers Tested + Boost's primary test compilers are: + + Boost's primary test compilers are: + + + +* Linux: + + + Clang: 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 12.0.0, 13.0.0, 14.0.0 + + Clang, C++11: 3.4, 11.0.0, 13.0.0, 14.0.0 + + Clang, C++14: 3.5, 3.6, 3.7, 3.8, 3.9, 4.0, 5.0, 12.0.0, 13.0.0, + 14.0.0 + + Clang, C++17: 6.0.1, 7.0.0, 8.0.0, 9.0.0, 10.0.0, 11.0.0, 12.0.0, + 13.0.0, 14.0.0 + + Clang, C++20: 11.0.0, 12.0.0, 13.0.0, 14.0.0 + + GCC: 4.6.3, 11, 12 + + GCC, C++11: 4.7.3, 4.8.5, 11, 12 + + GCC, C++14: 5.4.0, 6.4.0, 7.3.0, 8.0.1, 9.1.0, 11, 12 + + GCC, C++17: 7.3.0, 8.0.1, 9.1.0, 11, 12 + + GCC, C++20: 8.0.1, 9.1.0, 10, 11, 12 +* OS X: + + + Apple Clang: 11.0.3 + + Apple Clang, C++11: 11.0.3 + + Apple Clang, C++14: 11.0.3 + + Apple Clang, C++17: 11.0.3 + + Apple Clang, C++20: 11.0.3 +* Windows: + + + Visual C++: 10.0, 11.0, 12.0, 14.0, 14.1, 14.2, 14.3 + +### Acknowledgements + Marshall Clow, Michael Caisse and Glen Fernandes managed this release. + + + + + + + + + + + + diff --git a/users/index.html b/users/index.html new file mode 100644 index 0000000..03f643e --- /dev/null +++ b/users/index.html @@ -0,0 +1,159 @@ +--- +title: Boost Background Information +copyright: Beman Dawes 2005. +revised: +--- + + +Boost Background Information + + + +Boost Background Information +============================ + +Why should an organization use Boost? +------------------------------------- + + +In a word, *Productivity*. Use of high-quality + libraries like Boost speeds initial development, results in + fewer bugs, reduces reinvention-of-the-wheel, and cuts + long-term maintenance costs. And since Boost libraries tend to + become de facto or de jure standards, many programmers are + already familiar with them. + + +Ten of the Boost libraries are included in the [C++ Standard Library's TR1](http://open-std.org/jtc1/sc22/wg21/docs/library_technical_report.html), and so are + slated for later full standardization. More Boost libraries are + in the pipeline for [TR2](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1810.html). Using Boost libraries gives an + organization a head-start in adopting new technologies. + + +Many organization already use programs implemented with + Boost, like Adobe [Acrobat Reader 7.0](http://www.adobe.com/products/acrobat/readermain.html). + + +Who else is using Boost? +------------------------ + + +See the [Who's Using Boost + page](/users/uses.html) for a sampling. We don't know the exact numbers, but a + release gets around 100,000 downloads from SourceForge, and + that is only one of several distribution routes. + + +What do others say about Boost? +------------------------------- +> +> "...one of the most highly regarded and expertly designed +> C++ library projects in the world." +> +> — [Herb Sutter](http://www.gotw.ca/) and [Andrei Alexandrescu](http://en.wikipedia.org/wiki/Andrei_Alexandrescu), [C++ Coding Standards](http://safari.awprofessional.com/?XmlId=0321113586) +> +> +> +> +> "Item 55: Familiarize yourself with Boost." +> +> — [Scott Meyers](http://www.aristeia.com/), [Effective C++, 3rd Ed.](http://my.safaribooksonline.com/0321334876) +> +> +> +> +> "The obvious solution for most programmers is to use a +> library that provides an elegant and efficient platform +> independent to needed services. Examples are BOOST..." +> +> — [Bjarne Stroustrup](http://www.research.att.com/~bs/), [Abstraction, libraries, and efficiency in +> C++](http://www.research.att.com/~bs/abstraction.pdf) +> +> +> + + +How do users get support? +------------------------- + + +For relatively straightforward support needs, users rely on + the [mailing lists](/community/groups.html). One of + the advantages of Boost is the responsiveness of other users + and Boost developers. + + +What about license issues? +-------------------------- + + +Boost has its own [license](license.html), + developed with help from the Harvard Law School. The [Boost license polices](license.html) encourage both + commercial and non-commercial use, and the Boost license is not + related to the GPL or other licenses - that are sometimes seen + as business unfriendly. + + +What about other intellectual property issues? +---------------------------------------------- + + +The Boost libraries tend to be new, fresh, and creative + designs. They are not copies, clones, or derivations of + proprietary libraries. Boost has a firm policy to respect the + IP rights of others. The development of Boost libraries is + publicly documented via the mailing lists and version control + repository. The source code has been inspected by many, many + knowledgeable programmers. Each Boost file has a copyright + notice and license information. IP issues have been reviewed by + the legal teams from some of the corporations which use Boost, + and in some cases these lawyers have been kind enough to give + Boost feedback on IP issues. There are no guarantees, but those + factors all tend to reduce IP risk. + + +Why would anyone give away valuable software for free? +------------------------------------------------------ + + +Businesses and other organizations often prefer to have code + developed, maintained, and improved in the open source + community when it does not contain technology specific to their + application domain, because it allows them to focus more + development resources on their core business. + + +Individuals contribute for the technical challenge, to hone + their technical skills, for the sense of community, as part of + their graduate school programs, as a way around geographic + isolation, to enhance their employment opportunities, and as + advertisements for their consulting services. There are + probably as many reasons as there are individuals. Some of the + apparently individual contributions come from employees of + support companies with contracts from businesses or other + organizations who have an interest in seeing that a library is + well-maintained. + + +Who pays Boost's expenses? +-------------------------- + + +Boost doesn't really have any expenses! All the + infrastructure is contributed by supporters, such as the + [Open Systems + Lab](http://www.osl.iu.edu/) at Indiana University, [SourceForge](http://sourceforge.net/), + [Boost Consulting](http://www.boost-consulting.com/), [MetaCommunications](http://www.meta-comm.com/), and the individuals, + companies, and other organizations who run the regression + tests. Borland, HP, Intel, and Microsoft have contributed + compilers. And hundreds, or even thousands, of programmers + contribute their time. That's what makes Boost possible. + + + + + + + + + diff --git a/users/license.html b/users/license.html new file mode 100644 index 0000000..4657f38 --- /dev/null +++ b/users/license.html @@ -0,0 +1,342 @@ +--- +title: Boost Software License +copyright: Joe Coder 2004 - 2006. Beman Dawes, Daniel Frey, David Abrahams, 2003-2004. Rene Rivera 2004-2005. +revised: +--- + + +Boost Software License + + + +Boost Software License +====================== + +* [License text](../LICENSE_1_0.txt) +* [Introduction](#Introduction) +* [History](#History) +* [Rationale](#Rationale) +* [FAQ](#FAQ) +* [Transition](#Transition) +* [Acknowledgements](#Acknowledgements) + + +Introduction +------------ + + +The [Boost Software License](../LICENSE_1_0.txt) + specifies the terms and conditions of use for all Boost + libraries and tools. + + +History +------- + + +As Boost grew, it became unmanageable for each Boost file to + have its own license. Users complained that each license needed + to be reviewed, and that reviews were difficult or impossible + if Boost libraries contained many different licenses. Boost + moderators and maintainers spent excessive time dealing with + license issues. Boost developers often copied existing licenses + without actually knowing if the license wording met legal + needs. + + +To clarify these licensing issues, the Boost moderators + asked for help from the [Berkman Center for Internet & Society](http://cyber.law.harvard.edu) + at Harvard Law School, Cambridge, Massachusetts, USA. It was requested that a + single Boost license be developed that met the traditional + requirements that Boost licenses, particularly: + + +* Must be simple to read and understand. +* Must grant permission without fee to copy, use and modify + the software for any use. +* Must require that the license appear with all copies + [including redistributions] of the software source code. +* Must not require that the license appear with executables + or other binary uses of the library. +* Must not require that the source code be available for + execution or other binary uses of the library. + + +Additionally, other common open source licenses were studied + to see what additional issues were being treated, and additions + representing good legal practice were also requested. The + result is the [Boost Software + License](../LICENSE_1_0.txt): +``` +``` + +Rationale +--------- + + +The following rationale was provided by Devin Smith, the + lawyer who wrote the Boost Software License. It has been edited + slightly for brevity. Editorial additions are shown in square + brackets. + + +### Benefit of Common Software License + + +If one of Boost's goals is to ease use and adoption of the + various libraries made available by Boost, it does make sense + to try to standardize the licenses under which the libraries + are made available to users. (I make some recommendations about + a possible short-form license below.) + + +[Standardizing the license will not] necessarily address the + issue of satisfying corporate licensees. Each corporation will + have its own concerns, based on their own experiences with + software licensing and distribution and, if they're careful, + will want to carefully review each license, even if they've + been told that they're all standard. I would expect that, + unless we're remarkably brilliant (or lucky) in drafting the + standard Boost license, the standard license won't satisfy the + legal departments of all corporations. I imagine that some + will, for instance, absolutely insist that licensors provide a + warranty of title and provide indemnification for third-party + intellectual property infringement claims. Others may want + functional warranties. (If I were advising the corporations, I + would point out that they're not paying anything for the code + and getting such warranties from individual programmers, who + probably do not have deep pockets, is not that valuable anyway, + but other lawyers may disagree.) + + +But this can be addressed, not by trying to craft the + perfect standard license, but by informing the corporations + that they can, if they don't like the standard license, + approach the authors to negotiate a different, perhaps even + paid, license. + + +One other benefit of adopting a standard license is to help + ensure that the license accomplishes, from a legal perspective, + what the authors intend. For instance, many of the [original] + licenses for the libraries available on boost.org do not + disclaim the warranty of title, meaning that the authors could, + arguably, be sued by a user if the code infringes the rights of + a third party and the user is sued by that third party. I think + the authors probably want to disclaim this kind of + liability. + + +### Short-Form License + + +Without in anyway detracting from the draft license that's + been circulated [to Boost moderators], I'd like to propose an + alternative "short-form" license that Boost could have the + library authors adopt. David [Abrahams] has expressed a desire + to keep things as simple as possible, and to try to move away + from past practice as little as possible, and this is my + attempt at a draft. + + +This license, which is very similar to the BSD license and + the MIT license, should satisfy the Open Source Initiative's + Open Source Definition: (i) the license permits free + redistribution, (ii) the distributed code includes source code, + (iii) the license permits the creation of derivative works, + (iv) the license does not discriminate against persons or + groups, (v) the license does not discriminate against fields of + endeavor, (vi) the rights apply to all to whom the program is + redistributed, (vii) the license is not specific to a product, + and (viii) the license is technologically neutral (i.e., it + does not [require] an explicit gesture of assent in order to + establish a contract between licensor and licensee). + + +This license grants all rights under the owner's copyrights + (as well as an implied patent license), disclaims all liability + for use of the code (including intellectual property + infringement liability), and requires that all subsequent + copies of the code [except machine-executable object code], + including partial copies and derivative works, include the + license. + + +FAQ +--- + + +How should Boost + programmers apply the license to source and header + files? Add a comment based on + the following template, substituting appropriate text for the + italicized portion: +``` + +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE\_1\_0.txt or copy at +// https://www.boost.org/LICENSE\_1\_0.txt) + +``` + +Please leave an empty line before and after the above + comment block. It is fine if the copyright and license messages + are not on different lines; in no case there should be other + intervening text. Do not include "All rights reserved" + anywhere. + + +Other ways of licensing source files have been considered, + but some of them turned out to unintentionally nullify legal + elements of the license. Having fixed language for referring to + the license helps corporate legal departments evaluate the + boost distribution. Creativity in license reference language is + strongly discouraged, but judicious changes in the use of + whitespace are fine. + + +How should the + license be applied to documentation files, instead? +Very similarly to the way it is + applied to source files: the user should see the very same text + indicated in the template above, with the only difference that + both the local and the web copy of LICENSE\_1\_0.txt should be + linked to. Refer to the HTML source code of this page in case + of doubt. + + +How should Boost + programmers maintain the copyright messages? +Copyright is only claimed for changes + meeting a certain threshold of originality. Therefore, the copyright + message only covers expressions of creativity. It is up to authors of + changes to add themselves to the copyright message if they so decide. + Typically, new claimant is added when someone takes over maintenance + of a library or new version of an existing library is developed. + In principle, do not ever remove previous copyright claims - + just add new claims and/or claimants. + + +How is the Boost + license different from the [GNU General Public License (GPL)](https://opensource.org/licenses/gpl-license.php)? +The Boost license permits the creation + of derivative works for any use with + no legal requirement to release your source code. Other + differences include Boost not requiring reproduction of + copyright messages for object code redistribution, and the fact + that the Boost license is not "viral": if you distribute your + own code along with some Boost code, the Boost license applies + only to the Boost code (and modified versions thereof); you are + free to license your own code under any terms you like. The GPL + is also much longer, and thus may be harder to understand. + + +Why the phrase + "machine-executable object code generated by a source language + processor"? To distinguish + cases where we do not require reproduction of the copyrights + and license, such as object libraries, shared libraries, and + final program executables, from cases where reproduction is + still required, such as distribution of self-extracting + archives of source code or precompiled header files. More + detailed wording was rejected as not being legally necessary, + and reducing readability. + + +Why is the + "disclaimer" paragraph of the license entirely in + uppercase? Capitalization of + these particular provisions is a US legal mandate for consumer + protection. (Diane Cabell) + + +Does the copyright + and license cover interfaces too? The conceptual interface to a library isn't + covered. The particular representation expressed in the header + is covered, as is the documentation, examples, test programs, + and all the other material that goes with the library. A + different implementation is free to use the same logical + interface, however. Interface issues have been fought out in + court several times; ask a lawyer for details. + + +Why doesn't the + license prohibit the copyright holder from patenting the + covered software? No one who + distributes their code under the terms of this license could + turn around and sue a user for patent infringement. (Devin + Smith) + + +Boost's lawyers were well aware of patent provisions in + licenses like the GPL and CPL, and would have included such + provisions in the Boost license if they were believed to be + legally useful. + + +Why doesn't the + copyright message say "All rights reserved"? +Devin Smith says "I don't think it + belongs in the copyright notice for anything (software, + electronic documentation, etc.) that is being licensed. It + belongs in books that are sold where, in fact, all rights + (e.g., to reproduce the book, etc.) are being reserved in the + publisher or author. I think it shouldn't be in the BSD + license." + + +Do I have to + copyright/license trivial files? Even a test file that just contains an empty + `main()` should have a copyright. Files without + copyrights make corporate lawyers nervous, and that's a barrier + to adoption. The more of Boost is uniformly copyrighted and + licensed, the less problem people will have with mounting a + Boost release CD on a corporate server. + + +Can I use the Boost + license for my own projects outside Boost? Sure; there are no restrictions on the use of the + license itself. + + +[![Open Source (OSI) Logo](https://opensource.org/trademarks/opensource/web/opensource-110x95.png)](https://opensource.org/docs/definition.php)Is the Boost + license "[Open Source](https://opensource.org/docs/osd)"? Yes. The [Open Source Initiative](https://opensource.org/) certified the + [Boost Software License 1.0](https://opensource.org/licenses/bsl1.0.html) in early + 2008. + + +Transition +---------- + + +To ease the transition of the code base towards the new + common license, several people decided to give a [blanket + permission](/doc/libs/release/more/blanket-permission.txt) for all their contributions to use the new + license. This hopefully helps maintainers to switch to the new + license once the list contains enough names without asking over + and over again for each change. Please consider adding your + name to the list. + + +Acknowledgements +---------------- + + +Dave Abrahams led the Boost effort to develop better + licensing. The legal team was led by [Diane Cabell](https://cyber.harvard.edu/people/dcabell), Director, Clinical Programs, + [Berkman Center for Internet & Society](https://cyber.harvard.edu/), + Harvard Law School. Devin Smith, attorney, [Nixon Peabody + LLP](https://www.nixonpeabody.com/), wrote the Boost License. Eva Chan, Harvard Law School, + contributed analysis of Boost issues and drafts of various + legal documents. Boost members reviewed drafts of the license. + Beman Dawes wrote this web page. + + + + + + + + + diff --git a/users/memoriam.html b/users/memoriam.html new file mode 100644 index 0000000..7cb3d54 --- /dev/null +++ b/users/memoriam.html @@ -0,0 +1,26 @@ +--- +title: Boost Memoriam +copyright: 2020 Glen Fernande. +revised: +--- + + +Boost Memoriam + + + +Boost Memoriam +============== + +* [![-](people/beman_dawes_small.jpg)Beman Dawes](memoriam/beman_dawes.html) +* + + + + + + + + + + diff --git a/users/memoriam/beman_dawes.html b/users/memoriam/beman_dawes.html new file mode 100644 index 0000000..0d8a459 --- /dev/null +++ b/users/memoriam/beman_dawes.html @@ -0,0 +1,101 @@ +--- +title: Beman Dawes +copyright: +revised: +--- + + +Beman Dawes + + + +In Memoriam: Beman Dawes +======================== + +![-](beman_dawes.jpg) + + +[Beman + Dawes](https://www.boost.org/users/people/beman_dawes.html) passed on December first, 2020 at the age of 81 years. + He was survived by his wife Sonda. + + **Dave Abrahams:** Beman Dawes was my friend, + inspiration, and collaborator. He was a living demonstration + that collegial respect and kindness are fundamental to getting + great results. His idea for Boost blossomed into a unique + community, inventing the art of library design. RIP. + + +**Emil Dotchevski:** I talked with Beman many + times. He was always kind, and through my experience with him I + am honored to have had a chance to work with this brilliant + member of our community. He should be celebrated as one of those + little-known figures who nonetheless has had an enormous positive + impact on the world through his work. + + +**Stefanus Du Toit:** Just learned about the + passing of Beman Dawes. Beman was a truly positive and + inspirational influence on the C++ community. A rare example of + someone putting contribution to the greater good above all else. + You'll be missed, Beman. + + +**Howard Hinnant:** He was a friend. He was a + giant. He will be missed. + + +**Jon Kalb:** Beman Dawes' legacy in the C++ + community is matched by few. As a leader in the process of + defining the C++ standard, he recognized a need for high quality, + non-proprietary libraries. He saw not only that these were few, + but that there was no environment to create new ones. He created + the Boost Libraries with the goal of making high quality, + peer-reviewed, open source libraries available for every C++ + programmer and as an environment to develop candidate libraries + for standardization. He then helped launch BoostCon (now C++Now), + as a way of nurturing the community that made Boost possible and + appreciates high quality C++ libraries. He did all of this with + such humor, humility, generosity, and grace that he will be much + missed. + + +**Robert Ramey:** I do not think C++ would be + where it is today without the extraordinary accomplishments of + two particular people. Beman Dawes and David Abrahams. Before + their efforts in the late nineties C++ was suffering from a lack + of libraries which made it noncompetitive with alternatives being + promoted at the time - most notably Java and C#. These + alternatives were funded by they biggest of the big. The future + must have looked bleak to C++ fans at the time. I was looking for + an alternative to C++ when I came upon Boost with a number of + portable and indispensable libraries. Boost was founded by these + two gentleman (of complimentary personalities). That changed + everything for me - and I'm sure I'm not the only one. And I + suspect that it was responsible for changing the future of C++. + To those who believe that one man can't make a big difference - I + offer this counter example. + + +**Herb Sutter:** Beman was one of the most + important and influential C++ experts in the world, and made his + many contributions mostly behind the scenes, so that many C++ + developers have likely never heard of him. I and everyone else + who have ever benefited from any of the standardized STL, Boost, + C++Now, std::filesystem, C++98/11/14/17, and more - so, really, + most people who have ever used C++ - all owe Beman a debt of + gratitude. We miss him greatly. + + +If you’ve thoughts about Beman that you’d like to share, + please send them to + [memorial@boost.org](mailto:memorial@boost.org). + + + + + + +Copyright © 2020 Glen Fernadnes + + diff --git a/users/memoriam/beman_dawes.jpg b/users/memoriam/beman_dawes.jpg new file mode 100644 index 0000000..cdb8952 Binary files /dev/null and b/users/memoriam/beman_dawes.jpg differ diff --git a/users/news/a_special_note_for_boost_1_52_0_and_higher.html b/users/news/a_special_note_for_boost_1_52_0_and_higher.html new file mode 100644 index 0000000..75a35c8 --- /dev/null +++ b/users/news/a_special_note_for_boost_1_52_0_and_higher.html @@ -0,0 +1,75 @@ +--- +title: A Special Note for Boost 1.52.0 and Higher +copyright: Rene Rivera 2006-2007. +revised: +--- + + +A Special Note for Boost 1.52.0 and Higher + + + + + + +A Special Note for Boost 1.52.0 and Higher +========================================== + +A Special Note for Boost 1.52.0 and Higher +------------------------------------------ + + +November 6th, 2012 09:27 GMT + + + Starting with Boost 1.52.0, the `boost::result\_of` + component defaults to an implementation that uses the C++11 `decltype` + keyword to deduce the return type of callables on compilers with strong `decltype` support. As `boost::result\_of` + is a key piece of library infrastructure, we at Boost have found this change + to be moderately disruptive. You should be aware of the issue when making the + decision to upgrade from an older version of Boost. + +### Why + the Change Was Made +`boost::result\_of` has been changed to use `decltype` to make it more consistent with `std::result\_of` + (when sufficient compiler support is available). Also, the use of `decltype` should help to improve compile times + and increase the accuracy of the type computation. + + +### Who + is Affected + If you use a compiler with sufficiently bug-free `decltype` + support (including [N3276](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3276.pdf)), + then you will get the new behavior. At the time of writing (Nov 4, 2012), the + only compiler in that category is Clang 3.1, but as other compilers improve, + this will change. + + +### What + Problems Can the Change Cause? + The use of `decltype` in `result\_of` can result in a different type + being computed than with the now-obsolete TR1 `result\_of` + protocol. This will often be the case for incorrectly written TR1-style function + objects that misreport their result types. This is unfortunately too common. + But it can even happen for some correctly written function objects. + + +### Where + Can I Learn More? + Please see the documentation for [`boost::result\_of`](https://www.boost.org/doc/libs/1_52_0/libs/utility/utility.htm#result_of) + to understand the differences between TR1 `result\_of` + and `decltype` `result\_of`, + and to find out how you can write your code to accommodate both. + + + + + + + + + + + + + diff --git a/users/news/asio_formal_review_begins.html b/users/news/asio_formal_review_begins.html new file mode 100644 index 0000000..4395e53 --- /dev/null +++ b/users/news/asio_formal_review_begins.html @@ -0,0 +1,39 @@ +--- +title: asio Formal Review Begins +copyright: Rene Rivera 2006-2007. +revised: +--- + + +asio Formal Review Begins + + + + + + +asio Formal Review Begins +========================= + +asio Formal Review Begins +------------------------- + + +December 10th, 2006 12:00 GMT + + + The review will run until Friday December 23rd. The [Boost.Asio](http://asio.sourceforge.net/) + library is intended for programmers using C++ for systems programming, where + access to operating system functionality such as networking is often required. + + + + + + + + + + + + diff --git a/users/news/boost_has_moved_downloads_to_jfr.html b/users/news/boost_has_moved_downloads_to_jfr.html new file mode 100644 index 0000000..07ad27e --- /dev/null +++ b/users/news/boost_has_moved_downloads_to_jfr.html @@ -0,0 +1,50 @@ +--- +title: Boost has moved downloads to JFrog Artifactory +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Boost has moved downloads to JFrog Artifactory + + + + + + +Boost has moved downloads to JFrog Artifactory +============================================== + +Boost has moved downloads to JFrog Artifactory +---------------------------------------------- + + +April 29th, 2021 18:00 GMT + + + The service that Boost uses to serve up its releases, Bintray.com is being retired + by JFrog on the 1st of May. Fortunately for Boost, they have a new service, called + JFrog.Arifactory, which we have transitioned to. + + For the users of Boost, the only difference is that there is a new URL to download + releases and snapshots. + + Instead of: + you should use + to retrieve boost releases. + + Note: The pre-1.64 Boost releases are still available via Sourceforge. + + Thank you to JFrog for all your past and current support. + + + + + + + + + + + + diff --git a/users/news/boost_locale_security_notice.html b/users/news/boost_locale_security_notice.html new file mode 100644 index 0000000..dba1530 --- /dev/null +++ b/users/news/boost_locale_security_notice.html @@ -0,0 +1,53 @@ +--- +title: Boost.Locale security notice +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Boost.Locale security notice + + + + + + +Boost.Locale security notice +============================ + +Boost.Locale security notice +---------------------------- + + +February 1st, 2013 10:08 GMT + + + Boost.Locale library in Boost 1.48 to 1.52 including has a security flaw. + +`boost::locale::utf::utf\_traits` + accepted some invalid UTF-8 sequences. + + Applications that used these functions for UTF-8 input validation could expose + themselves to security threats as invalid UTF-8 sequece would be considered as + valid. + + This bug is fixed in upcoming Boost 1.53. + + For more details see: [#7743](https://svn.boost.org/trac/boost/ticket/7743) + + Users who can't upgrade to the latest versions may apply the following patch + to fix the problem. + + + + + + + + + + + + + + diff --git a/users/news/index.html b/users/news/index.html new file mode 100644 index 0000000..6f00eb4 --- /dev/null +++ b/users/news/index.html @@ -0,0 +1,25 @@ +--- +title: Boost News +copyright: Rene Rivera 2006. +revised: +--- + + +Boost News + + + + + +Boost News +========== + + + + + + + + + + diff --git a/users/news/old_compilers.html b/users/news/old_compilers.html new file mode 100644 index 0000000..5f8c93f --- /dev/null +++ b/users/news/old_compilers.html @@ -0,0 +1,106 @@ +--- +title: Old compilers +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Old compilers + + + + + + +Old compilers +============= + +Old compilers +------------- + + +August 5th, 2013 20:00 GMT + + + I just sent an email to user list asking if anyone is using old compilers, I'll + repeat it here: + +> +> +> Hello all, +> +> +> +> +> There has been some discussion on the development list about dropping all support +> for old C++ compilers. This will allow us to remove a lot of workarounds and +> simplify the code but before doing so it's a good idea to find out if anyone +> is still using them. Using boost with these compilers will cause a compile +> error in the config library (you can work round that using a custom configuration, +> but it's unlikely you'll be able to get much to work). The currently proposed +> versions for removing support are: +> +> +> +> * Digital Mars 8.40 and earlier +> * Visual C++ 7.0 and earlier +> * GCC 3.2 and earlier +> * Intel C++ 5.0 and earlier +> +> +> +> Which is, I think, a very cautious list. There's also a good chance that we +> might want to remove support for Borland C++ 5.x. Is there anyone still using +> those compilers? +> +> +> +> +> Just to be clear, this doesn't mean we'll be fully supporting all compilers +> later than these. Old compilers such as Visual C++ 7.1 and gcc 3.4 won't have +> a config error and we won't deliberately remove support, but support will be +> patchy. Many libraries (especially new ones) don't support those compilers, +> and we also don't have any formal testing for them, so if a new change breaks +> something, it might not be noticed. +> +> +> +> +> If you are still using compilers which are a little more recent than the ones +> listed above, it might still be worth mentioning in case we consider removing +> support for them in the future. +> +> +> +> +> Thanks in advance for any response, +> +> +> +> +> Daniel James +> +> +> +> +**Update:** I had a few responses, but none were + opposed to this change, so I made it in trunk a little while ago. It should be + included in the next release. + + There was some concern that we would remove support for later compilers (e.g. + Visual Studio 2008, aka. Visual C++ 9.0). We have no such plans, this change + is only for very old compilers. As always support across Boost libraries is not + uniform, but most library authors do try to support as wide a range of compilers + as is feasible. + + + + + + + + + + + + diff --git a/users/news/website_1_0_launch.html b/users/news/website_1_0_launch.html new file mode 100644 index 0000000..4880eb2 --- /dev/null +++ b/users/news/website_1_0_launch.html @@ -0,0 +1,41 @@ +--- +title: Website 1.0 Launch +copyright: Rene Rivera 2006-2007. +revised: +--- + + +Website 1.0 Launch + + + + + + +Website 1.0 Launch +================== + +Website 1.0 Launch +------------------ + + +March 28th, 2008 16:00 GMT + + + After much work the new Boost web site is here. Like all software the site has + bugs, so be gentle and reports problems in the bug tracker. Much thanks to the + Boost community for the help in testing, criticizing, and writing. But I especially + appreciate all the work Daniel James to translate content without which the web + site would be a much emptier place. + + + + + + + + + + + + diff --git a/users/people.html b/users/people.html new file mode 100644 index 0000000..e5b2f36 --- /dev/null +++ b/users/people.html @@ -0,0 +1,108 @@ +--- +title: Boost People +copyright: Beman Dawes, David Abrahams, 1998-2005. Rene Rivera 2004-2005. +revised: +--- + + +Boost People + + + +Boost People +============ + +* [![-](people/dave_abrahams_small.jpg)Dave + Abrahams](people/dave_abrahams.html) +* [![-](people/darin_adler_small.jpg)Darin Adler](people/darin_adler.html) +* [![-](people/ed_brey_small.jpg)Ed Brey](people/ed_brey.html) +* [![-](people/herve_bronnimann_small.jpg)Hervé + Brönnimann](people/herve_bronnimann.html) +* [![-](people/fernando_cacciola_small.jpg)Fernando + Cacciola](people/fernando_cacciola.html) +* [![-](people/greg_colvin_small.jpg)Greg Colvin](people/greg_colvin.html) +* [![-](people/beman_dawes_small.jpg)Beman Dawes](people/beman_dawes.html) +* [![-](people/joel_de_guzman_small.jpg)Joel de + Guzman](people/joel_de_guzman.html) +* [![-](people/peter_dimov_small.jpg)Peter Dimov](people/peter_dimov.html) +* [![-](people/pavol_droba_small.jpg)Pavol Droba](people/pavol_droba.html) +* [![-](people/glen_fernandes_small.jpg)Glen + Fernandes](people/glen_fernandes.html) +* [![-](people/eric_friedman_small.jpg)Eric + Friedman](people/eric_friedman.html) +* [![-](people/ronald_garcia_small.jpg)Ron Garcia](people/ronald_garcia.html) +* [![-](people/jeff_garland_small.jpg)Jeff + Garland](people/jeff_garland.html) +* [![-](people/jan_gaspar_small.jpg)Jan Gaspar](people/jan_gaspar.html) +* [![-](people/doug_gregor_small.jpg)Doug Gregor](people/doug_gregor.html) +* [![-](people/ralf_w_grosse_kunstleve_sm.jpg)Ralf W + Grosse-Kunstleve](people/ralf_w_grosse_kunstleve.html) +* [![-](people/aleksey_gurtovoy_small.jpg)Aleksey + Gurtovoy](people/aleksey_gurtovoy.html) +* [![-](people/kevlin_henney_small.jpg)Kevlin + Henney](people/kevlin_henney.html) +* [![-](people/howard_hinnant_small.jpg)Howard + Hinnant](people/howard_hinnant.html) +* [![-](people/hubert_holin_small.jpg)Hubert + Holin](people/hubert_holin.html) +* [![-](people/andreas_huber_small.jpg)Andreas + Huber](people/andreas_huber.html) +* [![-](people/nicolai_josuttis_small.jpg)Nicolai + Josuttis](http://www.josuttis.com) +* [![-](people/jaakko_jarvi_small.jpg)Jaakko + Järvi](people/jaakko_jarvi.html) +* [![-](people/hartmut_kaiser_small.jpg)Hartmut + Kaiser](people/hartmut_kaiser.html) +* [![-](people/vesa_karvonen_small.jpg)Vesa + Karvonen](people/vesa_karvonen.html) +* [![-](people/william_kempf_small.jpg)William + Kempf](people/william_kempf.html) +* [![-](people/samuel_krempp_small.jpg)Samuel + Krempp](people/samuel_krempp.html) +* [![-](people/dietmar_kuehl_small.jpg)Dietmar + Kühl](people/dietmar_kuehl.html) +* [![-](people/liequan_lee_small.jpg)Lie-Quan + Lee](people/liequan_lee.html) +* [![-](people/joaquin_lopez_small.jpg)Joaquín M + López Muñoz](people/joaquin_lopez.html) +* [![-](people/john_maddock_small.jpg)John + Maddock](people/john_maddock.html) +* [![-](people/mat_marcus_small.jpg)Mat Marcus](people/mat_marcus.html) +* [![-](people/jens_maurer_small.jpg)Jens Maurer](people/jens_maurer.html) +* [![-](people/paul_mensonides_small.jpg)Paul + Mensonides](people/paul_mensonides.html) +* [![-](people/paul_moore_small.jpg)Paul Moore](people/paul_moore.html) +* [![-](people/mac_murrett_small.jpg)Mac Murrett](people/mac_murrett.html) +* [![-](people/thorsten_ottosen_small.jpg)Thorsten + Ottosen](people/thorsten_ottosen.html) +* [![-](people/antony_polukhin_small.jpg)Antony Polukhin](people/antony_polukhin.html) +* [![-](people/gary_powell_small.jpg)Gary Powell](people/gary_powell.html) +* [![-](people/vladimir_prus_small.jpg)Vladimir + Prus](people/vladimir_prus.html) +* [![-](people/robert_ramey_small.jpg)Robert + Ramey](people/robert_ramey.html) +* [![-](people/rene_rivera.jpg)René + Rivera](people/rene_rivera.html) +* [![-](people/mark_rodgers_small.jpg)Mark + Rodgers](people/mark_rodgers.html) +* [![-](people/gennadiy_rozental_small.jpg)Gennadiy + Rozental](people/gennadiy_rozental.html) +* [![-](people/jeremy_siek_small.jpg)Jeremy Siek](people/jeremy_siek.html) +* [![-](people/jonathan_turkanis_small.jpg)Jonathan + Turkanis](people/jonathan_turkanis.html) +* [![-](people/daryle_walker_small.jpg)Daryle + Walker](people/daryle_walker.html) +* [![-](people/anthony_williams.jpg)Anthony + Williams](people/anthony_williams.html) +* [![-](people/thomas_witt_small.jpg)Thomas Witt](people/thomas_witt.html) +* + + + + + + + + + + diff --git a/users/people/_template_.html b/users/people/_template_.html new file mode 100644 index 0000000..e45abac --- /dev/null +++ b/users/people/_template_.html @@ -0,0 +1,26 @@ +--- +title: John Doe +copyright: Rene Rivera 2007. +revised: +--- + + +John Doe + + + +John Doe +======== + +![-](dave_abrahams.jpg) +[John Doe](mailto:jane.doe@?.?) is + ... + + + + + + + + + diff --git a/users/people/aleksey_gurtovoy.html b/users/people/aleksey_gurtovoy.html new file mode 100644 index 0000000..161d8f6 --- /dev/null +++ b/users/people/aleksey_gurtovoy.html @@ -0,0 +1,42 @@ +--- +title: Aleksey Gurtovoy +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Aleksey Gurtovoy + + + +Aleksey Gurtovoy +================ + +Aleksey Gurtovoy is an entrepreneur, engineer and product + builder. He is the original author of the Boost Metaprogramming + Library and a co-author, with + [David Abrahams](./dave_abrahams.html), of + [*C++ Template Metaprogramming*](https://www.amazon.com/Template-Metaprogramming-Concepts-Techniques-Beyond/dp/0321227255). + + +He has been working with C++ since 1993, and holds a M.S. + degree in computer science from Krasnoyarsk State Technical + University, Russia. + + +You can contact him by email at + [agurtovoy@acm.org](mailto:agurtovoy@acm.org) + and follow him on Twitter at + [@agurtovoy](https://twitter.com/agurtovoy). + + + + + + +Copyright © 2004-2016 Aleksey Gurtovoy + + + + + diff --git a/users/people/aleksey_gurtovoy.jpg b/users/people/aleksey_gurtovoy.jpg new file mode 100644 index 0000000..fd49271 Binary files /dev/null and b/users/people/aleksey_gurtovoy.jpg differ diff --git a/users/people/aleksey_gurtovoy2.jpg b/users/people/aleksey_gurtovoy2.jpg new file mode 100644 index 0000000..22b7d71 Binary files /dev/null and b/users/people/aleksey_gurtovoy2.jpg differ diff --git a/users/people/aleksey_gurtovoy_small.jpg b/users/people/aleksey_gurtovoy_small.jpg new file mode 100644 index 0000000..b4cffe0 Binary files /dev/null and b/users/people/aleksey_gurtovoy_small.jpg differ diff --git a/users/people/andreas_huber.html b/users/people/andreas_huber.html new file mode 100644 index 0000000..ce6164c --- /dev/null +++ b/users/people/andreas_huber.html @@ -0,0 +1,42 @@ +--- +title: Andreas Huber +copyright: Rene Rivera 2007. +revised: 2009-01-17 22:14:11 +0100 +--- + + +Andreas Huber + + + +Andreas Huber +============= + +![-](andreas_huber.jpg) + Andreas Huber is currently on a parental leave. At former + companies Andreas has been developing systems ranging from PC + control software for machinery to custom-made CRM applications. + In recent years, more and more of his professional work has + shifted to the .NET platform (C# and C++/CLI). + + +In his spare time Andreas still enjoys to program in + standard C++, which is how [Boost.Statechart](/doc/libs/release/libs/statechart/doc/index.html) + came into being. His other hobbies include swimming, camping, + hiking and traveling. + + +Andreas lives in Zurich, Switzerland with his wife Ruth and + son Marius. + + + + + + +Copyright © 2006-2009 Andreas Huber Dönni + + + + + diff --git a/users/people/andreas_huber.jpg b/users/people/andreas_huber.jpg new file mode 100644 index 0000000..61cd8cf Binary files /dev/null and b/users/people/andreas_huber.jpg differ diff --git a/users/people/andreas_huber_small.jpg b/users/people/andreas_huber_small.jpg new file mode 100644 index 0000000..eb20d67 Binary files /dev/null and b/users/people/andreas_huber_small.jpg differ diff --git a/users/people/anonymous.jpg b/users/people/anonymous.jpg new file mode 100644 index 0000000..108f6fc Binary files /dev/null and b/users/people/anonymous.jpg differ diff --git a/users/people/anonymous_small.jpg b/users/people/anonymous_small.jpg new file mode 100644 index 0000000..aaa75c7 Binary files /dev/null and b/users/people/anonymous_small.jpg differ diff --git a/users/people/anthony_williams.html b/users/people/anthony_williams.html new file mode 100644 index 0000000..e47954a --- /dev/null +++ b/users/people/anthony_williams.html @@ -0,0 +1,39 @@ +--- +title: Anthony Williams +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Anthony Williams + + + +Anthony Williams +================ + +![-](anthony_williams_large.jpg) Anthony Williams is the Managing Director of + [Just Software Solutions Ltd](http://www.justsoftwaresolutions.co.uk). He spends most of + his time developing custom software for clients. + + +Anthony is a member of the BSI C++ Standards Panel, and is + author or co-author of many of the thread-related proposals for + C++09, as well as several articles for magazines such as Dr + Dobb's Journal and C++ Users Journal. + + +He is married, with two children, and lives in the far West + of Cornwall, UK, where he can see the sea from his office. + + + + +Revised $Date:$ + +Copyright © 2008 Anthony Williams + + + + + diff --git a/users/people/anthony_williams.jpg b/users/people/anthony_williams.jpg new file mode 100644 index 0000000..034b929 Binary files /dev/null and b/users/people/anthony_williams.jpg differ diff --git a/users/people/anthony_williams_large.jpg b/users/people/anthony_williams_large.jpg new file mode 100644 index 0000000..33fff45 Binary files /dev/null and b/users/people/anthony_williams_large.jpg differ diff --git a/users/people/antony_polukhin.html b/users/people/antony_polukhin.html new file mode 100644 index 0000000..9b7e5a8 --- /dev/null +++ b/users/people/antony_polukhin.html @@ -0,0 +1,49 @@ +--- +title: Antony polukhin +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Antony polukhin + + + +Antony Polukhin +=============== + +![-](antony_polukhin.jpg)Antony Polukhin is a software developer. + + +That's it. + + +Well, if we go to his website [apolukhin.github.io](https://apolukhin.github.io/) we would notice that he represents + Russia in ISO WG21 C++. We would also note that he has authored many Boost + libraries and maintains even more. + + +He also works for Yandex.Taxi Ltd., helps Russian speaking people with + C++ standardization proposals, continues to contribute to the open source + and to the C++ language in general. + + +Looks like he also authored a bunch of books and articles, gave quite a lot of talks in different languages but mostly on the same programming language. + + +Oh, he also does consulting on C++. It's on the web site! + + +He is married, with two children. + + + + +Revised $Date:$ + +Copyright © 2020 Antony Polukhin + + + + + diff --git a/users/people/antony_polukhin.jpg b/users/people/antony_polukhin.jpg new file mode 100644 index 0000000..8f22eef Binary files /dev/null and b/users/people/antony_polukhin.jpg differ diff --git a/users/people/antony_polukhin_small.jpg b/users/people/antony_polukhin_small.jpg new file mode 100644 index 0000000..be9cc52 Binary files /dev/null and b/users/people/antony_polukhin_small.jpg differ diff --git a/users/people/beman_dawes.html b/users/people/beman_dawes.html new file mode 100644 index 0000000..ded0e33 --- /dev/null +++ b/users/people/beman_dawes.html @@ -0,0 +1,55 @@ +--- +title: Beman Dawes +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Beman Dawes + + + +Beman Dawes +=========== + +![-](beman_dawes.jpg) Beman + Dawes was a software developer from Virginia in the United + States and the founder of boost.org and BoostCon (now known as + C++Now). + + +He was the author of the StreetQuick® geographic atlas + library used by digital map publishers to help people get + really, really, lost. + + +He wrote his first computer program 50 years ago, and did + not mourn the passing of [bi-quinary](http://www.mta.ca/~amiller/ibm650/ibm650.htm) arithmetic. + + +Beman was a voting member of the ISO C++ Standards + Committee for twenty eight years, and chaired the Library Working + Group for five years. + + +He enjoyed travel, sailing, hiking, and biking. + + +Beman passed away on December first, 2020 and was survived by + his wife Sonda. + + +[His + memoriam.](https://www.boost.org/users/memoriam/beman_dawes.html) + + + + + + +Copyright © 2004 Beman Dawes + + + + + diff --git a/users/people/beman_dawes.jpg b/users/people/beman_dawes.jpg new file mode 100644 index 0000000..b6d4756 Binary files /dev/null and b/users/people/beman_dawes.jpg differ diff --git a/users/people/beman_dawes_small.jpg b/users/people/beman_dawes_small.jpg new file mode 100644 index 0000000..9ed895a Binary files /dev/null and b/users/people/beman_dawes_small.jpg differ diff --git a/users/people/darin_adler.html b/users/people/darin_adler.html new file mode 100644 index 0000000..a47898f --- /dev/null +++ b/users/people/darin_adler.html @@ -0,0 +1,64 @@ +--- +title: Darin Adler +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Darin Adler + + + +Darin Adler +=========== + +![-](darin_adler.jpg) Darin + Adler has been programming computers since 1976. He loves to do + it. + + +His first major professional experience was at [Apple Computer](http://apple.com). In 1988 + he led the team that rewrote the Macintosh Finder in C++. + Before that project was completed, he was shanghaied to be the + technical lead for the System 7 project (these days they would + call it "Mac OS 7"). The group he formed to help him do that, + the Blue Meanies, is still a [legend](http://www.cupertino.de/pages/archiv/EasterEggs/BlueMeanies.html) in the Apple community. + + +Since Apple, Darin has worked at [General + Magic](http://www.generalmagic.com) as an architect of the [Magic Cap](http://www.google.com/search?q=Magic+Cap) OS, used the moniker [Bent Spoon Software](http://bentspoon.com) + to do consulting, and helped start Eazel, a company that worked + to make Linux easier to use and developed the Nautilus + graphical shell for [GNOME](http://www.gnome.org). Since 1997, he has worked from his home + in Los Angeles, CA, collaborating with clients and coworkers in + other locations. + + +He prefers to use and program Macintosh computers with C++. + But work on the GNOME project is best accomplished with a + non-Macintosh PC. (That's why Darin is sitting in front of two + computers.) The other people working on the GNOME project don't + like C++, so he's writing a lot of C code these days. + + +The picture shows him hard at work with his C++ guru, his + daughter Sophia. + + +He has hobbies and stuff but you don't want to read about + that here. + + +You can contact him by sending mail to [darin@bentspoon.com](mailto:darin@bentspoon.com). + + + + + + +Copyright © 2001 Darin Adler + + + + + diff --git a/users/people/darin_adler.jpg b/users/people/darin_adler.jpg new file mode 100644 index 0000000..8a17394 Binary files /dev/null and b/users/people/darin_adler.jpg differ diff --git a/users/people/darin_adler_small.jpg b/users/people/darin_adler_small.jpg new file mode 100644 index 0000000..b9eb06e Binary files /dev/null and b/users/people/darin_adler_small.jpg differ diff --git a/users/people/daryle_walker.html b/users/people/daryle_walker.html new file mode 100644 index 0000000..306c027 --- /dev/null +++ b/users/people/daryle_walker.html @@ -0,0 +1,29 @@ +--- +title: Daryle Walker +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Daryle Walker + + + +Daryle Walker +============= + +![-](daryle_walker.jpg) + Daryle Walker, born and raised in the United States since 1973, + needs to write a fuller biography. + + + + + + +Copyright © 2001 Daryle Walker + + + + + diff --git a/users/people/daryle_walker.jpg b/users/people/daryle_walker.jpg new file mode 100644 index 0000000..848b260 Binary files /dev/null and b/users/people/daryle_walker.jpg differ diff --git a/users/people/daryle_walker_small.jpg b/users/people/daryle_walker_small.jpg new file mode 100644 index 0000000..0a58410 Binary files /dev/null and b/users/people/daryle_walker_small.jpg differ diff --git a/users/people/dave_abrahams.html b/users/people/dave_abrahams.html new file mode 100644 index 0000000..92736bf --- /dev/null +++ b/users/people/dave_abrahams.html @@ -0,0 +1,38 @@ +--- +title: Dave Abrahams +copyright: David Abrahams 1998-2006. Rene Rivera 2004-2005. +revised: +--- + + +Dave Abrahams + + + +Dave Abrahams +============= + +![-](dave_abrahams.jpg) +[Dave Abrahams](mailto:dave@boost-consulting.com) is a founding member and + moderator of Boost, and an active member of the wider + open-source community. He has been an ANSI/ISO C++ + committee member since 1996, and has worked in the + software industry since 1988. In 2001 He + founded [Boost Consulting](http://www.boostpro.com) (now Boostpro + Computing) , a company dedicated to providing + professional support and development services for the + Boost C++ libraries and associated tools. + + +Dave often shows up at C++ standards committee meetings on a + bicycle. He lives in Somerville, Massachusetts with his + family. + + + + + + + + + diff --git a/users/people/dave_abrahams.jpg b/users/people/dave_abrahams.jpg new file mode 100644 index 0000000..4efa95c Binary files /dev/null and b/users/people/dave_abrahams.jpg differ diff --git a/users/people/dave_abrahams_small.jpg b/users/people/dave_abrahams_small.jpg new file mode 100644 index 0000000..919c0a1 Binary files /dev/null and b/users/people/dave_abrahams_small.jpg differ diff --git a/users/people/dietmar_kuehl.html b/users/people/dietmar_kuehl.html new file mode 100644 index 0000000..ec5e8e8 --- /dev/null +++ b/users/people/dietmar_kuehl.html @@ -0,0 +1,53 @@ +--- +title: Dietmar Kuehl +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Dietmar Kuehl + + + +Dietmar Kuehl +============= + +![-](dietmar_kuehl.jpg) + Dietmar Kuehl (the "ue" is actually a "u-umlaut", ie. one of + those funny German characters which has two dots above it) was + fork(2)ed in early 1968. + + +He visited school more or less successfully from 1973 to + 1987. In 1987 he started to study at the Technical University + of Berlin. He finished his studies in 1997 with a Diplom + (roughly the German equivalent of a masters) in Mathematics. + His [thesis](http://www.dietmar-kuehl.de/generic-graph-algorithms.pdf) was "Design Pattern for the + Implementation of Graph Algorithms"; strike the "Design + Pattern" and put in "Generic" somehow to get an idea of the + main topic. + + +Since 1997 he has worked as consultant for a small company + called Claas Solutions (the "aa" is no typo), mainly working + for major German banks. Since late 1995 Dietmar Kuehl has been + one of the moderators of the newsgroup [comp.lang.c++.moderated](news:comp.lang.c++.moderated). He is active on the C++ + Standards committee. + + +Email: [dietmar\_kuehl@yahoo.com](mailto:dietmar_kuehl@yahoo.com) + + +Home page:  + + + + + + +Copyright © 2000 Dietmar Kuehl + + + + + diff --git a/users/people/dietmar_kuehl.jpg b/users/people/dietmar_kuehl.jpg new file mode 100644 index 0000000..c97f54e Binary files /dev/null and b/users/people/dietmar_kuehl.jpg differ diff --git a/users/people/dietmar_kuehl_small.jpg b/users/people/dietmar_kuehl_small.jpg new file mode 100644 index 0000000..e3b7bf6 Binary files /dev/null and b/users/people/dietmar_kuehl_small.jpg differ diff --git a/users/people/doug_gregor.html b/users/people/doug_gregor.html new file mode 100644 index 0000000..1c0c66a --- /dev/null +++ b/users/people/doug_gregor.html @@ -0,0 +1,47 @@ +--- +title: Doug Gregor +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Doug Gregor + + + +Doug Gregor +=========== + +![-](doug_gregor.jpg) Doug + is a post-doctoral research fellow in the [Open Systems Lab](http://www.osl.iu.edu), + part of the [Computer Science](http://www.cs.indiana.edu) department at [Indiana University, + Bloomington.](http://www.iub.edu). + + +As a generic programming zealot, his search for the One True + Generic Language has seen him through the trials of the + [Generic Programming Group](http://www.cs.rpi.edu/research/gpg/), and [many](http://www.boost.org) [diversions](http://www.open-std.org/jtc1/sc22/wg21/). + + +When not hunched over in front of an [XEmacs](http://www.xemacs.org) window, + Doug looks to his wife Amy to help him navigate through the + daylight. Once there, he enjoys tennis and the occasional game + of paintball. + + +Email: dgregor -at- cs.indiana.edu + + +Home page: [`http://www.osl.iu.edu/~dgregor`](http://www.osl.iu.edu/~dgregor/) + + + + + + +Copyright © 2005 Doug Gregor + + + + + diff --git a/users/people/doug_gregor.jpg b/users/people/doug_gregor.jpg new file mode 100644 index 0000000..66fdd3b Binary files /dev/null and b/users/people/doug_gregor.jpg differ diff --git a/users/people/doug_gregor_small.jpg b/users/people/doug_gregor_small.jpg new file mode 100644 index 0000000..9955bc0 Binary files /dev/null and b/users/people/doug_gregor_small.jpg differ diff --git a/users/people/ed_brey.html b/users/people/ed_brey.html new file mode 100644 index 0000000..5f2f184 --- /dev/null +++ b/users/people/ed_brey.html @@ -0,0 +1,59 @@ +--- +title: Ed Brey +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Ed Brey + + + +Ed Brey +======= + +![-](ed_brey.jpg) Ed Brey + lives in Menomonee Falls, Wisconsin, a village outside of + Milwaukee. In the summertime, he likes to play tennis with his + wife, and in the winter, if there is enough snow, he likes to + go tobogganing or ice-skating. If it is not nice enough outside + for either of those, he plays on the piano. + + +Ed works at [Eaton Corporation](http://www.eaton.com) in Milwaukee. He started + working there as part of [Marquette University](http://www.mu.edu)'s engineering co-op + program. Upon graduation in 1995 from Marquette with a BS in + electrical and computer engineering, he was hired on full-time, + where he initially worked on firmware for industrial controls. + More recently, he has been working on a PC-based configuration + tool for industrial networks. Ed received his MS in computer + engineering in 2001 from [NTU](http://www.ntu.edu). + + +Ed has held programming as a pastime since his grade school + days, when he wrote a babysitting invoicing program. Soon + after, he wrote a game inspired by the TV game show + “Press Your Luck”. Ever since, programming + languages and concepts, along with finding ways to improve the + art and science of coding software, have always peeked his + interest. + + +Lastly, Ed has managed to retain his perspective. As fun as + computers and programming are, Ed's true loves in life are the + Lord Jesus whom he serves and his dear wife Beth. + + +Home page: + + + + + + +Copyright © 2002 Ed Brey + + + + + diff --git a/users/people/ed_brey.jpg b/users/people/ed_brey.jpg new file mode 100644 index 0000000..3a37894 Binary files /dev/null and b/users/people/ed_brey.jpg differ diff --git a/users/people/ed_brey_small.jpg b/users/people/ed_brey_small.jpg new file mode 100644 index 0000000..952dfc4 Binary files /dev/null and b/users/people/ed_brey_small.jpg differ diff --git a/users/people/eric_friedman.html b/users/people/eric_friedman.html new file mode 100644 index 0000000..c3c8005 --- /dev/null +++ b/users/people/eric_friedman.html @@ -0,0 +1,44 @@ +--- +title: Eric Friedman +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Eric Friedman + + + +Eric Friedman +============= + +![-](eric_friedman.jpg) + Eric Friedman is an undergraduate at Stanford University. Born + in 1984, he discovered programming at 10 and Boost at 17. He is + a Computer Science major, with interests in Political Science + and Arabic. + + +Eric is co-author of the [Variant library](/doc/libs/release/libs/variant/index.html) + and intends to author more. + + +He enjoys rap music, discussing politics, and, of course, + programming. + + +Though not starving, Eric is a college student and so + appreciates both spontaneous donations and internship + opportunities. He can be contacted at [ebf@users.sourceforge.net](mailto:ebf@users.sourceforge.net). + + + + + + +Copyright © 2003 Eric Friedman + + + + + diff --git a/users/people/eric_friedman.jpg b/users/people/eric_friedman.jpg new file mode 100644 index 0000000..1fecf0a Binary files /dev/null and b/users/people/eric_friedman.jpg differ diff --git a/users/people/eric_friedman_small.jpg b/users/people/eric_friedman_small.jpg new file mode 100644 index 0000000..eb76d06 Binary files /dev/null and b/users/people/eric_friedman_small.jpg differ diff --git a/users/people/fernando_cacciola.html b/users/people/fernando_cacciola.html new file mode 100644 index 0000000..1828553 --- /dev/null +++ b/users/people/fernando_cacciola.html @@ -0,0 +1,64 @@ +--- +title: Fernando Cacciola +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Fernando Cacciola + + + +Fernando Cacciola +================= + +![-](fernando_cacciola.jpg) +[Fernando Cacciola](mailto:fernando_cacciola@hotmail.com) has been programming since + 1984 when he got his hand on a Tandy Color Computer II for the + first time. He started with BASIC at the time, but quickly + moved to Assembly Language to get the most out of the Home + Computers of the time (from a Sinclair 1500 [Z80] to a + Commodore 64 [Motorola 6510]). + + +In 1990 he discovered the C programming language and started + to work as a professional programmer. In 1995 he discovered + C++, and during his long time employement in a company + producing CAD systems, the fields of Geometric Computing, + Computer Graphics, Image Processing and Numerics in + general. + + +He studied Biochemistry at the John F. Kennedy (Argentina) + University for 4+ years, but had to drop because of his + full-time job as a programmer. He would complete a CS degree if + he only had the time. + + +After 13 years of being an employed programmer (in just a + couple of companies), by the end of 2003, he became a + freelancer and founded SciSoft, a company specialized in + technically/scientifically-oriented software. + + +Currently he is an active developer of the [Computational Geometry + Algotithms Library (CGAL)](http://www.cgal.org/) and a member of the [IEEE Computer + Society](http://www.computer.org/), the [Association for Computing Machinery (ACM)](http://www.acm.org/) and + the [ACCU + community](http://www.accu.org/). + + +You are always welcome to visit Fernando's [home + page](http://fcacciola.50webs.com/). + + + + + + +Copyright © 2004 Fernando Cacciola + + + + + diff --git a/users/people/fernando_cacciola.jpg b/users/people/fernando_cacciola.jpg new file mode 100644 index 0000000..9c6d1fe Binary files /dev/null and b/users/people/fernando_cacciola.jpg differ diff --git a/users/people/fernando_cacciola_small.jpg b/users/people/fernando_cacciola_small.jpg new file mode 100644 index 0000000..b0bd455 Binary files /dev/null and b/users/people/fernando_cacciola_small.jpg differ diff --git a/users/people/gary_powell.html b/users/people/gary_powell.html new file mode 100644 index 0000000..ec5a388 --- /dev/null +++ b/users/people/gary_powell.html @@ -0,0 +1,41 @@ +--- +title: Gary Powell +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Gary Powell + + + +Gary Powell +=========== + +![-](gary_powell.jpg) Gary + Powell has been messing around with C++ since '87 when he + dreamed about adding his own operators to the language. Since + then he's been busy overloading everything in sight, and + working on bringing functional programming to C++. + + +He currently works for Sierra On-line a division of Havas + Interactive, a wholly owned subsidiary of Vivedi Universal of + France, as a game programmer + where he writes AI. + + +He can be reached at [gary.powell@sierra.com](mailto:gary.powell@sierra.com) but don't ask him + how to solve the riddle of the left handed troll. + + + + + + +Copyright © 2000 Gary Powell + + + + + diff --git a/users/people/gary_powell.jpg b/users/people/gary_powell.jpg new file mode 100644 index 0000000..349ad1c Binary files /dev/null and b/users/people/gary_powell.jpg differ diff --git a/users/people/gary_powell_small.jpg b/users/people/gary_powell_small.jpg new file mode 100644 index 0000000..6bb4e81 Binary files /dev/null and b/users/people/gary_powell_small.jpg differ diff --git a/users/people/gennadiy_rozental.html b/users/people/gennadiy_rozental.html new file mode 100644 index 0000000..2b79304 --- /dev/null +++ b/users/people/gennadiy_rozental.html @@ -0,0 +1,44 @@ +--- +title: Gennadiy Rozental +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Gennadiy Rozental + + + +Gennadiy Rozental +================= + +![-](gennadiy_rozental.jpg) + Gennadiy Rozental is a software developer from Ukraine, who now + lives in New Jersey, United States and work for Thomson + Financial in New York. He is married, with son and + daughter. + + +Gennadiy graduated from MIPT: Moscow Institute of Physics + and Technology with Master degree in computer science. Ever + since Gennadiy has been programming mostly in C++. + + +In his spare time he not only works on boost, but also enjoy + origami making. + + +You can contact him by sending mail to rogeeff at mail dot + com + + + + + + +Copyright © 2004 Gennadiy Rozental + + + + + diff --git a/users/people/gennadiy_rozental.jpg b/users/people/gennadiy_rozental.jpg new file mode 100644 index 0000000..625fbc0 Binary files /dev/null and b/users/people/gennadiy_rozental.jpg differ diff --git a/users/people/gennadiy_rozental_small.jpg b/users/people/gennadiy_rozental_small.jpg new file mode 100644 index 0000000..e024293 Binary files /dev/null and b/users/people/gennadiy_rozental_small.jpg differ diff --git a/users/people/glen_fernandes.html b/users/people/glen_fernandes.html new file mode 100644 index 0000000..47d8678 --- /dev/null +++ b/users/people/glen_fernandes.html @@ -0,0 +1,49 @@ +--- +title: Glen Fernandes +copyright: Glen Fernandes 2014. +revised: +--- + + +Glen Fernandes + + + + +Glen Fernandes +============== + +![glen fernandes](glen_fernandes.jpg) +[Glen Joseph Fernandes](http://linkedin.com/in/glenfern) is a C++ enthusiast + who has worked at Intel and Microsoft. + + +He is the author of the Boost + [Align](http://boost.org/libs/align) library, a + major contributor to the Boost [Smart + Pointers](https://boost.org/libs/smart_ptr/#history) and Core libraries, and has also contributed to + several other Boost libraries (including Mp11, Type Traits, + IO, Functional, Circular Buffer, Dynamic Bitset, Multi Array, + and more). + + +He is a contributor to the ISO C++ Standard and has at least + four features adopted for the new C++20 standard +([P0674R1](http://open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0674r1.html), +[P0653R2](http://open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0653r2.html), +[P1020R1](http://open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1020r1.html), +[P1357R1](http://open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1357r1.pdf)). + + +He lives with his wife Caroline and daughter Aeryn in the US, + graduated from the University of Sydney in Australia, and + before all that, lived in New Zealand. + + + + + + + + + diff --git a/users/people/glen_fernandes.jpg b/users/people/glen_fernandes.jpg new file mode 100644 index 0000000..1ea7f61 Binary files /dev/null and b/users/people/glen_fernandes.jpg differ diff --git a/users/people/glen_fernandes_small.jpg b/users/people/glen_fernandes_small.jpg new file mode 100644 index 0000000..7b08464 Binary files /dev/null and b/users/people/glen_fernandes_small.jpg differ diff --git a/users/people/greg_colvin.html b/users/people/greg_colvin.html new file mode 100644 index 0000000..a6bd654 --- /dev/null +++ b/users/people/greg_colvin.html @@ -0,0 +1,32 @@ +--- +title: Greg Colvin +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Greg Colvin + + + +Greg Colvin +=========== + +![-](greg_colvin.jpg) Dr. + Greg Colvin has been hacking happily since 1972. He is a member + of the ANSI/ISO C++ standards committee and a Principal Member + of Technical Staff with the Java Products Group at Oracle + Corporation. In his spare time he plays apocalyptic electric + blues guitar in his Colorado, USA home studio. + + + + + + +Copyright © 2000 Greg Colvin + + + + + diff --git a/users/people/greg_colvin.jpg b/users/people/greg_colvin.jpg new file mode 100644 index 0000000..8bde68f Binary files /dev/null and b/users/people/greg_colvin.jpg differ diff --git a/users/people/greg_colvin_small.jpg b/users/people/greg_colvin_small.jpg new file mode 100644 index 0000000..09ae51a Binary files /dev/null and b/users/people/greg_colvin_small.jpg differ diff --git a/users/people/hartmut_kaiser.html b/users/people/hartmut_kaiser.html new file mode 100644 index 0000000..a5364ce --- /dev/null +++ b/users/people/hartmut_kaiser.html @@ -0,0 +1,42 @@ +--- +title: Harmut Kaiser +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Harmut Kaiser + + + +Harmut Kaiser +============= + +![-](hartmut_kaiser.jpg) + After 15+ interesting years that Hartmut spent working in + industrial software development, he still tremendously enjoys + working with modern software development technologies and + techniques. His preferred field of interest is the software + development in the area of object-oriented and component-based + programming in C++ and its application in complex contexts, + such as for spatial information systems, internet based + applications and parser technologies. Hartmut enjoys using and + learning about modern C++ programming techniques, such as + template based generic and meta-programming and preprocessor + based meta-programming. + + +You can contact him by sending mail to: Hartmut.Kaiser [at] + gmail [dot] com + + + + + + +Copyright © 2006 Harmut Kaiser + + + + + diff --git a/users/people/hartmut_kaiser.jpg b/users/people/hartmut_kaiser.jpg new file mode 100644 index 0000000..8d6846d Binary files /dev/null and b/users/people/hartmut_kaiser.jpg differ diff --git a/users/people/hartmut_kaiser_small.jpg b/users/people/hartmut_kaiser_small.jpg new file mode 100644 index 0000000..5cabaf0 Binary files /dev/null and b/users/people/hartmut_kaiser_small.jpg differ diff --git a/users/people/herve_bronnimann.html b/users/people/herve_bronnimann.html new file mode 100644 index 0000000..b8d61c5 --- /dev/null +++ b/users/people/herve_bronnimann.html @@ -0,0 +1,38 @@ +--- +title: Hervé Brönnimann +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Hervé Brönnimann + + + +Hervé Brönnimann +================ + +![-](herve_bronnimann.jpg) + Hervé Brönnimann is an Assistant Professor at the + [Polytechnic + University](http://www.poly.edu) in Brooklyn, NY. His research deals with + computational geometry, algorithms, and implementation. Prior + to crossing the Atlantic, he was a researcher at INRIA, + participating in the development of the [CGAL library](http://www.cgal.org) for + geometric computation. + + +In Boost, he is one of the authors of the Interval library, + and of the Minmax library. + + + + + + +Copyright © 2004 Hervé Brönnimann + + + + + diff --git a/users/people/herve_bronnimann.jpg b/users/people/herve_bronnimann.jpg new file mode 100644 index 0000000..4e6af37 Binary files /dev/null and b/users/people/herve_bronnimann.jpg differ diff --git a/users/people/herve_bronnimann_small.jpg b/users/people/herve_bronnimann_small.jpg new file mode 100644 index 0000000..f995424 Binary files /dev/null and b/users/people/herve_bronnimann_small.jpg differ diff --git a/users/people/howard_hinnant.html b/users/people/howard_hinnant.html new file mode 100644 index 0000000..769b9d7 --- /dev/null +++ b/users/people/howard_hinnant.html @@ -0,0 +1,50 @@ +--- +title: Howard Hinnant +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Howard Hinnant + + + +Howard Hinnant +============== + +![-](howard_hinnant.jpg) + When Howard Hinnant is not monkeying around, he is a software + engineer for Apple and represents Apple on the C++ Standards + committee as Library Working Group Chairman.  Howard has + is also one of the co-authors / co-inventors of the rvalue + reference work for C++09 making move semantics and perfect + forwarding practical in C++.  In the past Howard was the + principal author of the CodeWarrior C++ library. + + +Howard is married with four children, four dogs (he really + isn't that fond of dogs), a rabbit, several exotic lizards with + the usual accompaniment of insects (which the lizards are + supposed to eat but find more entertaining to turn loose in the + house), um... let's see ... fish, wild mice (they eventually + kidnapped all the domesticated rodents), several dozen chickens + (no I'm not kidding)...  The neighbors are trying to turn + my property into a federally protected wildlife preserve.  + They've got a fighting chance ... the kids alone would + qualify. + + +When not sitting in front of his computer, Howard enjoys + snow skiing and ... more, snow skiing. + + + + + + +Copyright © 2000 Howard Hinnant + + + + + diff --git a/users/people/howard_hinnant.jpg b/users/people/howard_hinnant.jpg new file mode 100644 index 0000000..a63a446 Binary files /dev/null and b/users/people/howard_hinnant.jpg differ diff --git a/users/people/howard_hinnant_small.jpg b/users/people/howard_hinnant_small.jpg new file mode 100644 index 0000000..ec9c599 Binary files /dev/null and b/users/people/howard_hinnant_small.jpg differ diff --git a/users/people/hubert_holin.html b/users/people/hubert_holin.html new file mode 100644 index 0000000..895aea1 --- /dev/null +++ b/users/people/hubert_holin.html @@ -0,0 +1,51 @@ +--- +title: Hubert Holin +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Hubert Holin + + + +Hubert Holin +============ + +![-](hubert_holin.jpg) + Hubert Holin is a mathematician. He is currently a civil + servant of the french state (no longer indentured, but still + stuck). He has also worked as a developper in a small french + start-up , and as a math teacher in a private non-religious + higher-ed school. + + +His first programs were in assembly language/micro-code on + an Hewlett-Packard [HP 25](http://www.hpmuseum.org/hp25.htm) hand-held calculator (a marked + improvement over his father's use of binary-on-strips-of-paper + on some forgoten piece of metal...), back in the mists of time. + He is a Mac-using refugee of the Atari, and on a personal jihad + against The Evil Empire Of Computing ™. + + +Very much a Child of the World, he has lived in Europe, + Africa, the U.S.A., and is married with a chinese girl (with + whom he has both a daughter and a son). + + +Email: [Hubert.Holin@Bigfoot.com](mailto:Hubert.Holin@Bigfoot.com) + + +Home page: + + + + + + +Copyright © 2001 Hubert Holin + + + + + diff --git a/users/people/hubert_holin.jpg b/users/people/hubert_holin.jpg new file mode 100644 index 0000000..7533b9f Binary files /dev/null and b/users/people/hubert_holin.jpg differ diff --git a/users/people/hubert_holin_small.jpg b/users/people/hubert_holin_small.jpg new file mode 100644 index 0000000..40fd4b5 Binary files /dev/null and b/users/people/hubert_holin_small.jpg differ diff --git a/users/people/jaakko_jarvi.html b/users/people/jaakko_jarvi.html new file mode 100644 index 0000000..a55c185 --- /dev/null +++ b/users/people/jaakko_jarvi.html @@ -0,0 +1,38 @@ +--- +title: Jaakko Järvi +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Jaakko Järvi + + + +Jaakko Järvi +============ + +![-](jaakko_jarvi.jpg) + Jaakko Järvi is currently a researcher (Post doc) in the + [Open Systems + Lab](http://www.osl.iu.edu/) at Indiana University. + + +He's the author of the [Tuple Library](/doc/libs/release/libs/tuple/index.html) and + co-author of the [Lambda + Library.](/doc/libs/release/libs/lambda/index.html) + + +He can be reached at [jajarvi@cs.indiana.edu](mailto:jajarvi@cs.indiana.edu). + + + + + + +Copyright © 2003 Jaakko Järvi + + + + + diff --git a/users/people/jaakko_jarvi.jpg b/users/people/jaakko_jarvi.jpg new file mode 100644 index 0000000..6af42f3 Binary files /dev/null and b/users/people/jaakko_jarvi.jpg differ diff --git a/users/people/jaakko_jarvi_small.jpg b/users/people/jaakko_jarvi_small.jpg new file mode 100644 index 0000000..7fb5753 Binary files /dev/null and b/users/people/jaakko_jarvi_small.jpg differ diff --git a/users/people/jan_gaspar.html b/users/people/jan_gaspar.html new file mode 100644 index 0000000..034a50e --- /dev/null +++ b/users/people/jan_gaspar.html @@ -0,0 +1,46 @@ +--- +title: Jan Gaspar +copyright: Rene Rivera 2007. +revised: 2007-10-22 22:58:11 +0100 +--- + + +Jan Gaspar + + + +Jan Gaspar +========== + +![-](jan_gaspar.jpg) Jan + Gaspar is a software developer from Slovakia. He graduated at + the [Slovak + University of Technology](http://www.stu.sk) in Bratislava in 2000. He started + programming in C++ at the university and worked on several C++ + projects since then. He thinks C++ is still a useful language + although in the recent years his professional career moved more + towards Java. + + +At present he works for a UK based company [IG Index](http://www.igindex.co.uk) so you + are likely to meet him in the airspace between London and + Slovakia. + + +Jan is married and has one son. + + +You can contact him by sending an e-mail to jano\_gaspar at + yahoo dot com. + + + + + + +Copyright © 2007 Jan Gaspar + + + + + diff --git a/users/people/jan_gaspar.jpg b/users/people/jan_gaspar.jpg new file mode 100644 index 0000000..f7529a8 Binary files /dev/null and b/users/people/jan_gaspar.jpg differ diff --git a/users/people/jan_gaspar_small.jpg b/users/people/jan_gaspar_small.jpg new file mode 100644 index 0000000..21706be Binary files /dev/null and b/users/people/jan_gaspar_small.jpg differ diff --git a/users/people/jeff_garland.html b/users/people/jeff_garland.html new file mode 100644 index 0000000..c4c9bbd --- /dev/null +++ b/users/people/jeff_garland.html @@ -0,0 +1,46 @@ +--- +title: Jeff Garland +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Jeff Garland + + + +Jeff Garland +============ + +![-](jeff_garland.jpg) Jeff + Garland a software developer/consultant from sunny Phoenix, + Arizona USA (that's always UTC-7 since there's no DST in AZ). + He is the author of the [boost date-time + library](/doc/libs/release/doc/html/date_time.html) as well as a book on [representing software architecture](http://www.largescalesoftwarearchitecture.com). + + +Jeff has been distracted from finishing all those cool + features people want in date-time by running the [Boost Wiki](http://www.crystalclearsoftware.com/cgi-bin/boost_wiki/wiki.pl), serving as a review manager, + and a [Boost + Moderator](/community/moderators.html). + + +On the rare day that he's not in front of a computer from + morning till night you might find him out hiking, biking, or + skiing in Arizona's mountains and canyons with his wife and 2 + daughters. + + +Email: [jeff at crystalclearsoftware.com](mailto:jeff@crystalclearsoftware.com) + + + + + + +Copyright © 2005 Jeff Garland + + + + + diff --git a/users/people/jeff_garland.jpg b/users/people/jeff_garland.jpg new file mode 100644 index 0000000..e57a505 Binary files /dev/null and b/users/people/jeff_garland.jpg differ diff --git a/users/people/jeff_garland_small.jpg b/users/people/jeff_garland_small.jpg new file mode 100644 index 0000000..858150a Binary files /dev/null and b/users/people/jeff_garland_small.jpg differ diff --git a/users/people/jens_maurer.html b/users/people/jens_maurer.html new file mode 100644 index 0000000..808f191 --- /dev/null +++ b/users/people/jens_maurer.html @@ -0,0 +1,50 @@ +--- +title: Jens Maurer +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Jens Maurer + + + +Jens Maurer +=========== + +![-](jens_maurer.jpg) Jens + Maurer is a software developer from Germany who lives close to + Frankfurt/Main. He was born in 1973 and hasn't died yet. + + +He has worked for a multimedia company programming + home-banking applications, CGI scripts and Java applications. + He also helped program some simulation systems for long-term + decision support to aid businessmen in arguing about company + investments. + + +He is neither married nor does he have a girl friend, but + asked his colleagues to find one for him. + + +In his spare time, he likes visiting foreign countries but + dislikes getting there in uncomfortable airplane seats. On + random week-ends, he enjoys participating in historic dance + courses (without a costume, of course). Sometimes, he needs + fresh air and goes for a walk. + + +Email: [Jens.Maurer@gmx.net](mailto:Jens.Maurer@gmx.net) + + + + + + +Copyright © 2000 Jens Maurer + + + + + diff --git a/users/people/jens_maurer.jpg b/users/people/jens_maurer.jpg new file mode 100644 index 0000000..2dc21b4 Binary files /dev/null and b/users/people/jens_maurer.jpg differ diff --git a/users/people/jens_maurer_small.jpg b/users/people/jens_maurer_small.jpg new file mode 100644 index 0000000..3fd70cc Binary files /dev/null and b/users/people/jens_maurer_small.jpg differ diff --git a/users/people/jeremy_siek.html b/users/people/jeremy_siek.html new file mode 100644 index 0000000..1d6182a --- /dev/null +++ b/users/people/jeremy_siek.html @@ -0,0 +1,44 @@ +--- +title: Jeremy Siek +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Jeremy Siek + + + +Jeremy Siek +=========== + +![-](jeremy_siek.jpg) + Jeremy Siek is a Ph.D. student at Indiana Univ. + Bloomington. + + +He is the author of the Matrix Template Library (MTL), and + helped design the Generic Graph Component Library, which is now + the Boost Graph Library (BGL). + + +Once in a while Jeremy "comes up for air" and enjoys + fencing, hiking, skiing, and reading. He's also been spotted at + a few fightin' irish tailgaters (BYOB). + + +Jeremy has an intense fear for the ancient dark forests + where dusty decks thrive and devour programmers, places where + the light of abstraction has not yet reached. + + + + + + +Copyright © 2001 Jeremy Siek + + + + + diff --git a/users/people/jeremy_siek.jpg b/users/people/jeremy_siek.jpg new file mode 100644 index 0000000..2b8115c Binary files /dev/null and b/users/people/jeremy_siek.jpg differ diff --git a/users/people/jeremy_siek_small.jpg b/users/people/jeremy_siek_small.jpg new file mode 100644 index 0000000..3e4bfb9 Binary files /dev/null and b/users/people/jeremy_siek_small.jpg differ diff --git a/users/people/joaquin_lopez.html b/users/people/joaquin_lopez.html new file mode 100644 index 0000000..25cf5bd --- /dev/null +++ b/users/people/joaquin_lopez.html @@ -0,0 +1,44 @@ +--- +title: Joaquín M López Muñoz +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Joaquín M López Muñoz + + + +Joaquín M López Muñoz +===================== + +![-](joaquin_lopez.jpg) + Joaquín is a telecom engineer from the [Polytechnic University of + Madrid](http://www.upm.es). He currently works as an independent consultant in + a number of technological companies and startups. + Though actual programming is not one + of his job responsibilities, he still does some C++ for fun + when nobody's around. + + +Joaquín's professional career began with his first + exposure to a Dragon 32 (a Tandy TRS-80 clone) at the age of + 13, though at the time he probably was unaware of the future + impact of this event. He enjoys Mathematics, Logic and Latin; + his lower case interests include paper folding, compulsive + reading, writing, traveling and visiting all sorts of pubs + and restaurants. + You can contact him at [joaquin.lopezmunoz@gmail.com](mailto:joaquin.lopezmunoz@gmail.com). + + + + + + +Copyright © 2004-2020 Joaquín M López + Muñoz + + + + + diff --git a/users/people/joaquin_lopez.jpg b/users/people/joaquin_lopez.jpg new file mode 100644 index 0000000..bd36cac Binary files /dev/null and b/users/people/joaquin_lopez.jpg differ diff --git a/users/people/joaquin_lopez_small.jpg b/users/people/joaquin_lopez_small.jpg new file mode 100644 index 0000000..dc8bbf7 Binary files /dev/null and b/users/people/joaquin_lopez_small.jpg differ diff --git a/users/people/joel_de_guzman.html b/users/people/joel_de_guzman.html new file mode 100644 index 0000000..9b23429 --- /dev/null +++ b/users/people/joel_de_guzman.html @@ -0,0 +1,30 @@ +--- +title: Joel de Guzman +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Joel de Guzman + + + +Joel de Guzman +============== + +![-](joel_de_guzman.jpg)Joel got into electronics and programming in the 80s because almost everything in music, his first love, is becoming electronic and digital. Back then, he used to build his own guitars, effect boxes and synths. He enjoys playing distortion-laden rock guitar, composes and produces his own music in his home studio. + + +Joel de Guzman is the main author of the [Boost.Spirit Parser](https://www.boost.org/libs/spirit) library, the [Boost.Fusion](https://www.boost.org/libs/fusion) library and the [Boost.Phoenix](http://boost-spirit.com/home/spirit2/libs/spirit/phoenix/doc/html/index.html) library. He has been a professional software architect and engineer since 1987. Joel specializes in high quality, cross platform libraries, particularly—but not limited to—those written in C and C++. Joel is an expert practitioner of modern C++ techniques, template metaprogramming and functional programming, with a focus on generic programming and library-centric design. He’s very happy and enthusiastic with his current job as a consultant and engineer at [BoostPro Computing](http://www.boostpro.com). +  +Recently, Joel got into building guitars again. You can see him in action at [http://www.cycfi.com.](http://www.cycfi.com) + + + + +Copyright © 2003 Joel de Guzman + + + + + diff --git a/users/people/joel_de_guzman.jpg b/users/people/joel_de_guzman.jpg new file mode 100644 index 0000000..cc02a6a Binary files /dev/null and b/users/people/joel_de_guzman.jpg differ diff --git a/users/people/joel_de_guzman_small.jpg b/users/people/joel_de_guzman_small.jpg new file mode 100644 index 0000000..d008d6d Binary files /dev/null and b/users/people/joel_de_guzman_small.jpg differ diff --git a/users/people/john_maddock.html b/users/people/john_maddock.html new file mode 100644 index 0000000..1afcb96 --- /dev/null +++ b/users/people/john_maddock.html @@ -0,0 +1,35 @@ +--- +title: John Maddock +copyright: Rene Rivera 2004-2005. +revised: +--- + + +John Maddock + + + +John Maddock +============ + +![-](john_maddock.jpg) John + Maddock is a software developer from England and holds a PhD in + Chemistry, but found that computers smell less and explode less + often! + + +John is the author of the [regex++ regular expression package](http://ourworld.compuserve.com/homepages/John_Maddock/regexpp.htm), has an + almost pathological interest in anything that "can't be done", + and can be contacted at [john@johnmaddock.co.uk](mailto:john@johnmaddock.co.uk). + + + + + + +Copyright © 2003 John Maddock + + + + + diff --git a/users/people/john_maddock.jpg b/users/people/john_maddock.jpg new file mode 100644 index 0000000..9aaa0c9 Binary files /dev/null and b/users/people/john_maddock.jpg differ diff --git a/users/people/john_maddock_small.jpg b/users/people/john_maddock_small.jpg new file mode 100644 index 0000000..9a66ba7 Binary files /dev/null and b/users/people/john_maddock_small.jpg differ diff --git a/users/people/jonathan_turkanis.html b/users/people/jonathan_turkanis.html new file mode 100644 index 0000000..c43c259 --- /dev/null +++ b/users/people/jonathan_turkanis.html @@ -0,0 +1,34 @@ +--- +title: Jonathan Turkanis +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Jonathan Turkanis + + + +Jonathan Turkanis +================= + +![-](jonathan_turkanis.jpg) + Jonathan Turkanis is a Ph.D. Candidate in mathematical logic at + the University of California at Berkeley and a coauthor of the + forthcoming C++ Cookbook, published by + O'Reily. + + +You can contact him by sending mail to [technews@kangaroologic.com](mailto:technews@kangaroologic.com). + + + + + + +Copyright © 2005 Jonathan Turkanis + + + + + diff --git a/users/people/jonathan_turkanis.jpg b/users/people/jonathan_turkanis.jpg new file mode 100644 index 0000000..56d4b0f Binary files /dev/null and b/users/people/jonathan_turkanis.jpg differ diff --git a/users/people/jonathan_turkanis_small.jpg b/users/people/jonathan_turkanis_small.jpg new file mode 100644 index 0000000..19f7476 Binary files /dev/null and b/users/people/jonathan_turkanis_small.jpg differ diff --git a/users/people/kevlin_henney.html b/users/people/kevlin_henney.html new file mode 100644 index 0000000..4c29443 --- /dev/null +++ b/users/people/kevlin_henney.html @@ -0,0 +1,56 @@ +--- +title: Kevlin Henney +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Kevlin Henney + + + +Kevlin Henney +============= + +![-](kevlin_henney.jpg) + Kevlin Henney (, ) is an independent + consultant and trainer based in the UK. He has developed and + delivered training course material and consultancy on many + aspects of OO development, which he has practiced across a + number of domains for longer than he cares (or can) remember. + His professional interests include patterns, OO and + component-based design, architecture, distributed object + systems, and languages, including C++, C#, Java, and Ruby. He + is also a member of the BSI C++ standards committee. + + +Now that writing code is no longer the core responsibility + of his job, his non-professional interests seem to include the + hacking associated with the aforementioned professional + interests. However, never being one to keep something to + himself (like C++'s relationship with C, this is regarded as + both a strength and a weakness), he shares/inflicts (delete as + necessary) his professional and non-professional development + experiences with/on (ditto) others through writing articles and + presenting tutorials, workshops and papers at conferences. + + +He is married, and not just to his work. He and Carolyn have + one child, Stefan. The little spare time that remains to him is + taken up with music, reading, pub appreciation, etc. Although + with a newborn, there is more reading and less pub appreciation + (pubs are still appreciated, but more in memory than in + interaction). Finally, although he enjoys writing, Kevlin is + not really one for writing in the third person. + + + + + + +Copyright © 2002 Kevlin Henney + + + + + diff --git a/users/people/kevlin_henney.jpg b/users/people/kevlin_henney.jpg new file mode 100644 index 0000000..1bdc122 Binary files /dev/null and b/users/people/kevlin_henney.jpg differ diff --git a/users/people/kevlin_henney_small.jpg b/users/people/kevlin_henney_small.jpg new file mode 100644 index 0000000..142d113 Binary files /dev/null and b/users/people/kevlin_henney_small.jpg differ diff --git a/users/people/liequan_lee.html b/users/people/liequan_lee.html new file mode 100644 index 0000000..e499570 --- /dev/null +++ b/users/people/liequan_lee.html @@ -0,0 +1,39 @@ +--- +title: Lie-Quan Lee +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Lie-Quan Lee + + + +Lie-Quan Lee +============ + +![-](liequan_lee.jpg) + Lie-Quan Lee, AKA Rich Lee, is a graduate stduent in Computer + Science at University of Notre Dame. He is the author of the + Generic Graph Component Library (GGCL). + + +He has a strong desire of learning to disassemble and + assemable any electrical appliances. He likes playing bridge + but never had a chance to play it after he entered the + wonderful world of computers. + + +He can be contacted at liequan@slac.stanford.edu. + + + + + + +Copyright © 2004 Lie-Quan Lee + + + + + diff --git a/users/people/liequan_lee.jpg b/users/people/liequan_lee.jpg new file mode 100644 index 0000000..a7e54f2 Binary files /dev/null and b/users/people/liequan_lee.jpg differ diff --git a/users/people/liequan_lee_small.jpg b/users/people/liequan_lee_small.jpg new file mode 100644 index 0000000..8d1bf90 Binary files /dev/null and b/users/people/liequan_lee_small.jpg differ diff --git a/users/people/mac_murrett.html b/users/people/mac_murrett.html new file mode 100644 index 0000000..6c01475 --- /dev/null +++ b/users/people/mac_murrett.html @@ -0,0 +1,37 @@ +--- +title: Mac Murrett +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Mac Murrett + + + +Mac Murrett +=========== + +![-](mac_murrett.jpg) Mac + Murrett is an Advanced Developer at [Vanteon](http://www.vanteon.com/). He + lives in Rochester, NY, where everything closes at 10 PM. This + gives him plenty of time to think. + + +Mac graduated from SUNY: University at Buffalo with a degree + in Mathematics. He has been programming Macintoshes since he + was 12 years old, and recently won [the Best Hack Contest](http://www.hax.com/MacHack/HackContest.html) at [MacHack 2001](http://www.machack.com/). + Nonetheless, he swears up and down that his name has nothing to + do with the computer. + + + + + + +Copyright © 2002 Mac Murrett + + + + + diff --git a/users/people/mac_murrett.jpg b/users/people/mac_murrett.jpg new file mode 100644 index 0000000..5ae18a9 Binary files /dev/null and b/users/people/mac_murrett.jpg differ diff --git a/users/people/mac_murrett_small.jpg b/users/people/mac_murrett_small.jpg new file mode 100644 index 0000000..6729219 Binary files /dev/null and b/users/people/mac_murrett_small.jpg differ diff --git a/users/people/mark_rodgers.html b/users/people/mark_rodgers.html new file mode 100644 index 0000000..615894d --- /dev/null +++ b/users/people/mark_rodgers.html @@ -0,0 +1,44 @@ +--- +title: Mark Rodgers +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Mark Rodgers + + + +Mark Rodgers +============ + +![-](mark_rodgers.jpg) Mark + Rodgers lives in [Wellington](http://www.wellington.govt.nz/), the capital of New Zealand, + with his wife, Clare, and their son, Ronnie. + + +He studied Computer Science at [Victoria University of Wellington](http://www.vuw.ac.nz/home/default.aspx) from 1983 to + 1986, completing a B.Sc. (Hons). He now works as + consultant through his company, Cadenza New Zealand Ltd, and + also markets Cadenza Drawing Board™, a CAD system he + developed. + + +Mark has been programming in C++ since about 1990, and loves + every minute of it, but is continually amazed at how much more + he still has to learn. + + +You can contact Mark at [mark.rodgers@cadenza.co.nz](mailto:mark.rodgers@cadenza.co.nz). + + + + + + +Copyright © 2000 Mark Rodgers + + + + + diff --git a/users/people/mark_rodgers.jpg b/users/people/mark_rodgers.jpg new file mode 100644 index 0000000..0542e32 Binary files /dev/null and b/users/people/mark_rodgers.jpg differ diff --git a/users/people/mark_rodgers_small.jpg b/users/people/mark_rodgers_small.jpg new file mode 100644 index 0000000..8720912 Binary files /dev/null and b/users/people/mark_rodgers_small.jpg differ diff --git a/users/people/mat_marcus.html b/users/people/mat_marcus.html new file mode 100644 index 0000000..32f66f0 --- /dev/null +++ b/users/people/mat_marcus.html @@ -0,0 +1,37 @@ +--- +title: Mat Marcus +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Mat Marcus + + + +Mat Marcus +========== + +![-](mat_marcus.jpg) +[Mat + Marcus](http://www.emarcus.org) is a senior computer scientist in the Software + Technology Lab at Adobe Systems, Inc. He has been developing + software since 1985. Recent projects include a collaboration + with [Alex Stepanov](http://www.stepanovpapers.com) on a programming class and work on + the [Adobe Source Library](http://opensource.adobe.com/). Mat's first contribution + to Boost came in the summer of 2000, when he discovered a way + to exploit the properties of the sizeof operator to simulate + partial specialization (is\_pointer, etc. with Jesse Jones). Mat + lives in Seattle with his wife and son. + + + + + + +Copyright © 2002 Mat Marcus + + + + + diff --git a/users/people/mat_marcus.jpg b/users/people/mat_marcus.jpg new file mode 100644 index 0000000..fc807e0 Binary files /dev/null and b/users/people/mat_marcus.jpg differ diff --git a/users/people/mat_marcus_small.jpg b/users/people/mat_marcus_small.jpg new file mode 100644 index 0000000..13d7199 Binary files /dev/null and b/users/people/mat_marcus_small.jpg differ diff --git a/users/people/nicolai_josuttis.jpg b/users/people/nicolai_josuttis.jpg new file mode 100644 index 0000000..9cedc21 Binary files /dev/null and b/users/people/nicolai_josuttis.jpg differ diff --git a/users/people/nicolai_josuttis_small.jpg b/users/people/nicolai_josuttis_small.jpg new file mode 100644 index 0000000..564637f Binary files /dev/null and b/users/people/nicolai_josuttis_small.jpg differ diff --git a/users/people/paul_mensonides.html b/users/people/paul_mensonides.html new file mode 100644 index 0000000..8ad67a1 --- /dev/null +++ b/users/people/paul_mensonides.html @@ -0,0 +1,33 @@ +--- +title: Paul Mensonides +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Paul Mensonides + + + +Paul Mensonides +=============== + +![-](paul_mensonides.jpg) + Paul Mensonides was born on March 31 in 1977. He lives in + Tacoma, Washington. + + +His interests include musical composition, playing the + guitar, skiing, and programming--particularly in C and C++. + + + + + + +Copyright © 2002 Paul Mensonides + + + + + diff --git a/users/people/paul_mensonides.jpg b/users/people/paul_mensonides.jpg new file mode 100644 index 0000000..f570082 Binary files /dev/null and b/users/people/paul_mensonides.jpg differ diff --git a/users/people/paul_mensonides_small.jpg b/users/people/paul_mensonides_small.jpg new file mode 100644 index 0000000..8780c74 Binary files /dev/null and b/users/people/paul_mensonides_small.jpg differ diff --git a/users/people/paul_moore.html b/users/people/paul_moore.html new file mode 100644 index 0000000..538ceff --- /dev/null +++ b/users/people/paul_moore.html @@ -0,0 +1,42 @@ +--- +title: Paul Moore +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Paul Moore + + + +Paul Moore +========== + +![-](paul_moore.jpg) Paul + Moore lives in Cheshire, England. He is married, with one son. + His "day job" is as an Oracle DBA, but he writes C and C++ + programs in his spare time. + + +Paul started programming on Acorn's BBC Micro and RISC PC + series of computers, but finally went mainstream and bought a + PC, on which he now runs Windows and Linux. Paul's main + interest is in porting and developing open-source software, and + so his main programming language is C (at least until the open + source community switches to C++). + + +Paul's main claim to C++ fame is that he owns all 3 editions + of Bjarne Stroustrup's "The C++ Programming language", plus the + ARM and the C++ standard, but he didn't own a C++ compiler + until after the 3rd edition of Stroustrup's book came out. Make + of that what you will... + + + + + + + + + diff --git a/users/people/paul_moore.jpg b/users/people/paul_moore.jpg new file mode 100644 index 0000000..25510b0 Binary files /dev/null and b/users/people/paul_moore.jpg differ diff --git a/users/people/paul_moore_small.jpg b/users/people/paul_moore_small.jpg new file mode 100644 index 0000000..d7ed11e Binary files /dev/null and b/users/people/paul_moore_small.jpg differ diff --git a/users/people/pavol_droba.html b/users/people/pavol_droba.html new file mode 100644 index 0000000..4213344 --- /dev/null +++ b/users/people/pavol_droba.html @@ -0,0 +1,51 @@ +--- +title: Pavol Droba +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Pavol Droba + + + +Pavol Droba +=========== + +![-](pavol_droba.jpg) Pavol + Droba lives in Bratislava, the capital of Slovakia with his + beautiful wife Lenka. + + +Since childhood he has always been messing with computers in + one way or the other until he settled down with C++. Since then + he did a lot of various projects but he retained his affinity + to his favorite programming language. + + +He loves to design nice programs that works and to see how + the pieces of the puzzle called design come together. + + +Currently he is a developer in a small company where he + leads a group of 5 other guys. + + +When he is not at the computer Pavol enjoys his time with + his wife. In winter he likes skiing, in summer he does some + scuba diving. + + +You can leave him a message at [droba@topmail.sk](mailto:droba@topmail.sk). + + + + + + +*Copyright © 2004 Pavol Droba* + + + + + diff --git a/users/people/pavol_droba.jpg b/users/people/pavol_droba.jpg new file mode 100644 index 0000000..964a350 Binary files /dev/null and b/users/people/pavol_droba.jpg differ diff --git a/users/people/pavol_droba_small.jpg b/users/people/pavol_droba_small.jpg new file mode 100644 index 0000000..d83be97 Binary files /dev/null and b/users/people/pavol_droba_small.jpg differ diff --git a/users/people/peter_dimov.html b/users/people/peter_dimov.html new file mode 100644 index 0000000..9fb6b04 --- /dev/null +++ b/users/people/peter_dimov.html @@ -0,0 +1,33 @@ +--- +title: Peter Dimov +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Peter Dimov + + + +Peter Dimov +=========== + +![-](peter_dimov.jpg) +[Peter + Dimov](http://www.pdimov.com/) is a software developer from Plovdiv, Bulgaria. + + +He likes C++. Not to the extent to donate a kidney for every + proposed extension, but close. + + + + + + +Copyright © 2005 Peter Dimov + + + + + diff --git a/users/people/peter_dimov.jpg b/users/people/peter_dimov.jpg new file mode 100644 index 0000000..6113b2c Binary files /dev/null and b/users/people/peter_dimov.jpg differ diff --git a/users/people/peter_dimov_old.jpg b/users/people/peter_dimov_old.jpg new file mode 100644 index 0000000..7450b7b Binary files /dev/null and b/users/people/peter_dimov_old.jpg differ diff --git a/users/people/peter_dimov_small.jpg b/users/people/peter_dimov_small.jpg new file mode 100644 index 0000000..a1a3912 Binary files /dev/null and b/users/people/peter_dimov_small.jpg differ diff --git a/users/people/peter_dimov_small_old.jpg b/users/people/peter_dimov_small_old.jpg new file mode 100644 index 0000000..e457500 Binary files /dev/null and b/users/people/peter_dimov_small_old.jpg differ diff --git a/users/people/ralf_w_grosse_kunstleve.html b/users/people/ralf_w_grosse_kunstleve.html new file mode 100644 index 0000000..86971a8 --- /dev/null +++ b/users/people/ralf_w_grosse_kunstleve.html @@ -0,0 +1,62 @@ +--- +title: Ralf W. Grosse-Kunstleve +copyright: © 2001 Ralf W. Rene Rivera 2004-2005. +revised: +--- + + +Ralf W. Grosse-Kunstleve + + + +Ralf W. Grosse-Kunstleve +======================== + +![-](ralf_w_grosse_kunstleve.jpg) Ralf is a crystallographer. He has a degree in + Mineralogy ([Bochum, Germany](http://www.mineralogie.ruhr-uni-bochum.de/eng/index.html)), and a Ph.D. in + Crystallography ([ETH Zurich](http://www.crystal.mat.ethz.ch/Intro/lfkcry) , Switzerland). Real Mineralogists + and Crystallographers run experiments with x-rays and hardware + that is not normally associated with C++ and Boost. However, + when Ralf kept breaking the expensive experimental equipment + too often, he decided that he would cause less damage as a + computational crystallographer. + + +Being a scientist, Ralf spent most of his life programming + in Fortran, the great grand-father of all good programming + languages (if you know Backus-Naur you know the name of the + [inventor of Fortran](http://www-groups.dcs.st-and.ac.uk/~history/Mathematicians/Backus.html)). Ralf is a co-author + of the [CNS](http://cns.csb.yale.edu/) Fortran program that is very popular in + structural biology. When he learned that a real programmer can + write Fortran in any language, Ralf knew that it was time for + him to learn C++. Of course, absorbing four decades of progress + in the field of computer science all at once crashed his brain. + To be able to deal with the challenge, he spawned two child + processes and named them Lisa and Anna. To see Lisa, click on + the picture and turn your monitor by 180 degrees around the + view axis. (Other pictures of [Lisa](http://cci.lbl.gov/~rwgk/Lisa-Roza-Illes/) and [Anna](http://cci.lbl.gov/~rwgk/Anna-Rhona-Illes/) do not require gymnastics with the + monitor.) + + +Right now, Ralf is working for the [Computational + Crystallography Initiative](http://cci.lbl.gov/) at the [Lawrence Berkeley + National Laboratory](http://www.lbl.gov/) in California. The goal of this + initiative is to write a software system for high-throughput + protein crystal structure determination, also known as [Structural Genomics](http://www.nigms.nih.gov/news/announcements/psi.html). Surprisingly, the gestation + period for such a system turns out to be much longer than it + was for Lisa and Anna. However, pre-natal diagnosis already + revealed that Python and C++ are the parents-to-be. For an + ultra-sound image of the new system at its early developmental + stage [click here](http://cctbx.sourceforge.net/). + + + + + + + Grosse-Kunstleve + + + + + diff --git a/users/people/ralf_w_grosse_kunstleve.jpg b/users/people/ralf_w_grosse_kunstleve.jpg new file mode 100644 index 0000000..b1ff168 Binary files /dev/null and b/users/people/ralf_w_grosse_kunstleve.jpg differ diff --git a/users/people/ralf_w_grosse_kunstleve_sm.jpg b/users/people/ralf_w_grosse_kunstleve_sm.jpg new file mode 100644 index 0000000..65a822e Binary files /dev/null and b/users/people/ralf_w_grosse_kunstleve_sm.jpg differ diff --git a/users/people/rene_rivera.html b/users/people/rene_rivera.html new file mode 100644 index 0000000..d69794c --- /dev/null +++ b/users/people/rene_rivera.html @@ -0,0 +1,43 @@ +--- +title: René Rivera +copyright: Beman Dawes, David Abrahams, 1998-2005. Rene Rivera 2004-2005. +revised: +--- + + +René Rivera + + + +René Rivera +=========== + +![-](rene_rivera.jpg) + René has spent most of his life programming in one + language or another. From assembly, through BASIC, and up to + C++ and Lisp, he has managed to program on a variety of + computers and operating systems. + + +In the past he managed to get a concurrent MS and BS in + Computer Science from Loyola University at Chicago. Work for + the Institute for the Learning Sciences at Northwestern + University building AI related systems. And worked on game + development at Jellyvision Inc. ([jellyvision.com](http://jellyvision.com)). + Where he lead the programming of "You Don't Know Jack: The 5th + Dementia", and of "That's a Fact: Jack! Read.". Which where the + basis for the development of the first two versions of "Who + Wants To Be a Millionaire". + + +His motto of "clean code, clean graphics, it can always + stand improvement" has repeatedly gotten him in trouble. + + + + + + + + + diff --git a/users/people/rene_rivera.jpg b/users/people/rene_rivera.jpg new file mode 100644 index 0000000..bda1c7f Binary files /dev/null and b/users/people/rene_rivera.jpg differ diff --git a/users/people/robert_ramey.html b/users/people/robert_ramey.html new file mode 100644 index 0000000..7559280 --- /dev/null +++ b/users/people/robert_ramey.html @@ -0,0 +1,45 @@ +--- +title: Robert Ramey +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Robert Ramey + + + +Robert Ramey +============ + +![-](robert_ramey.jpg) +[Robert Ramey](http://www.rrsd.com) + is a contract software developer living in Santa Barbara, + California. He has been involved in all aspects of the computer + industry for more than 30 years. + + +After graduating with an MS in Operations Research from U.C. + Berkeley in 1971 and serving 18 months in the miltary, he left + on a trip to Ecuador. There he founded a data processing + company which is still in operation today. Returning to + California in 1986, he focused on the more technical aspects of + software development. This has resulted in the completion of + projects such as the Postman's Sort and Boost serialization + library - among others. + + +Other current interests include hanggliding, squash, hiking + and bike riding. + + + + + + +Copyright © 2004 Robert Ramey + + + + + diff --git a/users/people/robert_ramey.jpg b/users/people/robert_ramey.jpg new file mode 100644 index 0000000..7924bad Binary files /dev/null and b/users/people/robert_ramey.jpg differ diff --git a/users/people/robert_ramey_small.jpg b/users/people/robert_ramey_small.jpg new file mode 100644 index 0000000..e2e7be4 Binary files /dev/null and b/users/people/robert_ramey_small.jpg differ diff --git a/users/people/ronald_garcia.html b/users/people/ronald_garcia.html new file mode 100644 index 0000000..086e7d1 --- /dev/null +++ b/users/people/ronald_garcia.html @@ -0,0 +1,38 @@ +--- +title: Ronald Garcia +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Ronald Garcia + + + +Ronald Garcia +============= + +![-](ronald_garcia.jpg) + Ronald Garcia is a researcher at Carnegie Mellon University in + Pittsburgh, PA. He is the author of the Boost + Multidimensional Array Library ([MultiArray](/doc/libs/release/libs/multi_array/doc/index.html)). + His research interests include software engineering tools and + techniques, programming languages, generic and generative + programming and high performance scientific computing. + + +When he's not in front of a computer, Ron's interests + include playing ultimate frisbee, bass guitar, drumset, and + West African percussion. + + + + + + +Copyright © 2002 Ronald Garcia + + + + + diff --git a/users/people/ronald_garcia.jpg b/users/people/ronald_garcia.jpg new file mode 100644 index 0000000..597059f Binary files /dev/null and b/users/people/ronald_garcia.jpg differ diff --git a/users/people/ronald_garcia_small.jpg b/users/people/ronald_garcia_small.jpg new file mode 100644 index 0000000..ced4c58 Binary files /dev/null and b/users/people/ronald_garcia_small.jpg differ diff --git a/users/people/samuel_krempp.html b/users/people/samuel_krempp.html new file mode 100644 index 0000000..0c0edac --- /dev/null +++ b/users/people/samuel_krempp.html @@ -0,0 +1,45 @@ +--- +title: Samuel Krempp +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Samuel Krempp + + + +Samuel Krempp +============= + +![-](samuel_krempp.jpg) + Samuel Krempp is teaching Mathematics and Computer Science at + the university technology institute *I.U.T. + Tremblay-en-France* near Paris. + + +Programming has been his leisure until he entered the 'Ecole + Normale Supérieure de Cachan' and got into C++ for his + studies and research in applied mathematics and image + recognition. + + +He enjoys many other things - among them photography, riding + his bicycle, and scuba-diving in wonderful, warm, sunny seas + when he can afford it. + + +He's the author of the [Boost Format + library](/doc/libs/release/libs/format/index.html). + + + + + + +Copyright © 2002 Samuel Krempp + + + + + diff --git a/users/people/samuel_krempp.jpg b/users/people/samuel_krempp.jpg new file mode 100644 index 0000000..110e3e0 Binary files /dev/null and b/users/people/samuel_krempp.jpg differ diff --git a/users/people/samuel_krempp_small.jpg b/users/people/samuel_krempp_small.jpg new file mode 100644 index 0000000..aebf9c6 Binary files /dev/null and b/users/people/samuel_krempp_small.jpg differ diff --git a/users/people/template.html b/users/people/template.html new file mode 100644 index 0000000..8b32fc1 --- /dev/null +++ b/users/people/template.html @@ -0,0 +1,25 @@ +--- +title: First Last +copyright: Beman Dawes, David Abrahams, 1998-2005. Rene Rivera 2004-2005. +revised: +--- + + +First Last + + + +First Last +========== + +![-](first_last.jpg) First + Last + + + + + + + + + diff --git a/users/people/thomas_witt.html b/users/people/thomas_witt.html new file mode 100644 index 0000000..683252d --- /dev/null +++ b/users/people/thomas_witt.html @@ -0,0 +1,43 @@ +--- +title: Thomas Witt +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Thomas Witt + + + +Thomas Witt +=========== + +![-](thomas_witt.jpg) + Thomas Witt is a senior software developer at [Zephyr + Associates, Inc.](http://www.styleadvisor.com). Being a mechanical engineer by training, + he nowadays spends most of his time developing applications and + libraries in C++. Twice a year he is allowed to leave his + office to attend C++ standards committee meetings. + + +Thomas is coauthor of the Boost.Iterator library and in a + less busy and distant past was acting as [Boost Review Wizard](/community/reviews.html) + + +In his spare time Thomas likes reading, running, swimming + and skiing. There is also rumor of him being a railroad + enthusiast, but Thomas refuses to comment on this. Thomas lives + in Stateline, Nevada enjoying the view of Lake Tahoe and the + slopes of the surrounding ski resorts. + + + + + + +Copyright © 2005 Thomas Witt + + + + + diff --git a/users/people/thomas_witt.jpg b/users/people/thomas_witt.jpg new file mode 100644 index 0000000..ed922c7 Binary files /dev/null and b/users/people/thomas_witt.jpg differ diff --git a/users/people/thomas_witt_small.jpg b/users/people/thomas_witt_small.jpg new file mode 100644 index 0000000..4ea3a2b Binary files /dev/null and b/users/people/thomas_witt_small.jpg differ diff --git a/users/people/thorsten_ottosen.html b/users/people/thorsten_ottosen.html new file mode 100644 index 0000000..815b0a2 --- /dev/null +++ b/users/people/thorsten_ottosen.html @@ -0,0 +1,48 @@ +--- +title: Thorsten Ottosen +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Thorsten Ottosen + + + +Thorsten Ottosen +================ + +![-](thorsten_ottosen.jpg) +[Thorsten + Ottosen](mailto:nesotto@cs.aau.dk) is currently a Ph.D. student at the [Machine Intelligence](http://www.cs.aau.dk/en/research/mi/) + group at Aalborg University. He holds a M.Sc. in Computer + Science from Aalborg University, Denmark (2005). After having + studied mathematics at University of Technology in Sydney, + Australia (2003), he returned to Denmark to write a second + thesis in the area of decision support systems (2004). His + first [thesis](http://www.cs.auc.dk/~nesotto/pie/) was in computer graphics since he used to + dream about making computer games. + + +Thorsten is also a co-owner and part-time employee of + [Dezide](http://www.dezide.com), a + company that specializes is trouble-shooting programs based on + Bayesian-network technology. + + +In his spare-time he used to code/read/hack C++ and + participate in ANSI/ISO C++ committee meetings. He now focuses + a bit more on his thesis. In his spare-time he enjoys jogging, + reading, and being with family and friends. + + + + + + +Copyright © 2004-2007 Thorsten Ottosen + + + + + diff --git a/users/people/thorsten_ottosen.jpg b/users/people/thorsten_ottosen.jpg new file mode 100644 index 0000000..34968b3 Binary files /dev/null and b/users/people/thorsten_ottosen.jpg differ diff --git a/users/people/thorsten_ottosen_small.jpg b/users/people/thorsten_ottosen_small.jpg new file mode 100644 index 0000000..bf0b248 Binary files /dev/null and b/users/people/thorsten_ottosen_small.jpg differ diff --git a/users/people/vesa_karvonen.html b/users/people/vesa_karvonen.html new file mode 100644 index 0000000..7a7b889 --- /dev/null +++ b/users/people/vesa_karvonen.html @@ -0,0 +1,87 @@ +--- +title: Vesa Karvonen +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Vesa Karvonen + + + +Vesa Karvonen +============= + +![-](vesa_karvonen.jpg) If + we are to believe MBTI tests, Vesa is an [INTJ](http://en.wikipedia.org/wiki/INTJ). + He has been like that probably since late 1978-1979, because, + according to some sources, it takes 2-3 years to develop the + basic temperament. Previously he saw himself mostly as a + "builder of systems" and "applier of theoretical models", but + nowadays he is beginning to see the "mastermind" aspect of his + personality. As a "Free-Thinker", his mind hardly ever + rests. + + +Vesa enjoys healthy and sustainable ways of life. He is a + vegetarian and likes cooking. Exercise is a daily part of his + life - he needs to be in good shape in order to sit all day in + work. He likes going to the gym, swimming, spinning, running, + roller skating, etc... He also practices dancing. + + +For the past years, he has been working in a small [company](http://www.housemarque.com) that + develops console games. His role is the development of software + technology, such as class libraries, frameworks and tools, for + making games. He doesn't see himself as a game or a graphics + programmer, although he has been involved in quite a few such + projects. For the past few years, most of his programming has + been in C++, but recently he has also enjoyed writing some + Ocaml. + + +He likes buying technical books using the company credit + card, but lately he hasn't had the time to read as much as he + would like (hopefully this changes soon). He likes reading (a + lot) computer science and software engineering, but also + psychology, philosophy and various self-help books, because he + knows that all the really hard problems are social - not + technical. Fantasy is also close to his heart. + + +Vesa is a bit ambivalent about his university studies. He is + a self-educated programmer and has experience ranging from bit + twiddling to generative programming and also leading of small + teams. Like many of his close colleagues, he sees that the + depth of computer science education, at least in Finland, is, + frankly, insufficient. He'll probably complete his studies some + day, because sadly most people respect authority by rank, title + or publication far more than he does. + + +Vesa is an eXtreme Programmer. He has found out that in + order for pair programming to work, both pairs must share a + similar level of experience and must be both willing and able + to externalize their thoughts. If he is sometimes forced to + stop refactoring, he'll probably quit his job. He thinks that + optimization, including improving readability and simplifying + structure, is the root of all fun in programming. He dislikes + writing documentation and reports that are never read. + + +One of his friends coerced him to use the image that you see + on this page. The image was scanned from a rather worn out + picture taken by an ex-girlfriend and is probably the only + picture of Vesa having his natural smile. Vesa is neither + married nor engaged, but just recently he met a very nice + girl... While programming is interesting and fun, it is love + that really makes him happy. ;) + + + + + + + + + diff --git a/users/people/vesa_karvonen.jpg b/users/people/vesa_karvonen.jpg new file mode 100644 index 0000000..81b6213 Binary files /dev/null and b/users/people/vesa_karvonen.jpg differ diff --git a/users/people/vesa_karvonen_small.jpg b/users/people/vesa_karvonen_small.jpg new file mode 100644 index 0000000..9e483d6 Binary files /dev/null and b/users/people/vesa_karvonen_small.jpg differ diff --git a/users/people/vladimir_prus.html b/users/people/vladimir_prus.html new file mode 100644 index 0000000..c451edc --- /dev/null +++ b/users/people/vladimir_prus.html @@ -0,0 +1,32 @@ +--- +title: Vladimir Prus +copyright: Rene Rivera 2004-2005. +revised: +--- + + +Vladimir Prus + + + +Vladimir Prus +============= + +![-](vladimir_prus.jpg) + Vladimir Prus is a development tools engineer, working on build + tools, debuggers and compilers as well as IDE UX and UI. He has a + a [website](http://vladimirprus.com) with more + details, and often posts on [Google+](http://google.com/+VladimirPrus). + + + + + + + +Copyright © 2004 Vladimir Prus + + + + + diff --git a/users/people/vladimir_prus.jpg b/users/people/vladimir_prus.jpg new file mode 100644 index 0000000..34a8d2f Binary files /dev/null and b/users/people/vladimir_prus.jpg differ diff --git a/users/people/vladimir_prus_small.jpg b/users/people/vladimir_prus_small.jpg new file mode 100644 index 0000000..e8ffbb7 Binary files /dev/null and b/users/people/vladimir_prus_small.jpg differ diff --git a/users/people/william_kempf.html b/users/people/william_kempf.html new file mode 100644 index 0000000..074f7e8 --- /dev/null +++ b/users/people/william_kempf.html @@ -0,0 +1,41 @@ +--- +title: William Kempf +copyright: Rene Rivera 2004-2005. +revised: +--- + + +William Kempf + + + +William Kempf +============= + +![-](william_kempf.jpg) + Bill Kempf lives in Omaha, NE with his wife Bonnie, his cat + Dexter and his two Chinchillas, Chimney and Minuet. He married + on Oct. 30, 1999 where he and his wife held a Halloween costume + reception. If that doesn't give you an idea of what kind of guy + he is, nothing will. + + +Bill graduated from Doane, a small private college in + Nebraska in 1992 with a B.S. in Computer Science/Math. Being in + the wrong place at the wrong time he had to take a job as the + only person in an IS shop for a local affiliate of the Bunge + Grain Company. In 1995 he moved on to a job as a software + engineer for First Data Resources where he worked on + client/server financial applications. + + + + + + +Copyright © 2000 William Kempf + + + + + diff --git a/users/people/william_kempf.jpg b/users/people/william_kempf.jpg new file mode 100644 index 0000000..41d239d Binary files /dev/null and b/users/people/william_kempf.jpg differ diff --git a/users/people/william_kempf_small.jpg b/users/people/william_kempf_small.jpg new file mode 100644 index 0000000..b679b26 Binary files /dev/null and b/users/people/william_kempf_small.jpg differ diff --git a/users/uses.html b/users/uses.html new file mode 100644 index 0000000..14bb177 --- /dev/null +++ b/users/uses.html @@ -0,0 +1,78 @@ +--- +title: Who's Using Boost? +copyright: Various Authors 2005. Rene Rivera 2007. +revised: +--- + + +Who's Using Boost? + + + +Who's Using Boost? +================== + +* [Introduction](#Introduction) +* [Open Source Boost](uses_open.html) +* [In House Boost](uses_inhouse.html) +* [Shrink Wrapped Boost](uses_shrink.html) +* [Submissions](#Submissions) + + +Introduction +------------ + + +Open source isn't just for nerds and researchers. Real world + programming challenges, irrespective of whether they are open + or closed source, can benefit enormously from the thought and + experience that has gone into the Boost software libraries. Put + simply, for any given problem for which Boost provides a + solution, Boost will strive to provide the best solution + possible. It's up to you to decide whether we've achieved that, + but as these pages will testify, many other developers have + found our solutions to be the best for them. + + +*Disclaimer:* Boost's developers try to ensure that + the information on these pages is correct, but from time to + time inadvertent mistakes are bound to occur: if you would like + an entry in these pages to be removed or corrected please + contact the [Boost + Moderators](../community/moderators.html). + + +Submissions +----------- + + +If you have an application or library that's using Boost and + would like to be listed here, please post the following + information to the [main + Boost developer mailing list](../community/groups.html#main): + + +* The name of the Application/Product/Service. +* The name of the company (where appropriate). +* A paragraph describing the + Application/Product/Service. +* Any information you can provide about which parts of + Boost you used, along with any comments you may have on how + Boost helped your product development. +* URLs to your companies home page, and the home page of + the Application/Product/Service if there is one. + + +Finally, if the subheadings used in the structure of these + pages don't fit your Product/Application/Service please say so: + we're always interested to hear how these pages can be improved + or better structured. + + + + + + + + + diff --git a/users/uses_inhouse.html b/users/uses_inhouse.html new file mode 100644 index 0000000..7f683e0 --- /dev/null +++ b/users/uses_inhouse.html @@ -0,0 +1,283 @@ +--- +title: In House Boost +copyright: Rene Rivera 2007. +revised: +--- + + +In House Boost + + + +In House Boost +============== + +Whether you're a government department, an internet startup, + or a specialist consultancy, in-house developement using the + Boost Libraries can significantly shorten your development + cycles. + + +Cern +---- + + +[The Large Hadron Collider](http://lhc.web.cern.ch/lhc/) + experiments at CERN make use of the Boost C++ libraries. + The experiment's C++ programs have several millions of + lines of code for the detector simulation, data reconstruction and + data analysis and use several of the components of the Boost library. + Examples of Boost libraries used are Any, Spirit, Date Time, Program Options, Regex, SmartPtr, Thread. + + +Google +------ + + +[google-gtags](http://code.google.com/p/google-gtags/) + Provides server-based tags serving for large codebases. This is + an extension to GNU Emacs and X-Emacs TAGS functionality, that + uses [Boost.Test](../doc/libs/release/libs/test/index.html) as + its unit test framework. + + +LiquidNet +--------- + + +[LiquidNet](http://www.liquidnet.com/) is Americas number + one electronic marketplace for large block trading, and the 5th + fastest growing company according to Inc Magazine. + + +"*Boost Libraries most used, in order of + importance:* + + +*[Boost.SharedPointer](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Python](../doc/libs/release/libs/python/doc/index.html), + [Boost.LexicalCast](../doc/libs/release/libs/conversion/lexical_cast.htm), + [Boost.Optional](../doc/libs/release/libs/optional/index.html), + [Boost.Any](../doc/libs/release/libs/any/index.html) + and [Boost.Tuple](../doc/libs/release/libs/tuple/index.html)*" + + +Océ-Technologies B.V. +--------------------- + + +Throughout the world [Océ](http://www.oce.com) is one of the major + suppliers of document management and printing systems and the + related services. We develop, manufacture, service and sell + printers, scanners, peripheral equipment and media, supported + by unique software. Océ products for the corporate and + commercial market are widely known for their quality, ease of + use, speed and reliability. + + +The Boost libraries enable us to get a higher degree of + uniformity and quality in our code. During a redesign last year + we found that lots of small constructions from Boost shortens + development time and prevents having to reinvent many wheels. + Libraries that we use include [Boost.Assign](../doc/libs/release/libs/assign/index.html), + [Boost.DateTime](../doc/libs/release/libs/date_time/index.html), + [Boost.EnableIf](../doc/libs/release/libs/utility/enable_if.html), + [Boost.FileSystem](../doc/libs/release/libs/filesystem/index.html), + [Boost.Format](../doc/libs/release/libs/format/index.html), + [Boost.Function](../doc/libs/release/libs/function/index.html), + [Boost.Iterator](../doc/libs/release/libs/iterator/index.html), + [Boost.MultiIndex](../doc/libs/release/libs/multi_index/index.html), + [Boost.Operators](../doc/libs/release/libs/utility/operators.htm), + [Boost.Optional](../doc/libs/release/libs/optional/index.html), + [Boost.PointerContainer](../doc/libs/release/libs/ptr_container/index.html), + [Boost.Signals](../doc/libs/release/libs/signals/index.html), + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.Thread](../doc/libs/release/libs/thread/index.html), + and [Boost.Variant](../doc/libs/release/libs/variant/index.html). + + +MetOcean Engineers +------------------ + + +[MetOcean Engineers](http://www.metoceanengineers.com) are a + leading consultancy providing oceanographic and meteorological + services in support of coastal and ocean engineering and + environmental protection. Core activities encompass: + oceanographic measurements; metocean monitoring systems; + coastal and ocean engineering; environmental consultancy; data + management. + + +Boost Libraries currently in use: [Boost.Any](../doc/libs/release/libs/any/index.html), + [Boost.Assign](../doc/libs/release/libs/assign/index.html), + [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.DateTime](../doc/libs/release/libs/date_time/index.html), + [Boost.Iterator](../doc/libs/release/libs/iterator/index.html), + [Boost.LexicalCast](../doc/libs/release/libs/conversion/lexical_cast.htm), + [Boost.MPL](../doc/libs/release/libs/mpl/index.html), + [Boost.Phoenix](../doc/libs/release/libs/spirit/phoenix/index.html), + [Boost.ProgramOptions](../doc/libs/release/libs/program_options/index.html), + [Boost.Ref](../doc/libs/release/libs/bind/ref.html), + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.Spirit](../doc/libs/release/libs/spirit/index.html), + [Boost.StringAlgorithms](../doc/libs/release/libs/algorithm/string/index.html), + [Boost.Tribool](../doc/libs/release/doc/html/tribool.html) + and [Boost.Variant](../doc/libs/release/libs/variant/index.html) + + +TeraView Ltd +------------ + + +[TeraView + Ltd](http://www.teraview.com) develop terahertz based systems for a variety of + applications including spectroscopy and imaging. + + +*"We use: [Boost.Thread](../doc/libs/release/libs/thread/index.html), + [Boost.FileSystem](../doc/libs/release/libs/filesystem/index.html), + [Boost.DateTime](../doc/libs/release/libs/date_time/index.html), + [Boost.Serialization](../doc/libs/release/libs/serialization/index.html), + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.Function](../doc/libs/release/libs/function/index.html), + [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Iterator](../doc/libs/release/libs/iterator/index.html), + [Boost.LexicalCast](../doc/libs/release/libs/conversion/lexical_cast.htm), + [Boost.Format](../doc/libs/release/libs/format/index.html), + [Boost.Tuple](../doc/libs/release/libs/tuple/index.html), + [Boost.Any](../doc/libs/release/libs/any/index.html) + and [Boost.Optional](../doc/libs/release/libs/optional/index.html)"* + + +NPC International +----------------- + + +With about 800 restaurants, [NPC International](http://www.npcinternational.com) is the + world's largest Pizza Hut franchisee. + + +*"We make extensive use of boost in our internally + developed point of sale, restaurant management, communications, + and accounting systems. We use the following Boost libraries in + approximate order of frequency of use: [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Function](../doc/libs/release/libs/function/index.html), + [Boost.Optional](../doc/libs/release/libs/optional/index.html), + [Boost.SharedPointer](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.DateTime](../doc/libs/release/libs/date_time/index.html), + [Boost.Thread](../doc/libs/release/libs/thread/index.html), + [Boost.Lambda](../doc/libs/release/libs/lambda/index.html), + [Boost.TypeTraits](../doc/libs/release/libs/type_traits/index.html), + [Boost.MPL](../doc/libs/release/libs/mpl/index.html), + [Boost.Tuple](../doc/libs/release/libs/tuple/index.html), + [Boost.EnableIf](../doc/libs/release/libs/utility/enable_if.html), + [Boost.Variant](../doc/libs/release/libs/variant/index.html), + [Boost.Spirit](../doc/libs/release/libs/spirit/index.html), + [Boost.StringAlgorithms](../doc/libs/release/libs/algorithm/string/index.html), + [Boost.Preprocessor](../doc/libs/release/libs/preprocessor/index.html), + [Boost.FileSystem](../doc/libs/release/libs/filesystem/index.html), + [Boost.Operators](../doc/libs/release/libs/utility/operators.htm), + [Boost.Iterator](../doc/libs/release/libs/iterator/index.html) + and [Boost.Tokenizer](../doc/libs/release/libs/tokenizer/index.html)."* + + +Rational Discovery LLC +---------------------- + + +[Rational Discovery](http://www.rationaldiscovery.com) + provides computational modeling, combinatorial library design + and custom software development services to the pharmaceutical, + biotech and chemical industries. + + +*"We do a substantial amount of internal research to + develop new approaches for applying machine-learning techniques + to solve chemical problems. Because we're a small organization + and chemistry is a large and complex field, it is essential + that we be able to quickly and easily prototype and test new + algorithms. We have found the Boost libraries, a reliable + source of high-quality code, to be indispensable.* + + +*Boost libraries used: [Boost.Python](../doc/libs/release/libs/python/doc/index.html), + [Boost.Graph](../doc/libs/release/libs/graph/index.html), + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.Any](../doc/libs/release/libs/any/index.html), + [Boost.LexicalCast](../doc/libs/release/libs/conversion/lexical_cast.htm), + [Boost.Random](../doc/libs/release/libs/random/index.html), + [Boost.StringAlgorithms](../doc/libs/release/libs/algorithm/string/index.html), + [Boost.Tuple](../doc/libs/release/libs/tuple/index.html), + [Boost.Ublas](../doc/libs/release/libs/numeric/ublas/index.html)."* + + +Archelon LLC +------------ + + +[Archelon LLC](http://www.archelon-us.com) is a global + securities firm headquartered in Chicago. We actively trade + equities, futures and derivatives in both electronic and + floor-based markets. Archelon is one of the highest volume + market makers on EUREX and a leading U.S. option market maker + focusing on the most active securities. + + +*"We use: [Boost.Any](../doc/libs/release/libs/any/index.html), + [Array](../doc/libs/release/libs/array/index.html), + [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.DateTime](../doc/libs/release/libs/date_time/index.html), + [Boost.Function](../doc/libs/release/libs/function/index.html), + [Boost.LexicalCast](../doc/libs/release/libs/conversion/lexical_cast.htm), + [Boost.Optional](../doc/libs/release/libs/optional/index.html), + [Boost.Rational](../doc/libs/release/libs/rational/index.html), + [Boost.Regex](../doc/libs/release/libs/regex/index.html), + [Boost.Signals](../doc/libs/release/libs/signals/index.html), + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.Tokenizer](../doc/libs/release/libs/tokenizer/index.html), + [Boost.Tuple](../doc/libs/release/libs/tuple/index.html) and + [Boost.Utility](../doc/libs/release/libs/utility/index.html)."* + + +Automated Trading Deck +---------------------- + + +[Automated + Trading Deck](http://www.atdesk.com) (ATD) uses a large number of Boost libraries. + ATD is a technology company specializing in automated trading + and customized equity execution solutions for its customers. We + offer automated execution solutions in all domestic cash equity + markets, including the listed, over-the-counter, exchange + traded fund and bulletin board marketplaces. Our proprietary + "Pricing Engine" and automated limit-order trading algorithms + apply advanced expert systems to limit-order trading and + customer executions. + + +"EB" Automotive +--------------- + + +["EB" + Automotive](http://www.elektrobit.com/static/en/index.html) is currently using [Boost.GIL](../doc/libs/release/libs/gil/doc/index.html), + [Boost.MPL](../doc/libs/release/libs/mpl/index.html) + and [Boost.StringAlgorithms](../doc/libs/release/libs/algorithm/string/index.html) + for a in house tool. Additionally we use Stefan Seefelds + Boost.XML from sandbox, with a few small extensions. + + +*"Especially [Boost.GIL](../doc/libs/release/libs/gil/doc/index.html) + gave our image preprocessing routines a strong speed boost and + greatly simplified our code".* + + + + + + + + + diff --git a/users/uses_open.html b/users/uses_open.html new file mode 100644 index 0000000..adad908 --- /dev/null +++ b/users/uses_open.html @@ -0,0 +1,739 @@ +--- +title: Open Source Boost +copyright: Rene Rivera 2007. +revised: +--- + + +Open Source Boost + + + +Open Source Boost +================= + +Boost is used in a variety of Open Source Projects, both + applications and libraries. Indeed many Open Source libraries + developed around Boost have in the past been judged of high + enough quality to be absorbed into the main Boost source tree, + a process that will no doubt continue into the future. Others + are in highly specialized niche markets, ranging from + probability theory to astronomy, via mass spectroscopy: + whatever your field of interest you'll find something of value + in Boost. + + +Algocoders +---------- + + +Algocoders + has been using boost since last 6+ years with a mission to help people + build a better software eco-system by standing on the shoulder of giants. + + + + + If it wasn't for Boost, then it could have been really difficult for us + to build our framework based on sound mathematical foundation of computer science + using modern C++. + + It is the pioneering efforts at Boost towards + "Using and Extending C++11, Boost and Beyond" + which has motivated us to devote ourself in developing bullet-size capsules + in the form of tiny booklets with industrial-set framework to lift the thin veil + with initial focus on practical usage of C++11 + vis-a-vis mathematical foundation behind it. + + Enthused by boost, we are working tirelessly towards publishing a series of + books (or booklets) + which will bridge the gap between esoteric and street-side ones. + Initial focus will be on C++11, Boost, Loki, STL, Algorithms, Data Structures, + Multi-threading, Design Patterns, gcc, Clang, valgrind. + + First book in this series is Foundation of Algorithms in C++11, Volume 1: + Using and Extending C++11, Boost and Beyond (published December 2012) + + List of books in progress: + + + +* Smart Pointers : Tips and Techniques in C++ : Using and Extending C++11, Boost and Beyond +* C++11 FAQs : Using and Extending C++11, Boost and Beyond +* Concepts & Traits C++ : Using and Extending C++11, Boost and Beyond + We use almost all the libraries in Boost including trunk and branches, + especially Spirit, Phoenix, Proto, MPL, Fusion. + + + +Adobe Software Libraries +------------------------ + + +The [Adobe Software Libraries](http://opensource.adobe.com/) + provide components for modeling the human interface appearance + and behavior in a software application. The Adobe Software + Libraries depend on many parts of Boost including [Boost.Any](../doc/libs/release/libs/any/index.html), + [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Function](../doc/libs/release/libs/function/index.html), + [Boost.MPL](../doc/libs/release/libs/mpl/index.html), + [Boost.Operators](../doc/libs/release/libs/utility/operators.htm), + [Boost.Range](../doc/libs/release/libs/range/index.html), + [Boost.StaticAssert](../doc/libs/release/libs/static_assert/index.html), + [Boost.Thread](../doc/libs/release/libs/thread/index.html), + and [Boost.TypeTraits](../doc/libs/release/libs/type_traits/index.html). + + +Currently Boost and the Adobe Software Libraries are in use + in around 30 Adobe products. + + +LyX Document Editor +------------------- + + +[The LyX + Document Editor](http://www.lyx.org/) is an advanced open source document + processor that encourages an approach to writing based on the + structure of your documents, not their appearance. LyX produces + high quality, professional output, using LaTeX, an industrial + strength typesetting engine. + + +LyX uses many parts of Boost, including [Array](../doc/libs/release/libs/array/index.html), [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Regex](../doc/libs/release/libs/regex/index.html), + [Boost.TypeTraits](../doc/libs/release/libs/type_traits/index.html), + [Boost.Function](../doc/libs/release/libs/function/index.html), + and [Boost.Signals](../doc/libs/release/libs/signals/index.html). + + +CodeSynthesis XML Schema to C++ Data Binding Compiler (XSD) + by Code Synthesis Tools CC +--------------------------------------------------------------------------------------- + + +[CodeSynthesis XML + Schema to C++ Data Binding Compiler (XSD)](http://codesynthesis.com/products/xsd/) is an + open-source, cross-platform XML Data Binding implementation for + C++. Provided with an XML instance specification (XML Schema), + it generates C++ classes that represent the given vocabulary as + well as parsing and serialization code. You can then access the + data stored in XML using types and functions that semantically + correspond to your application domain rather than dealing with + elements, attributes, and text in a direct representation of + XML such as DOM or SAX. + + +XSD uses [Boost.Regex](../doc/libs/release/libs/regex/index.html) and + [Boost.FileSystem](../doc/libs/release/libs/filesystem/index.html) + libraries from Boost. [Boost.Regex](../doc/libs/release/libs/regex/index.html) is + used to perform transformations on file, type and member names. + [Boost.FileSystem](../doc/libs/release/libs/filesystem/index.html) + is used to capture and manipulate XML Schema include and import + paths. Additionally, we are planning to provide an optional + mapping of XML Schema date and time types to C++ types from the + Boost [Boost.DateTime](../doc/libs/release/libs/date_time/index.html) + library. + + +CodeShop +-------- + + +I am happy to announce Amsterdam based [CodeShop](http://www.code-shop.com) has been using + Boost since 2005 on all of it's projects (and CodeShop memebers + have been using Boost since 2001). + + +We used it on the following: + + +*OpenZoep* + + +An open source voip stack + (xmpp-sip*rtp*(port)audio/codecs), capable of pc2pc + calls and pc2pstn calls - it's a message based sdk, so you + could write your own Gtalk or Skype ... + + +Boost is used everywhere: from the xmpp implementation + ([Boost.Function](../doc/libs/release/libs/function/index.html), + [Boost.Asio](../doc/libs/release/libs/asio/index.html)) to + the codecs-wrapper ([Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html)) + - and more. Boost made the code a lot easier, more fun, safer + and faster to develop. Bjam was used as build system. + + +See [description](http://www.code-shop.com/2007/1/14/openzoep) + and [trac&svn](https://open.code-shop.com/trac/openzoep). + + +*Abonja / Whitelabelvideo* + + +Online videosharing platform: you can upload and watch + flashvideo online, but at the same time run your pc client and + download all your preferences automatically for viewing later + at home + + +Boost and C++ are used for the serverside tooling. Bjam is + used as build system. + + +[www.abonja.nl](http://www.abonja.nl) and [www.whitelabelvideo.nl](http://www.whitelabelvideo.nl) + (Dutch only: a javascript sdk for viewing and uploading - Boost + is used serverside also). + + +Code from above and other projects made available as plain + download or as library. + + +Pieces address 'simple' problems like a windows registry + wrapper to more system like parts as for instance a drm + implementation. Boost is used all over (\_\_filesystem, [Boost.Thread](../doc/libs/release/libs/thread/index.html), + [Boost.Asio](../doc/libs/release/libs/asio/index.html), + [Boost.Spirit](../doc/libs/release/libs/spirit/index.html) + etc); [Boost.Build](../build/) + is used as build system. + + +CGAL +---- + + +[CGAL](http://www.cgal.org/) is + the Computational Geometry Algorithms Library, an open source + C++ library providing generic components such as + triangulations, convex hulls algorithms, boolean operations of + polygons and many other things. *"We currently use the + following Boost libraries : [Boost.Operators](../doc/libs/release/libs/utility/operators.htm), + [Boost.Iterator](../doc/libs/release/libs/iterator/index.html), + [Boost.Tuple](../doc/libs/release/libs/tuple/index.html), + [Boost.ConceptCheck](../doc/libs/release/libs/concept_check/index.html), + [Boost.MPL](../doc/libs/release/libs/mpl/index.html), + [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Optional](../doc/libs/release/libs/optional/index.html) + and [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html)."* + + +ALPS +---- + + +[ALPS](http://alps.comp-phys.org/) is an open source project + to develop codes for the accurate simulation of quantum lattice + models, such as quantum magnets, electronic systems and + Bose-Einstein condensates. The main Boost libraries used are: + [Boost.Graph](../doc/libs/release/libs/graph/index.html), + [Boost.Random](../doc/libs/release/libs/random/index.html), + [Boost.MultiIndex](../doc/libs/release/libs/multi_index/index.html), + [Boost.ProgramOptions](../doc/libs/release/libs/program_options/index.html), + [Boost.LexicalCast](../doc/libs/release/libs/conversion/lexical_cast.htm), + [Boost.Serialization](../doc/libs/release/libs/serialization/index.html), + [Boost.Regex](../doc/libs/release/libs/regex/index.html), + [Boost.Tuple](../doc/libs/release/libs/tuple/index.html), + [Boost.FileSystem](../doc/libs/release/libs/filesystem/index.html), + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Functional](../doc/libs/release/libs/functional/index.html) + and [Boost.TypeTraits](../doc/libs/release/libs/type_traits/index.html) + + +SmartWin++ +---------- + + +[SmartWin++](http://smartwin.sourceforge.net/) is a 100% + free GUI library for developing Windows applications, it's free + both as in "free beer" and as in "free speech", you can freely + use SmartWin++ for commercial applications and for Open Source + applications! + + +Open VRML +--------- + + +[Open + VRML](http://openvrml.org/) is a free cross-platform runtime for VRML. The basic + OpenVRML distribution includes libraries you can use to add + VRML support to an application, and Lookat, a simple + stand-alone VRML browser. + + +Bayes++ +------- + + +[Bayes++](http://bayesclasses.sourceforge.net/Bayes++.html) + is an open source library that represents and implements a wide + variety of numerical algorithms for Bayesian Filtering of + discrete systems from the [Australian Centre for Field + Robotics](http://www.acfr.usyd.edu.au/). Bayes++ makes particularly heavy use of [Boost.Ublas](../doc/libs/release/libs/numeric/ublas/index.html) + for matrix and numeric computations. + + +Kohonen Neural Network Library (KNNL) +------------------------------------- + + +[Kohonen neural network + library](http://knnl.sourceforge.net/) is a set of classes and functions for design, train + and use Kohonen networks (self organizing maps). + + +KNNL Uses [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Function](../doc/libs/release/libs/function/index.html), + [Boost.TypeTraits](../doc/libs/release/libs/type_traits/index.html) +[Boost.ProgramOptions](../doc/libs/release/libs/program_options/index.html). + + +The C++/Tk Library +------------------ + + +[The + C++/Tk Library](http://cpptk.sourceforge.net) is an open source C++ interface to the Tk + GUI Library. + + +GluCat +------ + + +[GluCat](http://glucat.sourceforge.net/) is a library of + template classes which model the universal Clifford algebras + over the real or complex fields, with arbitrary dimension and + arbitrary signature. + + +OpenMS +------ + + +[OpenMS](http://open-ms.sourceforge.net/) is an open source + C++ library for LC/MS data management, reduction, evaluation, + visualization, storage and sophisticated statistical analyses. + It can be used to develop mass spectrometry related + applications. + + +libpdf++ +-------- + + +[libpdf++](http://libpdfxx.sourceforge.net/doc/index.html) + is an object-oriented library for generating PDF (portable + document format) files. It is designed in a way that the + objects in the document are mapped directly to classes in the + library. + + +Regina +------ + + +[Regina](http://regina.sourceforge.net/) is a suite of + mathematical software for 3-manifold topologists. It focuses + upon the study of 3-manifold triangulations and includes + support for normal surfaces and angle structures. + + +MetaFS +------ + + +[MetaFS](http://metafs.sourceforge.net/) is a daemon for + Linux (and Linux only) that allows you to access information + about your files (such as MP3 tags or JPEG's EXIF tags) easily + and consistently using extended attributes. It also allows you + to perform fast searches using this information. MetaFS is + extensible, so anyone can write plug-ins to access new types of + metadata. + + +The ASN.1 Tool +-------------- + + +Abstract Syntax Notation One (ASN.1) is a formal language + for abstractly describing messages to be exchanged among an + extensive range of applications involving the Internet, + intelligent network, cellular phones, ground-to-air + communications, electronic commerce, secure electronic + services, interactive television, intelligent transportation + systems, Voice Over IP and others. + + +[The ASN.1 Tool](http://iiiasn1.sourceforge.net/main.html) + includes two parts : an ASN.1 compiler "asnparser" which + compiles the Abstract Syntax to c++ files, and a runtime + library which is used to link with the c++ files generated by + asnparser. Based on the works of Open H.323 projects, it is + developed for the needs of H.450 series protocol. + + +DGD +--- + + +[DGD](http://dgd.sourceforge.net/dgd_home.html) (Depression + Glass Debug) is simple, easy to use C++ ostream extension + created with a goal to produce nice, readable and easy to + understand trace logs + + +FEAR +---- + + +[FEAR](http://fear.sourceforge.net/) is a language + independent open-source project providing portable support for + the creation of genuine Artificial Intelligence within + realistic simulated worlds. + + +XEngine +------- + + +[XEngine](http://xengine.sourceforge.net/features.php) is a + platform- and rendering-API-independent 3D engine for real-time + visualization with support for programmable graphics pipeline + architectures and is implemented in C++. + + +Spheral++ +--------- + + +[Spheral++](http://spheral.sourceforge.net/) is a numerical + tool for simulating the evolution of a set of fluid or solid + materials subject to hydrodynamic, gravitational, and radiative + effects. Spherical++ uses [Boost.Python](../doc/libs/release/libs/python/doc/index.html). + + +C++ XML Objects +--------------- + + +[C++ XML Objects](http://cppxmlobj.sourceforge.net/) is a + framework for persisting hierarchies of C++ objects to and from + XML. + + +HippoDraw +--------- + + +[HippoDraw](http://www.slac.stanford.edu/grp/ek/hippodraw/index.html) + provides a highly interactive data analysis environment. + HippoDraw uses [Boost.Python](../doc/libs/release/libs/python/doc/index.html). + + +Orocos +------ + + +[The Orocos Robot Control Software Application + Framework](http://people.mech.kuleuven.ac.be/~psoetens/orocos/doc/orocos-control-manual.html). + + +ECell +----- + + +The [E-Cell + Project](http://www.e-cell.org/) is an international research project aiming at + developing necessary theoretical supports, technologies and + software platforms to allow precise whole cell simulation. + + +VCS Made Easy +------------- + + +[VCS + Made Easy](http://vcsme.sourceforge.net/), or vcsme for short, is an utility whose main + purpose is to simplify the maintenance of file trees managed by + a version control system, such as the well known CVS or + Subversion. Simply put, it automates the process of bringing + all these directories to an up-to-date status with a single and + simple command. + + +*"The following Boost libraries were used: [Boost.Format](../doc/libs/release/libs/format/index.html), + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.Utility](../doc/libs/release/libs/utility/index.html) + and [Boost.FileSystem](../doc/libs/release/libs/filesystem/index.html)."* + + +Monotone +-------- + + +[Monotone](http://www.venge.net/monotone/) is a free + distributed version control system. It provides a simple, + single-file transactional version store, with fully + disconnected operation and an efficient peer-to-peer + synchronization protocol. It understands history-sensitive + merging, lightweight branches, integrated code review and 3rd + party testing. It uses cryptographic version naming and + client-side RSA certificates. It has good internationalization + support, has no external dependencies, runs on linux, solaris, + OSX, windows, and other unixes, and is licensed under the GNU + GPL. + + +*"The followind Boost libraries were used: [Boost.DateTime](../doc/libs/release/libs/date_time/index.html), + [Boost.FileSystem](../doc/libs/release/libs/filesystem/index.html), + [Boost.Conversion](../doc/libs/release/libs/conversion/index.html), + [Boost.Optional](../doc/libs/release/libs/optional/index.html), + [Boost.Random](../doc/libs/release/libs/random/index.html), + [Boost.Regex](../doc/libs/release/libs/regex/index.html), + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.StaticAssert](../doc/libs/release/libs/static_assert/index.html), + [Boost.Tokenizer](../doc/libs/release/libs/tokenizer/index.html), + [Boost.Tuple](../doc/libs/release/libs/tuple/index.html) and + [Boost.Test](../doc/libs/release/libs/test/index.html)."* + + +Hydranode Engine +---------------- + + +[Hydranode + Engine](http://hydranode.com/) is a plugin-driven P2P client engine that relies + heavily on Boost libraries. Hydranode codebase is licenced + under GNU GPL, and is developed mainly by Alo Sarv. Currently + in Beta phase, Hydranode runs on wide range of platforms, + including Windows, Linux, BSD, Mac OS, Solaris etc. + + +*"Hydranode Engine and plugins rely heavily on the + following Boost libraries: [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Function](../doc/libs/release/libs/function/index.html), + [Boost.Lambda](../doc/libs/release/libs/lambda/index.html), + [Boost.MultiIndex](../doc/libs/release/libs/multi_index/index.html), + [Boost.Signals](../doc/libs/release/libs/signals/index.html), + Threads, [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + Format, [Boost.LexicalCast](../doc/libs/release/libs/conversion/lexical_cast.htm). + Other Boost libraries being used include [Boost.FileSystem](../doc/libs/release/libs/filesystem/index.html), + [Boost.StringAlgorithms](../doc/libs/release/libs/algorithm/string/index.html), + [Boost.DateTime](../doc/libs/release/libs/date_time/index.html), + [Boost.ProgramOptions](../doc/libs/release/libs/program_options/index.html), + [Boost.Spirit](../doc/libs/release/libs/spirit/index.html), + [Boost.Random](../doc/libs/release/libs/random/index.html), + [Boost.Tokenizer](../doc/libs/release/libs/tokenizer/index.html), + [Boost.TypeTraits](../doc/libs/release/libs/type_traits/index.html), + [Boost.Tribool](../doc/libs/release/doc/html/tribool.html), + [Boost.Tuple](../doc/libs/release/libs/tuple/index.html) and + [Boost.Any](../doc/libs/release/libs/any/index.html). Once + Boost 1.33 is released, I'm also looking forward to using the + Boost Iostreams library in Hydranode.* + + +*"All complex data structures in Hydranode are + implemented using [Boost.MultiIndex](../doc/libs/release/libs/multi_index/index.html) + containers, which significantly reduced development time and + kept code clean. Format is being used for all text formatting. + Having [Boost.Thread](../doc/libs/release/libs/thread/index.html) + and [Boost.FileSystem](../doc/libs/release/libs/filesystem/index.html) + libraries available made cross-platform development lot easier + in those areas."* + + +Hugin +----- + + +With [hugin](http://hugin.sourceforge.net/) you can assemble a + mosiac of photographs into a complete immersive panorama, + stitch any series of overlapping pictures and much more. + + +Enblend +------- + + +[Enblend](http://enblend.sourceforge.net/) is a tool for + compositing images. Given a set of images that overlap in some + irregular way, Enblend overlays them in such a way that the + seam between the images is invisible, or at least very + difficult to see. + + +GNU Source-highlight +-------------------- + + +[GNU Source-highlight](http://www.gnu.org/software/src-highlite/source-highlight.html), given a source file, produces a + document with syntax highlighting. The colors and the styles + can be specified (bold, italics, underline) by means of a + configuration file, and some other options can be specified at + the command line. The output format can be HTML, XHTML and ANSI + color escape sequences. GNU Source Highlight is build around + [Boost.Regex](../doc/libs/release/libs/regex/index.html) + + +Luabind +------- + + +[Luabind](http://luabind.sourceforge.net/) is a library that + helps you create bindings between C++ and lua. It has the + ability to expose functions and classes, written in C++, to + lua. It will also supply the functionality to define classes in + lua and let them derive from other lua classes or C++ classes. + Lua classes can override virtual functions from their C++ + baseclasses. It is written towards lua 5.0, and does not work + with lua 4. + + +C++/Tcl +------- + + +[C++/Tcl](http://cpptcl.sourceforge.net/) is a library that + allows the easy integration of C++ and Tcl. + + +Mordor +------ + + +The [Modor](http://code.mozy.com/projects/mordor/) project + is a high performance I/O library. + + Issued under [BSD license](https://opensource.org/licenses/bsd-license.php). + + + +NOX +--- + + +The [NOX](http://www.noxrepo.org/) project is the original OpenFlow controller, + and facilitates development of fast C++ controllers on Linux. + NOX is a piece of the Software Defined Networking ecosystem. + Specifically, it?s a platform for building network control applications. + + + +QuantLib +-------- + + +The [QuantLib](http://quantlib.org/) project provides a + comprehensive software framework for quantitative finance. + QuantLib is a free/open-source library for modeling, trading, + and risk management in real-life. Boost components used include + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.Iterator](../doc/libs/release/libs/iterator/index.html), + and [Boost.Test](../doc/libs/release/libs/test/index.html). + + +CBCanaylzer +----------- + + +[CBCanaylzer](http://www.biozentrum.uni-wuerzburg.de/index.php?id=524) + is developed by the Department of Bioinformatics, at the + University of Wuerzburg. + + +*"CBCAnalyzer (CBC = compensatory base change) is a tool + to create small'' phylogenetic trees from sequence alignments. + To measure the distance of sequences the compensatory base + changes are detected and counted. The bionj algorithm is then + used to construct a tree. CBCAnalyzer is available on Windows, + Linux and partly works on MacOSX.* + + +*"Boost libraries used: [Boost.ProgramOptions](../doc/libs/release/libs/program_options/index.html) + - creates really nice output, and is both easy to extend and + simple to handle. [Boost.Iterator](../doc/libs/release/libs/iterator/index.html), + [Boost.Spirit](../doc/libs/release/libs/spirit/index.html) - + Saved a lot of my time, and makes the vast amount of biological + file formats simple to support, [Boost.SharedPointer](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.Lambda](../doc/libs/release/libs/lambda/index.html).* + + +Profdist +-------- + + +[Profdist](http://www.biozentrum.uni-wuerzburg.de/index.php?id=523) + is developed by the Department of Bioinformatics, at the + University of Wuerzburg. + + +*"Profdist is a tool for the construction of large + phylogenetic trees based on profile distances. The input + alignment data gets extended by random picking of rows, and a + clustering technique is used to create profiles of the most + frequent subtrees. The iterative approach allows working on + large datasets. Currently the application is very limited by + the quality of wxWidgets, and only available for Windows and + Linux.* + + +*"The Boost libraries used were: [Boost.StringAlgorithms](../doc/libs/release/libs/algorithm/string/index.html), + [Boost.Ref](../doc/libs/release/libs/bind/ref.html), + [Boost.Iterator](../doc/libs/release/libs/iterator/index.html), + [Boost.Spirit](../doc/libs/release/libs/spirit/index.html), + [Boost.SharedPointer](../doc/libs/release/libs/smart_ptr/index.html) + and [Boost.Lambda](../doc/libs/release/libs/lambda/index.html)."* + + +The Yake Engine +--------------- + + +[The Yake + Engine](http://www.yake.org/) is a component-based, object-oriented engine written + in C++ and primarily designed for VR applications and games. It + abstracts typical low-level and middleware APIs and provides + various low, mid and application level functionality as well as + tools to create and import content. + + +Public Sector Credit Solutions +------------------------------ + + +[Public Sector Credit Solutions](http://www.publicsectorcredit.org/) An open source project modelling sovereign rating debt ratings uses + a Monte Carlo simulation which includes calls to Boost.Math + normal and Cauchy random number generators. + [Public Sector Credit Framework](http://www.publicsectorcredit.org/pscf.html) +Python-Ogre +----------- + + +[Python-Ogre](http://python-ogre.python-hosting.com/) is a + Python bindings for Ogre 3D - a scene-oriented, flexible 3D + engine. + + +Python-Ogre uses [Boost.Python](../doc/libs/release/libs/python/doc/index.html) + to expose next libraries to Python: + + +* Ogre +* Newton +* ODE +* OgreAL +* CEGUI +* OIS + + + + + + + + + diff --git a/users/uses_shrink.html b/users/uses_shrink.html new file mode 100644 index 0000000..c06cf85 --- /dev/null +++ b/users/uses_shrink.html @@ -0,0 +1,655 @@ +--- +title: Shrink Wrapped Boost +copyright: Rene Rivera 2007. +revised: +--- + + +Shrink Wrapped Boost + + + +Shrink Wrapped Boost +==================== + +Boost has found it's way into many products that are + available "off the shelf", including consumer applications from + Adobe, through to business middleware from SAP. + + +Adobe Photoshop CS2 +------------------- + + +[Adobe + Photoshop CS2](http://www.adobe.com/products/photoshop/index.html) uses the [Adobe Software Libraries](http://opensource.adobe.com/), + which in turn depend upon large parts of Boost. The [Adobe Software + Libraries](http://opensource.adobe.com/) are being rolled out across the Adobe product + line to provide cross platform user interface logic. + + +Adobe Indesign +-------------- + + +[Adobe + Indesign](http://www.adobe.com/products/indesign/index.html) offers best of breed page design: Indesign and + it's asociated SDK depend upon Boost [Boost.Regex](../doc/libs/release/libs/regex/index.html), + [Boost.Functional](../doc/libs/release/libs/functional/index.html) + and others. + + +SAP NetWeaver +------------- + + +[SAP + NetWeaver](http://www.sap.com/platform/netweaver/index.epx) is the technical foundation of mySAP Business + Suite solutions, SAP xApps composite applications, partner + solutions, and customer custom-built applications. [Boost.Regex](../doc/libs/release/libs/regex/index.html) + provides the regular expression implementation for SAP's + [ABAP + language](https://www.sdn.sap.com/irj/sdn?node=linkDnode6-3). + + +Real Networks, Rhapsody +----------------------- + + +The [Rhapsody + Music Service](http://www.real.com/) allows its subscribers to legally + download/transfer/burn over a million songs. The Rhapsody + client software was built with many Boost libraries: + + +[Boost.Format](../doc/libs/release/libs/format/index.html): + Boost.Format is top notch. Using it is a bliss. + + +[Boost.Functional](../doc/libs/release/libs/functional/index.html), + [Boost.Function](../doc/libs/release/libs/function/index.html), + and [Boost.Bind](../doc/libs/release/libs/bind/index.html): + These three libraries, along with [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html) + are the most used in our application. I could not imagine not + having them handy. + + +[Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html): + Hands down, the most useful, and used library of the lot! + + +[Boost.DateTime](../doc/libs/release/libs/date_time/index.html): + Simple to use, effective, does the job. I love the flexible + input string parsing facilities, and the human readable ISO + output. + + +[Boost.Iterator](../doc/libs/release/libs/iterator/index.html): + Wow. Moving legacy iterating interfaces, or interfaces that + should of been properly designed as iterators to STL compliant + iterators was easy and painless. The gains in functionality to + our code made by this library are invaluable. + + +[Boost.Regex](../doc/libs/release/libs/regex/index.html): + When you need it, it works magic. + + +[Boost.Thread](../doc/libs/release/libs/thread/index.html): + Used to implement the monitor pattern in key areas. + + +[Boost.Preprocessor](../doc/libs/release/libs/preprocessor/index.html): + Used to implement repetitive unit-test code generation. The + codebase benefited greatly from the clarity [Boost.Preprocessor](../doc/libs/release/libs/preprocessor/index.html) + brought. + + +Skyjuice Software, Quick File Rename +------------------------------------ +[Skyjuice Software](http://www.skyjuicesoftware.com) +[Quick File Rename](http://www.skyjuicesoftware.com/software/QuickFileRename) + is a unicode batch file and + folder renamer which allows photo collectors and audiophiles to rename + thousands of files and folders in seconds. Users can tag audio files, + extract meta data information for photos, and perform other batch rename + operations to allow better categorisation of files and folders in Windows + Explorer. Complex rename operations can be combined into a single step + using a rules system. A command line mode is also supported. + Parts of boost used: All regular expressions used in Quick File Rename are + parsed by + [Boost.Regex](../doc/libs/release/libs/random/index.html). + This provided us with tremendous power for the text + manipulation that is used frequently in both in the GUI and console modes. + + + +DataSolid GmbH Germany, CADdy++ Mechanical Design (c) +----------------------------------------------------- + + +[CADdy++ + Mechanical Design professional (c)](http://www.DataSolid.com) is a fully parametric 3D + CAD application with unbroken link between 3D models and 2D + drawings. CADdy++ uses the Boost libraries: [Boost.Any](../doc/libs/release/libs/any/index.html), + [Boost.Tokenizer](../doc/libs/release/libs/tokenizer/index.html), + [Boost.Signals](../doc/libs/release/libs/signals/index.html), + [Boost.PropertyMap](../doc/libs/release/libs/property_map/index.html), + [Array](../doc/libs/release/libs/array/index.html), + [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Operators](../doc/libs/release/libs/utility/operators.htm), + [Boost.Tuple](../doc/libs/release/libs/tuple/index.html), + [Boost.Random](../doc/libs/release/libs/random/index.html). + + +*"Many thanks to all the boost developers for their great + work and effort spending into boost."* + + +Dimension 5, Miner3D +-------------------- + + +Data visualization technology enabling advanced data + analysis, visualization, sonification and speech applications + for business and science. + + +The [Miner3D](http://www.miner3D.com) application provides means + for interactive visual analysis of arbitrary tabular data from + various data sources. It has a powerful OpenGL-based + visualization engine and an intuitive GUI. This combination + helps a human eye guide the application of statistical tools + and spot the patterns that might otherwise remain hidden. + + +*"We are using the following boost libraries: [Boost.DateTime](../doc/libs/release/libs/date_time/index.html), + [Boost.Variant](../doc/libs/release/libs/variant/index.html), + [Boost.Regex](../doc/libs/release/libs/regex/index.html), + [Boost.Format](../doc/libs/release/libs/format/index.html), + [Boost.StringAlgorithms](../doc/libs/release/libs/algorithm/string/index.html), + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.MPL](../doc/libs/release/libs/mpl/index.html), + [Boost.TypeTraits](../doc/libs/release/libs/type_traits/index.html), + [Boost.Operators](../doc/libs/release/libs/utility/operators.htm), + [Boost.DynamicBitset](../doc/libs/release/libs/dynamic_bitset/index.html), + [Boost.EnableIf](../doc/libs/release/libs/utility/enable_if.html), + [Boost.Timer](../doc/libs/release/libs/timer/index.html)."* + + +Synergy, mailIntercept +---------------------- + + +[mailIntercept](http://www.mintercept.com) from [Synergy](http://www.synergy.com.br) is a + mail interceptor service for Exchange Server 2000/2003. + + +mailIntercept intercepts and interprets the e-mails from a + LAN using Exchange Server and converts the microsoft + proprietary format to MIME and passes them to an SMTP filter + and returns the emails to the Exchange Server as modified by + the SMTP filter, converted back to the microsoft proprietary + format and with its features preserved. + + +mailIntercept was built using the following Boost libraries: + [Boost.MPL](../doc/libs/release/libs/mpl/index.html), + [Boost.StringAlgorithms](../doc/libs/release/libs/algorithm/string/index.html), + [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Phoenix](../doc/libs/release/libs/spirit/phoenix/index.html), + [Boost.Spirit](../doc/libs/release/libs/spirit/index.html), + [Boost.PointerContainer](../doc/libs/release/libs/ptr_container/index.html), + [Boost.Serialization](../doc/libs/release/libs/serialization/index.html), + [Boost.Regex](../doc/libs/release/libs/regex/index.html), + [Boost.Iterator](../doc/libs/release/libs/iterator/index.html), + [Boost.Lambda](../doc/libs/release/libs/lambda/index.html), + [Boost.LexicalCast](../doc/libs/release/libs/conversion/lexical_cast.htm), + [Boost.Operators](../doc/libs/release/libs/utility/operators.htm), + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.Tribool](../doc/libs/release/doc/html/tribool.html) + and [Boost.TypeTraits](../doc/libs/release/libs/type_traits/index.html) + + +Integrated Research P/L, PROGNOSIS IP Telephony Manager and + IP Telephony Express +--------------------------------------------------------------------------------- + + +[PROGNOSIS](http://www.ir.com) + is a suite of IP telephony management software products, + specifically designed to address the key challenges of IP + telephony life cycle management, including network-readiness, + assessment, pre-deployment assurance testing, and ongoing Day-2 + management of Cisco CallManager, Cisco Unity, and Cisco AVVID + infrastructure. *"The Boost libraries used were: [Boost.Any](../doc/libs/release/libs/any/index.html), + [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Function](../doc/libs/release/libs/function/index.html), + [Boost.LexicalCast](../doc/libs/release/libs/conversion/lexical_cast.htm), + [Boost.MPL](../doc/libs/release/libs/mpl/index.html), + [Boost.NumericCast](../doc/libs/release/libs/conversion/cast.htm#numeric_cast), + [Boost.Ref](../doc/libs/release/libs/bind/ref.html), + [Boost.Regex](../doc/libs/release/libs/regex/index.html), + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.Thread](../doc/libs/release/libs/thread/index.html), + [Boost.TypeTraits](../doc/libs/release/libs/type_traits/index.html)."* + + +Kinook Software, Visual Build Professional +------------------------------------------ + + +[Visual Build Professional](http://www.visualbuild.com/) is + a tool that enables developers, software process engineers, and + build specialists to create an automated, repeatable process + for building their software. Visual Build provides built-in + support for Microsoft Visual Studio .NET and 2005, Visual + Basic, Visual C++, Visual J++, SourceSafe, eMbedded Tools, + Borland Delphi, JBuilder, C++Builder, and more. + + +The following Boost Libraries were used: [Boost.Any](../doc/libs/release/libs/any/index.html), + [Boost.MemFn](../doc/libs/release/libs/bind/mem_fn.html), + [Boost.Regex](../doc/libs/release/libs/regex/index.html), + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.StaticAssert](../doc/libs/release/libs/static_assert/index.html) + + +Kinook Software, Ultra Recall +----------------------------- + + +[Ultra + Recall](http://www.ultrarecall.com/) is a personal information management (PIM) / + knowledge management (KM) application for Microsoft Windows. It + helps you capture, organize, and recall all of your electronic + information across all the applications that you use. + + +Used the following Boost libraries: [Boost.Format](../doc/libs/release/libs/format/index.html), + [Boost.SharedPointer](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.StaticAssert](../doc/libs/release/libs/static_assert/index.html) + + +Applied Dynamics International, ADvantageDE +------------------------------------------- + + +[Applied + Dynamics International (ADI)](http://www.adi.com) provides state-of-the art + software and hardware tools to the automotive, aerospace, and + defense industries to design and test embedded control systems. + ADI's tools provide advanced capabilities in real-time + hardware-in-the-loop (HIL) simulation, rapid prototyping, and + embedded controller software development. We have been a + leading supplier of HIL simulation solutions since 1957. + + +ADvantageDE is the development environment. It allows + simulation models to be easily connected to one another or to + hardware components for real-time simulation. ADvantageDE + projects can be created for execution on your PC, Unix + workstation or on our real-time platforms. + + +ADvantageVI is the point of control and the graphical user + interface for all of the run-time activities. The run-time + architecture includes extensive features for interacting with, + visualizing, and automating simulation and test activities. + + +DasCom provides access to real-time simulation data from + most Windows applications, such as Micrsoft Excel, National + Instruments Labview, etc. + + +The following Boost Libraries are used: [Array](../doc/libs/release/libs/array/index.html), [Boost.Assign](../doc/libs/release/libs/assign/index.html), + [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.CRC](../doc/libs/release/libs/crc/index.html), + [Boost.DynamicBitset](../doc/libs/release/libs/dynamic_bitset/index.html), + [Boost.EnableIf](../doc/libs/release/libs/utility/enable_if.html), + [Boost.FileSystem](../doc/libs/release/libs/filesystem/index.html), + [Boost.Function](../doc/libs/release/libs/function/index.html), + [Boost.Functional](../doc/libs/release/libs/functional/index.html), + [Boost.Iterator](../doc/libs/release/libs/iterator/index.html), + [Boost.Lambda](../doc/libs/release/libs/lambda/index.html), + [Boost.Optional](../doc/libs/release/libs/optional/index.html), + [Boost.Preprocessor](../doc/libs/release/libs/preprocessor/index.html), + [Boost.Ref](../doc/libs/release/libs/bind/ref.html), + [Boost.Regex](../doc/libs/release/libs/regex/index.html), + [Boost.Serialization](../doc/libs/release/libs/serialization/index.html), + [Boost.Signals](../doc/libs/release/libs/signals/index.html), + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.StaticAssert](../doc/libs/release/libs/static_assert/index.html), + [Boost.Spirit](../doc/libs/release/libs/spirit/index.html), + [Boost.StringAlgorithms](../doc/libs/release/libs/algorithm/string/index.html), + [Boost.Tokenizer](../doc/libs/release/libs/tokenizer/index.html), + [Boost.Tuple](../doc/libs/release/libs/tuple/index.html), + [Boost.Utility](../doc/libs/release/libs/utility/index.html) + and [Boost.Variant](../doc/libs/release/libs/variant/index.html) + + +PeerGuardian +------------ + + +[PeerGuardian 2](http://phoenixlabs.org/pg2/) is Methlabs + premier IP blocker for Windows. With features like support for + multiple lists, a list editor, automatic updates, and blocking + all of IPv4 (TCP, UDP, ICMP, etc), PeerGuardian 2 is the safest + and easiest way to protect your privacy on P2P. + + +Boost Libraries used include [Boost.CRC](../doc/libs/release/libs/crc/index.html), + [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Integer](../doc/libs/release/libs/integer/index.html), + [Boost.Function](../doc/libs/release/libs/function/index.html), + [Boost.Functional](../doc/libs/release/libs/functional/index.html), + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.LexicalCast](../doc/libs/release/libs/conversion/lexical_cast.htm), + [Boost.StringAlgorithms](../doc/libs/release/libs/algorithm/string/index.html), + [Boost.Random](../doc/libs/release/libs/random/index.html), + [Boost.Format](../doc/libs/release/libs/format/index.html), + [Boost.Utility](../doc/libs/release/libs/utility/index.html). + + +DECOMSYS::DESIGNER PRO +---------------------- + + +[DECOMSYS::DESIGNER PRO](http://www.decomsys.com/) enables + the user to design a highly complex [FlexRay](http://www.flexray.com/) communication system, + which is going to be the fundament for tomorrow's automotive + electronics. + + +*"Boost Libraries used: [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.DynamicBitset](../doc/libs/release/libs/dynamic_bitset/index.html), + [Boost.Format](../doc/libs/release/libs/format/index.html), + [Boost.Function](../doc/libs/release/libs/function/index.html), + [Boost.Iterator](../doc/libs/release/libs/iterator/index.html), + [Boost.MPL](../doc/libs/release/libs/mpl/index.html), + [Boost.MultiIndex](../doc/libs/release/libs/multi_index/index.html), + [Boost.Utility](../doc/libs/release/libs/utility/index.html), + [Boost.Operators](../doc/libs/release/libs/utility/operators.htm), + [Boost.Preprocessor](../doc/libs/release/libs/preprocessor/index.html) + (nice for generating data for unit tests), [Boost.ProgramOptions](../doc/libs/release/libs/program_options/index.html) + (for the unit test programs), [Boost.Ref](../doc/libs/release/libs/bind/ref.html), + [Boost.Regex](../doc/libs/release/libs/regex/index.html), + [Boost.Serialization](../doc/libs/release/libs/serialization/index.html), + [Boost.Signals](../doc/libs/release/libs/signals/index.html), + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.Spirit](../doc/libs/release/libs/spirit/index.html), + [Boost.Timer](../doc/libs/release/libs/timer/index.html) and + [Boost.Variant](../doc/libs/release/libs/variant/index.html)* + + +*"We are also planning to use Andreas Huber's FSM library + and Iostreams (together with Serialize) once they are + officially released."* + + +Wise Riddles Software, Audiomatic +--------------------------------- + + +[Audiomatic](http://www.wiseriddles.com/Products/Audiomatic/) + is a tool used to make system-wide macros and then launch those + macros with a voice command or keyboard shortcut at any time... + from any Windows application. Audiomatic enables you to launch + programs, files, or websites; simulate keystrokes; play sounds; + speak text; or even run scripts. You can do it all with a voice + command or keyboard shortcut! *"Boost libraries Used: + [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Function](../doc/libs/release/libs/function/index.html), + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.DateTime](../doc/libs/release/libs/date_time/index.html), + [Boost.StringAlgorithms](../doc/libs/release/libs/algorithm/string/index.html), + [Boost.Utility](../doc/libs/release/libs/utility/index.html), + [Boost.Regex](../doc/libs/release/libs/regex/index.html), + [Boost.Thread](../doc/libs/release/libs/thread/index.html), + [Boost.MPL](../doc/libs/release/libs/mpl/index.html) + and [Boost.TypeTraits](../doc/libs/release/libs/type_traits/index.html)."* + + +SMProcess FxEngine +------------------ + + +The [FxEngine](http://www.smprocess.com/Bin/FxEngineSetup.exe) + from [SMProcess](http://www.smprocess.com) is a Free Framework + for data flow processing and the design of dynamic systems + using plugins. The Framework provides a full control to the + plugin architecture for applications that require custom + solutions. + + +The Framework is essentially based on three boost libraries: + [Boost.Thread](../doc/libs/release/libs/thread/index.html): + Used to implement each "Pin" work. [Boost.Thread](../doc/libs/release/libs/thread/index.html) + includes everything what we were looking for a portable + framework like mutex and condition components. [Boost.Functional](../doc/libs/release/libs/functional/index.html) + and [Boost.Bind](../doc/libs/release/libs/bind/index.html): + Provide a great flexibility compared to the STL. [Boost.Timer](../doc/libs/release/libs/timer/index.html): A + very straightforward and effective timer. + + +Remobo +------ + + +[Remobo](http://www.remobo.com) from [AWIT Systems, Inc](http://www.remobo.com) creates an + Instant Private Network (IPN) between your computers and your + friends. It's a COMPUTER Network based on your Social Network. + With IPN service, you and your friends can work or play + together over Internet as if you were sitting on the same + office or home LAN (Local Area Network). + + +The Boost libraries used were: [Asio](../doc/libs/release/libs/asio/index.html), [Bind](../doc/libs/release/libs/bind/index.html), [DateTime](../doc/libs/release/libs/date_time/index.html), + [Non-Copyable](../doc/libs/release/libs/utility/utility.htm#Class_noncopyable), [File + System](../doc/libs/release/libs/filesystem/index.html), [Function](../doc/libs/release/libs/function/index.html), + [Lexical + Cast](../doc/libs/release/libs/conversion/lexical_cast.htm), [Ref](../doc/libs/release/libs/bind/ref.html), [Regex](../doc/libs/release/libs/regex/index.html), [Serialization](../doc/libs/release/libs/serialization/index.html), + [Smart + Pointer](../doc/libs/release/libs/smart_ptr/index.html), [StateChart](../doc/libs/release/libs/statechart/index.html), + [Threads](../doc/libs/release/libs/thread/index.html), + [Tokenizer](../doc/libs/release/libs/tokenizer/index.html), + [Tribool](../doc/libs/release/doc/html/tribool), + [Tuples](../doc/libs/release/libs/tuple/doc/tuple_users_guide.html), + [Utility](../doc/libs/release/libs/utility/index.html), + [Variant](../doc/libs/release/libs/variant/index.html), + [Format](../doc/libs/release/libs/format/index.html), + [MPL](../doc/libs/release/libs/mpl/index.html), + [Multi + Index](../doc/libs/release/libs/multi_index/index.html), [Preprocessor](../doc/libs/release/libs/preprocessor/doc/index.html), + [Type + Traits](../doc/libs/release/libs/type_traits/index.html) + + +Megahard Software Technologies Inc., Rule in Hell +------------------------------------------------- + + +Rule in Hell is a Massively Multiplayer Online Role Playing + Game (still in beta). + + +The Boost libraries used were: [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Function](../doc/libs/release/libs/function/index.html), + [Boost.Any](../doc/libs/release/libs/any/index.html), + [Boost.Tuple](../doc/libs/release/libs/tuple/index.html), + [Boost.Ref](../doc/libs/release/libs/bind/ref.html), + [Boost.SharedPointer](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.TypeTraits](../doc/libs/release/libs/type_traits/index.html) + and [Boost.Utility](../doc/libs/release/libs/utility/index.html). + + +*"By far the combination of [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Function](../doc/libs/release/libs/function/index.html), + [Boost.SharedPointer](../doc/libs/release/libs/smart_ptr/index.html) + and [Boost.Ref](../doc/libs/release/libs/bind/ref.html) is what + we use most heavily".* + + +Dr. Detlef Meyer-Eltz, TextTransformer +-------------------------------------- + + +The [TextTransformer](http://www.texttransformer.com) is a + Windows IDE for the generation of top down parsers with + included c++ interpreter code for semantic actions. Both can be + executed or debugged immediately on single source files or on + groups of files. Generated parsers can be exported as c++ code + including as well the interpretable code as any arbitrary other + code. Tokens are defined as POSIX regular expressions and rules + are defined in a similar syntax quasi as regular expressions of + regular expressions. The construction of parse trees and their + traversal is supported. + + +*"The TextTransformer is essentially based on the + [Boost.Regex](../doc/libs/release/libs/regex/index.html), + by which the tokens for a parser can be defined. The [Boost.LexicalCast](../doc/libs/release/libs/conversion/lexical_cast.htm) + and the Format library are used for the integrated c++ + interpreter. For the future also an interpreter version of the + [Boost.StringAlgorithms](../doc/libs/release/libs/algorithm/string/index.html) + is planned. The [Boost.ProgramOptions](../doc/libs/release/libs/program_options/index.html) + library will be used too to improve the command line version of + the texttransformer."* + + +Redshift Software, The Thot Tool +-------------------------------- + + +[The Thot + Tool](http://thot-tool.com/) is an asset management tool for a group of game + developers. Thot combines assets, both binary and text, with + workflow automation into a unified whole, and was built using + Boost [Boost.Thread](../doc/libs/release/libs/thread/index.html), + [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.Regex](../doc/libs/release/libs/regex/index.html), + [Boost.MPL](../doc/libs/release/libs/mpl/index.html), and + [Boost.TypeTraits](../doc/libs/release/libs/type_traits/index.html). + + +Paragent, Paragent Manage 2.1 +----------------------------- + + +[Paragent + Manage](http://www.paragent.com/) is a Desktop Management Application that uses a + lightweight agent written in C++. Unlike traditional desktop + management solutions, Paragent Manage avoids the complexity and + cost of servers by using peer-to-peer communication between + agents and the administrative console. This allows real-time + inventory searching, alerting and software auditing in an + easy-to-deploy and maintain package. + + +*"We have used Boost extensively throughout our agent, + including: [Boost.Thread](../doc/libs/release/libs/thread/index.html), + [Boost.SharedPointer](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Spirit](../doc/libs/release/libs/spirit/index.html), + [Boost.DateTime](../doc/libs/release/libs/date_time/index.html), + [Boost.StringAlgorithms](../doc/libs/release/libs/algorithm/string/index.html), + [Boost.MultiIndex](../doc/libs/release/libs/multi_index/index.html), + [Boost.FileSystem](../doc/libs/release/libs/filesystem/index.html).* + + +*"Apart from some read\_write\_mutex issues we had, Boost + has been a seamless part of our development, and has allowed us + to develop and deploy a very complex, highly threaded + networking agent with a built-in lisp-like xml-based scripting + language all done in C++. Our entire development team would + like to thank everyone for their hard work on behalf of C++ + coders everywhere."* + + +think-cell, Boost PowerPoint efficiency +--------------------------------------- +[think-cell](http://www.think-cell.com/) + was founded in 2002 in Berlin and is today the leading vendor + of productivity software for professional PowerPoint users. + Its product suite covers the complete process of presentation creation - + from analysis and preparation of business data + to the graphical rendering of qualitative and quantitative results. + Most international business consulting firms, + as well as a large number of the well-known industrial global leaders, + are among think-cell's customers. + + Our presentation suite think-cell serves a single purpose – creating business presentations. + It is a complete set of cutting-edge productivity tools, each unrivaled in its scope of application. + + think-cell chart is our leading PowerPoint add-in for creating professional business charts, + such as complex Waterfalls, Mekkos and Gantts, in a few minutes. + + think-cell round is our one-of-a-kind Excel add-in for consistently rounding numbers, + even across complex calculations. + + think-cell layout is our patented PowerPoint add-in + for rapidly composing clean slide layouts from standard elements. + + Libraries used: + [Algorithm](../doc/libs/release/libs/algorithm/index.html), + [Assign](../doc/libs/release/libs/assign/index.html), + [Config](../doc/libs/release/libs/config/config.htm), + [Conversion](../doc/libs/release/libs/conversion/index.html), + [CRC](../doc/libs/release/libs/crc/index.html), + [Date Time](../doc/libs/release/libs/date_time/index.html), + [Format](../doc/libs/release/libs/format/index.html), + [Fusion](../doc/libs/release/libs/fusion/doc/html/index.html), + [Geometry](../doc/libs/release/libs/geometry/index.html), + [Integer](../doc/libs/release/libs/integer/index.html), + [Interprocess](../doc/libs/release/libs/interprocess/index.html), + [Intrusive](../doc/libs/release/libs/intrusive/index.html), + [Iostreams](../doc/libs/release/libs/iostreams/index.html), + [Iterator](../doc/libs/release/libs/iterator/index.html), + [Math Common Factor](../doc/libs/release/libs/math/doc/html/gcd_lcm.html), + [Math/Special Functions](../doc/libs/release/libs/math/doc/html/special.html), + [MPL](../doc/libs/release/libs/mpl/index.html), + [Multi-Array](../doc/libs/release/libs/multi_array/index.html), + [Multi-Index](../doc/libs/release/libs/multi_index/index.html), + [Numeric Conversion](../doc/libs/release/libs/numeric/conversion/index.html), + [Operators](../doc/libs/release/libs/utility/operators.htm), + [Optional](../doc/libs/release/libs/optional/index.html), + [Phoenix](../doc/libs/release/libs/phoenix/index.html), + [Preprocessor](../doc/libs/release/libs/preprocessor/index.html), + [Proto](../doc/libs/release/libs/proto/index.html), + [Range](../doc/libs/release/libs/range/index.html), + [Smart Ptr](../doc/libs/release/libs/smart_ptr/smart_ptr.htm), + [Spirit](../doc/libs/release/libs/spirit/index.html), + [String Algo](../doc/libs/release/libs/algorithm/string/index.html), + [Swap](../doc/libs/release/libs/utility/swap.html), + [Tribool](../doc/libs/release/doc/html/tribool.html), + [Tuple](../doc/libs/release/libs/tuple/index.html), + [Variant](../doc/libs/release/libs/variant/index.html) +LW-WORKS Software, Clipboard Recorder +------------------------------------- + + +[Clipboard + Recorder](http://www.lw-works.com/clipboard-recorder) is an application that helps users to manage their + clipboard history and provides easy ways for users to access + their saved clipboard data. + + +Libraries used: [Boost.SmartPointers](../doc/libs/release/libs/smart_ptr/index.html), + [Boost.Serialization](../doc/libs/release/libs/serialization/index.html), + [Boost.Asio](../doc/libs/release/libs/asio/index.html), + [Boost.StringAlgorithms](../doc/libs/release/libs/algorithm/string/index.html), + [Boost.Bind](../doc/libs/release/libs/bind/index.html), + [Boost.Thread](../doc/libs/release/libs/thread/index.html), + [Boost.Conversion](../doc/libs/release/libs/conversion/index.html), + Iostreams. + + + + + + + + +