From 0ce4a99d90915bed4fcae9af4843fe7fcc358fd5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Wed, 10 May 2023 18:15:53 +0100 Subject: [PATCH 001/171] Update configuration for building working drafts after N4950. --- source/config.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/config.tex b/source/config.tex index d764e25075..493b166c2f 100644 --- a/source/config.tex +++ b/source/config.tex @@ -1,8 +1,8 @@ %!TEX root = std.tex %%-------------------------------------------------- %% Version numbers -\newcommand{\docno}{N4950} -\newcommand{\prevdocno}{N4944} +\newcommand{\docno}{Dxxxx} +\newcommand{\prevdocno}{N4950} \newcommand{\cppver}{202302L} %% Release date From abb81facf56f82a7487b3f64ae337ce2802c4bf3 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Fri, 12 May 2023 09:38:16 +0200 Subject: [PATCH 002/171] [intro.execution] Fix bad function call in example --- source/basic.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/basic.tex b/source/basic.tex index cb8225617f..2afa7e18ca 100644 --- a/source/basic.tex +++ b/source/basic.tex @@ -5716,7 +5716,7 @@ if (S(3).v()) // full-expression includes lvalue-to-rvalue and \tcode{int} to \tcode{bool} conversions, // performed before temporary is deleted at end of full-expression { } - bool b = noexcept(S()); // exception specification of destructor of \tcode{S} considered for \keyword{noexcept} + bool b = noexcept(S(4)); // exception specification of destructor of \tcode{S} considered for \keyword{noexcept} // full-expression is destruction of \tcode{s2} at end of block } From 42f21d84fb374b11d44c0b367bda649636128b6a Mon Sep 17 00:00:00 2001 From: Andrew Rogers Date: Wed, 19 Apr 2023 01:03:57 +0100 Subject: [PATCH 003/171] [dcl.init.aggr] Add missing apostrophe --- source/declarations.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/declarations.tex b/source/declarations.tex index 06c3caad99..fed6acc54f 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -5227,7 +5227,7 @@ and \tcode{y[2]}. The initializer ends early and therefore -\tcode{y[3]}s +\tcode{y[3]}'s elements are initialized as if explicitly initialized with an expression of the form \tcode{float()}, From 4514233a48954d0fd0669236cc986640e33feb04 Mon Sep 17 00:00:00 2001 From: lprv <100177227+lprv@users.noreply.github.com> Date: Fri, 12 May 2023 23:14:43 +0200 Subject: [PATCH 004/171] [basic.compound] Fix cross-reference for 'incomplete type' (#6210) --- source/basic.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/basic.tex b/source/basic.tex index 2afa7e18ca..e7d171d6fe 100644 --- a/source/basic.tex +++ b/source/basic.tex @@ -5265,7 +5265,7 @@ Except for pointers to static members, text referring to ``pointers'' does not apply to pointers to members. Pointers to incomplete types are allowed although there are restrictions on what can be done with -them\iref{basic.align}. +them\iref{basic.types.general}. \indextext{address}% Every value of pointer type is one of the following: \begin{itemize} From 3ec6173e224efca7ddce91182aeed48263e6506f Mon Sep 17 00:00:00 2001 From: languagelawyer <38548419+languagelawyer@users.noreply.github.com> Date: Sun, 14 May 2023 22:06:19 +0500 Subject: [PATCH 005/171] [class.base.init] Use \defnadj to introduce delegating and target constructor (#6252) --- source/classes.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/classes.tex b/source/classes.tex index 8735ff7c11..c17568610b 100644 --- a/source/classes.tex +++ b/source/classes.tex @@ -5461,8 +5461,8 @@ \grammarterm{class-or-decltype} that denotes the constructor's class itself. If a \grammarterm{mem-initializer-id} designates the constructor's class, it shall be the only \grammarterm{mem-initializer}; the constructor -is a \term{delegating constructor}, and the constructor selected by the -\grammarterm{mem-initializer} is the \term{target constructor}. +is a \defnadj{delegating}{constructor}, and the constructor selected by the +\grammarterm{mem-initializer} is the \defnadj{target}{constructor}. The target constructor is selected by overload resolution. Once the target constructor returns, the body of the delegating constructor is executed. If a constructor delegates to itself directly or indirectly, From 4fac9f97a2c25d39a01f75cf198d0783bfa8deda Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Tue, 16 May 2023 17:01:51 +0100 Subject: [PATCH 006/171] [strings], [unord.req.general], [stringbuf.members]: Fix xrefs to [container.requirements.general] All the references for "qualifies as an input iterator" and "qualifies as an allocator" are supposed to be to [container.reqmts] p69 which begins: > The behavior of certain container member functions and deduction > guides depends on whether types qualify as input iterators or > allocators. The reference in [string.require] for obtaining an allocator should be to [container.reqmts] p64. The reference in [string.require] Note 2 should be to [container.requirements.pre] p3. Fixes #6184 --- source/containers.tex | 6 +++--- source/iostreams.tex | 2 +- source/strings.tex | 23 ++++++++++++----------- 3 files changed, 16 insertions(+), 15 deletions(-) diff --git a/source/containers.tex b/source/containers.tex index c2b3a424fa..39d1107df5 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -2705,7 +2705,7 @@ \pnum A type \tcode{X} meets the \defnadj{associative}{container} requirements if \tcode{X} meets all the requirements of an allocator-aware -container\iref{container.requirements.general} and +container\iref{container.reqmts} and the following types, statements, and expressions are well-formed and have the specified semantics, except that for @@ -4204,7 +4204,7 @@ A type \tcode{X} meets the \defnadj{unordered associative}{container} requirements if \tcode{X} meets all the requirements of -an allocator-aware container\iref{container.requirements.general} and +an allocator-aware container\iref{container.reqmts} and the following types, statements, and expressions are well-formed and have the specified semantics, except that for \tcode{unordered_map} and \tcode{unordered_multimap}, @@ -4675,7 +4675,7 @@ \begin{itemdescr} \pnum \effects -In addition to the container requirements\iref{container.requirements.general}, +In addition to the container requirements\iref{container.reqmts}, copies the hash function, predicate, and maximum load factor. \pnum diff --git a/source/iostreams.tex b/source/iostreams.tex index f8d884ff15..10fe61d276 100644 --- a/source/iostreams.tex +++ b/source/iostreams.tex @@ -8333,7 +8333,7 @@ \pnum \constraints \tcode{SAlloc} is a type that -qualifies as an allocator\iref{container.requirements.general}. +qualifies as an allocator\iref{container.reqmts}. \pnum \effects diff --git a/source/strings.tex b/source/strings.tex index ccc85dcf88..66fc8b2094 100644 --- a/source/strings.tex +++ b/source/strings.tex @@ -2374,7 +2374,7 @@ \tcode{basic_string} uses an object of type \tcode{Allocator} to allocate and free storage for the contained \tcode{charT} objects as needed. The \tcode{Allocator} object used is -obtained as described in \ref{container.requirements.general}. +obtained as described in \ref{container.reqmts}. In every specialization \tcode{basic_string}, the type \tcode{traits} shall meet the character traits requirements\iref{char.traits}. @@ -2382,7 +2382,7 @@ Every specialization \tcode{basic_string} is an allocator-aware container, but does not use the allocator's \tcode{construct} and \tcode{destroy} -member functions\iref{container.requirements.general}. +member functions\iref{container.requirements.pre}. \end{note} \begin{note} The program is ill-formed if \tcode{traits::char_type} @@ -2569,7 +2569,8 @@ \pnum \constraints \tcode{Allocator} is a type -that qualifies as an allocator\iref{container.requirements.general}. + +that qualifies as an allocator\iref{container.reqmts}. \begin{note} This affects class template argument deduction. \end{note} @@ -2588,7 +2589,7 @@ \pnum \constraints \tcode{Allocator} is a type -that qualifies as an allocator\iref{container.requirements.general}. +that qualifies as an allocator\iref{container.reqmts}. \begin{note} This affects class template argument deduction. \end{note} @@ -2608,7 +2609,7 @@ \pnum \constraints \tcode{InputIterator} is a type that qualifies as an input -iterator\iref{container.requirements.general}. +iterator\iref{container.reqmts}. \pnum \effects @@ -2672,7 +2673,7 @@ \pnum \constraints \tcode{InputIterator} is a type that qualifies as an input iterator, -and \tcode{Allocator} is a type that qualifies as an allocator\iref{container.requirements.general}. +and \tcode{Allocator} is a type that qualifies as an allocator\iref{container.reqmts}. \end{itemdescr} \begin{itemdecl} @@ -2695,7 +2696,7 @@ \pnum \constraints \tcode{Allocator} is a type that qualifies as -an allocator\iref{container.requirements.general}. +an allocator\iref{container.reqmts}. \end{itemdescr} \indexlibrarymember{operator=}{basic_string}% @@ -3377,7 +3378,7 @@ \pnum \constraints \tcode{InputIterator} is a type that qualifies as an input -iterator\iref{container.requirements.general}. +iterator\iref{container.reqmts}. \pnum \effects @@ -3582,7 +3583,7 @@ \pnum \constraints \tcode{InputIterator} is a type that qualifies as an input -iterator\iref{container.requirements.general}. +iterator\iref{container.reqmts}. \pnum \effects @@ -3800,7 +3801,7 @@ \pnum \constraints \tcode{InputIterator} is a type that qualifies as an input -iterator\iref{container.requirements.general}. +iterator\iref{container.reqmts}. \pnum \expects @@ -4198,7 +4199,7 @@ \pnum \constraints \tcode{InputIterator} is a type that qualifies as an input -iterator\iref{container.requirements.general}. +iterator\iref{container.reqmts}. \pnum \effects From 1be4801ac1f90aca9a8f5804a48e8bcd082f5bb9 Mon Sep 17 00:00:00 2001 From: lprv <100177227+lprv@users.noreply.github.com> Date: Thu, 1 Jun 2023 20:57:05 +0200 Subject: [PATCH 007/171] [lib] Refer to exposition-only function templates as templates, not functions (#6265) * [tuple.apply]/1, /4 * [expected.object.assign]/1 * [iterator.cust.swap]/2 * [specialized.algorithms.general]/3 --- source/algorithms.tex | 3 ++- source/iterators.tex | 2 +- source/utilities.tex | 6 +++--- 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/source/algorithms.tex b/source/algorithms.tex index ed1d8d1cf0..b6a4acd763 100644 --- a/source/algorithms.tex +++ b/source/algorithms.tex @@ -10768,7 +10768,8 @@ before allowing the exception to propagate. \pnum -Some algorithms specified in \ref{specialized.algorithms} make use of the exposition-only function +Some algorithms specified in \ref{specialized.algorithms} +make use of the exposition-only function template \tcode{\placeholdernc{voidify}}: \begin{codeblock} template diff --git a/source/iterators.tex b/source/iterators.tex index d4f5e240ae..0a3eb7dd14 100644 --- a/source/iterators.tex +++ b/source/iterators.tex @@ -1170,7 +1170,7 @@ arguments. \pnum -Let \exposid{iter-exchange-move} be the exposition-only function: +Let \exposid{iter-exchange-move} be the exposition-only function template: \begin{itemdecl} template constexpr iter_value_t @\exposid{iter-exchange-move}@(X&& x, Y&& y) diff --git a/source/utilities.tex b/source/utilities.tex index 1b40eb3974..cc7b733d65 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -2639,7 +2639,7 @@ \begin{itemdescr} \pnum \effects -Given the exposition-only function: +Given the exposition-only function template: \begin{codeblock} namespace std { template @@ -2681,7 +2681,7 @@ \pnum \effects -Given the exposition-only function: +Given the exposition-only function template: \begin{codeblock} namespace std { template @@ -7735,7 +7735,7 @@ \rSec3[expected.object.assign]{Assignment} \pnum -This subclause makes use of the following exposition-only function: +This subclause makes use of the following exposition-only function template: \begin{codeblock} template constexpr void @\exposid{reinit-expected}@(T& newval, U& oldval, Args&&... args) { // \expos From c0685a584ea51d3e47381478a750729da3202b37 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?G=C3=A9ry=20Ogam?= Date: Tue, 13 Jun 2023 18:21:59 +0200 Subject: [PATCH 008/171] =?UTF-8?q?[basic.lval]=20Reword=20the=20misused?= =?UTF-8?q?=20term=20=E2=80=98classifications=E2=80=99=20(#4913)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/expressions.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/expressions.tex b/source/expressions.tex index 8026d15967..617ac9f742 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -158,7 +158,7 @@ \end{itemize} \pnum -Every expression belongs to exactly one of the fundamental classifications in this +Every expression belongs to exactly one of the fundamental categories in this taxonomy: lvalue, xvalue, or prvalue. This property of an expression is called its \defn{value category}. \begin{note} @@ -178,7 +178,7 @@ glvalues are ``generalized'' lvalues, prvalues are ``pure'' rvalues, and xvalues are ``eXpiring'' lvalues. -Despite their names, these terms classify expressions, not values. +Despite their names, these terms apply to expressions, not values. \end{note} \pnum From ae4cba4dc8ee2437f39a451268ad6bc924076da0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Tue, 20 Jun 2023 13:29:38 +0100 Subject: [PATCH 009/171] [cover-wd] A more appropriate title, and better line spacing --- source/cover-wd.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/cover-wd.tex b/source/cover-wd.tex index 2da775b155..54d00f4b64 100644 --- a/source/cover-wd.tex +++ b/source/cover-wd.tex @@ -22,7 +22,7 @@ \vspace{2.5cm} \begin{center} \textbf{\Huge -Working Draft, Standard for Programming Language \Cpp{}} +Working Draft\\[2ex]Programming Languages --- \Cpp{}} \end{center} \vfill \textbf{Note: this is an early draft. It's known to be incomplet and From d544cfcaec7559fe3b40b81343293390d3727a2d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johel=20Ernesto=20Guerrero=20Pe=C3=B1a?= Date: Wed, 21 Jun 2023 18:52:12 -0400 Subject: [PATCH 010/171] [expected.void.obs] Fix index for specialization --- source/utilities.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/utilities.tex b/source/utilities.tex index cc7b733d65..c99d900ebc 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -9182,7 +9182,7 @@ \tcode{has_value()} is \tcode{true}. \end{itemdescr} -\indexlibrarymember{value}{expected}% +\indexlibrarymember{value}{expected}% \begin{itemdecl} constexpr void value() const &; \end{itemdecl} From 7e7afe0965e4e16ff651167212ea05ed9c0ef788 Mon Sep 17 00:00:00 2001 From: Eisenwave Date: Thu, 6 Jul 2023 12:45:54 +0200 Subject: [PATCH 011/171] [expr.mul] Add missing commas (#6366) --- source/expressions.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/expressions.tex b/source/expressions.tex index 617ac9f742..3623d50012 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -6133,9 +6133,9 @@ \tcode{\%} operator yields the remainder from the division of the first expression by the second. \indextext{zero!undefined division by}% -If the second operand of \tcode{/} or \tcode{\%} is zero the behavior is +If the second operand of \tcode{/} or \tcode{\%} is zero, the behavior is undefined. -For integral operands the \tcode{/} operator yields the algebraic quotient with +For integral operands, the \tcode{/} operator yields the algebraic quotient with any fractional part discarded; \begin{footnote} This is often called truncation towards zero. From 384d36a0d30e6a8050e23f7193db40fb56ff4f06 Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Thu, 6 Jul 2023 20:45:10 +0100 Subject: [PATCH 012/171] [filebuf.virtuals] fix "if width if less than zero" typo --- source/iostreams.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/iostreams.tex b/source/iostreams.tex index 10fe61d276..bf9dbe8f30 100644 --- a/source/iostreams.tex +++ b/source/iostreams.tex @@ -11276,7 +11276,7 @@ ``Write any unshift sequence'' means, if \tcode{width} -if less than zero then call +is less than zero then call \tcode{a_codecvt.unshift(state, xbuf, xbuf+XSIZE, xbuf_end)} and output the resulting unshift sequence. The function determines one of three values for the From caf3254dff4d4764c073b4c2c87fc8785350b141 Mon Sep 17 00:00:00 2001 From: Hewill Kang <67143766+hewillk@users.noreply.github.com> Date: Mon, 10 Jul 2023 14:03:27 +0800 Subject: [PATCH 013/171] [time.duration.general] Use code font for duration --- source/time.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/time.tex b/source/time.tex index ef7289cb8f..238efa39a0 100644 --- a/source/time.tex +++ b/source/time.tex @@ -1279,7 +1279,7 @@ those thrown by the indicated operations on their representations. \pnum -The defaulted copy constructor of duration shall be a +The defaulted copy constructor of \tcode{duration} shall be a constexpr function if and only if the required initialization of the member \tcode{rep_} for copy and move, respectively, would be constexpr-suitable\iref{dcl.constexpr}. From 964015779245341d64d93bbd0d1e11f050b32e70 Mon Sep 17 00:00:00 2001 From: Hewill Kang <67143766+hewillk@users.noreply.github.com> Date: Mon, 10 Jul 2023 18:53:10 +0800 Subject: [PATCH 014/171] [time.duration.cons] Fix duplicate definition in example (#6372) --- source/time.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/time.tex b/source/time.tex index 238efa39a0..34911e8f7e 100644 --- a/source/time.tex +++ b/source/time.tex @@ -1313,7 +1313,7 @@ \begin{example} \begin{codeblock} duration d(3); // OK -duration d(3.5); // error +duration d2(3.5); // error \end{codeblock} \end{example} From 23712f5dd8c70c57e123f39f312169f3c1952dd7 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 17:12:47 -0700 Subject: [PATCH 015/171] CWG170 Pointer-to-member conversions --- source/expressions.tex | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/source/expressions.tex b/source/expressions.tex index 3623d50012..ef984c70c9 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -1051,7 +1051,10 @@ ambiguous\iref{class.member.lookup}, or virtual\iref{class.mi} base class of \tcode{D}, or a base class of a virtual base class of \tcode{D}, a program that necessitates this conversion is ill-formed. -The result of the conversion refers to the same member as the pointer to +If class \tcode{D} does not contain the original member and +is not a base class of the class containing the original member, +the behavior is undefined. Otherwise, +the result of the conversion refers to the same member as the pointer to member before the conversion took place, but it refers to the base class member as if it were a member of the derived class. The result refers to the member in \tcode{D}'s instance of \tcode{B}. Since the result has @@ -4139,7 +4142,7 @@ exists\iref{conv.mem}, the program is ill-formed. The null member pointer value\iref{conv.mem} is converted to the null member pointer value of the destination type. If class \tcode{B} -contains the original member, or is a base or derived class of the class +contains the original member, or is a base class of the class containing the original member, the resulting pointer to member points to the original member. Otherwise, the behavior is undefined. \begin{note} From edfbb70925dcceb908c403963162688e8f7e55b3 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 17:38:51 -0700 Subject: [PATCH 016/171] CWG1353 Array and variant members and deleted special member functions --- source/classes.tex | 84 ++++++++++++++++++++-------------------------- 1 file changed, 37 insertions(+), 47 deletions(-) diff --git a/source/classes.tex b/source/classes.tex index c17568610b..d508980432 100644 --- a/source/classes.tex +++ b/source/classes.tex @@ -1247,38 +1247,34 @@ \pnum A defaulted default constructor for class \tcode{X} is defined as deleted if: \begin{itemize} -\item \tcode{X} is a union that has a variant member -with a non-trivial default constructor and -no variant member of \tcode{X} has a default member initializer, - -\item \tcode{X} is a non-union class that has a variant member \tcode{M} -with a non-trivial default constructor and -no variant member of the anonymous union containing \tcode{M} -has a default member initializer, - \item any non-static data member with no default member initializer\iref{class.mem} is of reference type, -\item any non-variant non-static data member of const-qualified type (or array -thereof) with no \grammarterm{brace-or-equal-initializer} +\item any non-variant non-static data member of const-qualified type +(or possibly multi-dimensional array thereof) +with no \grammarterm{brace-or-equal-initializer} is not const-default-constructible\iref{dcl.init}, \item \tcode{X} is a union and all of its variant members are of const-qualified -type (or array thereof), +type (or possibly multi-dimensional array thereof), \item \tcode{X} is a non-union class and all members of any anonymous union member are -of const-qualified type (or array thereof), +of const-qualified type (or possibly multi-dimensional array thereof), \item any potentially constructed subobject, except for a non-static data member -with a \grammarterm{brace-or-equal-initializer}, has -class type \tcode{M} (or array thereof) and either \tcode{M} -has no default constructor or overload resolution\iref{over.match} -as applied to find \tcode{M}'s corresponding -constructor results in an ambiguity or in a function that is deleted or -inaccessible from the defaulted default constructor, or - -\item any potentially constructed subobject has a type -with a destructor that is deleted or inaccessible from the defaulted default +with a \grammarterm{brace-or-equal-initializer} +or a variant member of a union where another non-static data member +has a \grammarterm{brace-or-equal-initializer}, +has class type \tcode{M} (or possibly multi-dimensional array thereof) +and overload resolution\iref{over.match} +as applied to find \tcode{M}'s corresponding constructor +either does not result in a usable candidate\iref{over.match.general} +or, in the case of a variant member, selects a non-trivial function, or + +\item any potentially constructed subobject has +class type \tcode{M} (or possibly multi-dimensional array thereof) and +\tcode{M} has +a destructor that is deleted or inaccessible from the defaulted default constructor. \end{itemize} @@ -1543,18 +1539,16 @@ \tcode{X} is defined as deleted\iref{dcl.fct.def.delete} if \tcode{X} has: \begin{itemize} \item a potentially constructed subobject of type - \tcode{M} (or array thereof) that cannot be copied/moved because + \tcode{M} (or possibly multi-dimensional array thereof) for which overload resolution\iref{over.match}, as applied to find - \tcode{M}'s - corresponding constructor, results in an ambiguity or - a function that is deleted or inaccessible from the - defaulted constructor, - -\item a variant member whose corresponding constructor - as selected by overload resolution is non-trivial, - -\item any potentially constructed subobject of a type - with a destructor that is deleted or inaccessible from the defaulted + \tcode{M}'s corresponding constructor, + either does not result in a usable candidate\iref{over.match.general} or, + in the case of a variant member, selects a non-trivial function, + +\item any potentially constructed subobject of + class type \tcode{M} (or possibly multi-dimensional array thereof) + where \tcode{M} has + a destructor that is deleted or inaccessible from the defaulted constructor, or, \item for the copy constructor, a non-static data member of rvalue reference type. @@ -1823,21 +1817,19 @@ A defaulted copy/move assignment operator for class \tcode{X} is defined as deleted if \tcode{X} has: \begin{itemize} -\item a variant member with a non-trivial corresponding assignment operator and - \tcode{X} is a union-like class, or - \item a non-static data member of \keyword{const} non-class - type (or array thereof), or + type (or possibly multi-dimensional array thereof), or \item a non-static data member of reference type, or \item a direct non-static data member of class type \tcode{M} - (or array thereof) or a direct base class \tcode{M} + (or possibly multi-dimensional array thereof) or + a direct base class \tcode{M} that cannot be copied/moved because overload resolution \iref{over.match}, as applied to find \tcode{M}'s corresponding - assignment operator, results in an ambiguity or - a function that is deleted or inaccessible from the - defaulted assignment operator. + assignment operator, + either does not result in a usable candidate\iref{over.match.general} or, + in the case of a variant member, selects a non-trivial function. \end{itemize} \begin{note} @@ -2070,13 +2062,11 @@ A defaulted destructor for a class \tcode{X} is defined as deleted if: \begin{itemize} -\item \tcode{X} is a union-like class that has a variant - member with a non-trivial destructor, - \item any potentially constructed subobject has class type - \tcode{M} (or array thereof) and - \tcode{M} has a deleted destructor or a destructor - that is inaccessible from the defaulted destructor, + \tcode{M} (or possibly multi-dimensional array thereof) and + \tcode{M} has a destructor that is deleted or + is inaccessible from the defaulted destructor or, + in the case of a variant member, is non-trivial, \item or, for a virtual destructor, lookup of the non-array deallocation function results in an ambiguity or in a function that is deleted or From 9edd68233061f92035cd2e8cf02febacb5abe923 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 18:14:20 -0700 Subject: [PATCH 017/171] CWG1642 Missing requirements for prvalue operands --- source/declarations.tex | 5 +++-- source/expressions.tex | 50 +++++++++++++++++++++++++++-------------- 2 files changed, 36 insertions(+), 19 deletions(-) diff --git a/source/declarations.tex b/source/declarations.tex index fed6acc54f..d62abb2d05 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -4696,8 +4696,9 @@ \item Otherwise, the initial value of the object being initialized is the (possibly converted) value of the initializer expression. -A standard conversion sequence\iref{conv} will be used, if necessary, -to convert the initializer expression to the cv-unqualified version of +A standard conversion sequence\iref{conv} is used +to convert the initializer expression to +a prvalue of the cv-unqualified version of the destination type; no user-defined conversions are considered. If the conversion cannot diff --git a/source/expressions.tex b/source/expressions.tex index ef984c70c9..a55f4fc35c 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -246,7 +246,7 @@ \pnum Whenever a glvalue appears as an operand of an operator that -expects a prvalue for that operand, the +requires a prvalue for that operand, the lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array}, or function-to-pointer\iref{conv.func} standard conversions are applied to convert the expression to a prvalue. @@ -518,7 +518,8 @@ conversions. \end{note} A standard conversion sequence will be applied to -an expression if necessary to convert it to a required destination type. +an expression if necessary to convert it to an expression having +a required destination type and value category. \pnum \begin{note} @@ -1120,6 +1121,10 @@ which are defined as follows: \begin{itemize} +\item The lvalue-to-rvalue conversion\iref{conv.lval} +is applied to each operand and +the resulting prvalues are used in place of the original operands +for the remainder of this section. \item If either operand is of scoped enumeration type\iref{dcl.enum}, no conversions are performed; if the other operand does not have the same type, the expression is ill-formed. @@ -3169,10 +3174,10 @@ The postfix expression shall have function type or function pointer type. For a call to a non-member function or to a static member function, -the postfix expression shall either be an lvalue that refers to a +the postfix expression shall be either an lvalue that refers to a function (in which case the function-to-pointer standard conversion\iref{conv.func} is suppressed on the postfix expression), -or have function pointer type. +or a prvalue of function pointer type. \pnum If the selected @@ -4611,14 +4616,16 @@ \pnum \indextext{operator!unary plus}% -The operand of the unary \tcode{+} operator shall have arithmetic, unscoped +The operand of the unary \tcode{+} operator shall be a prvalue of +arithmetic, unscoped enumeration, or pointer type and the result is the value of the argument. Integral promotion is performed on integral or enumeration operands. The type of the result is the type of the promoted operand. \pnum \indextext{operator!unary minus}% -The operand of the unary \tcode{-} operator shall have arithmetic or unscoped +The operand of the unary \tcode{-} operator shall be a prvalue of +arithmetic or unscoped enumeration type and the result is the negative of its operand. Integral promotion is performed on integral or enumeration operands. The negative of an unsigned quantity is computed by subtracting its value from $2^n$, @@ -4639,7 +4646,8 @@ \pnum \indextext{operator!ones' complement}% -The operand of the \tcode{\~{}} operator shall have integral or unscoped enumeration type. +The operand of the \tcode{\~{}} operator shall be a prvalue of +integral or unscoped enumeration type. Integral promotions are performed. The type of the result is the type of the promoted operand. % FIXME: [basic.fundamental]/p5 uses $x_i$; [expr] uses $\tcode{x}_i$. @@ -5655,8 +5663,8 @@ that consists of empty square brackets can follow the \keyword{delete} keyword if the \grammarterm{lambda-expression} is enclosed in parentheses. \end{footnote} -The operand shall be of pointer to object type or of class type. If of -class type, the operand is contextually implicitly converted\iref{conv} +If the operand is of +class type, it is contextually implicitly converted\iref{conv} to a pointer to object type. \begin{footnote} @@ -5664,6 +5672,7 @@ cannot be deleted using a pointer of type \tcode{\keyword{void}*} because \keyword{void} is not an object type. \end{footnote} +Otherwise, it shall be a prvalue of pointer to object type. The \grammarterm{delete-expression} has type \keyword{void}. @@ -6020,6 +6029,7 @@ \pnum The binary operator \tcode{.*} binds its second operand, which shall be +a prvalue of type ``pointer to member of \tcode{T}'' to its first operand, which shall be a glvalue of @@ -6029,6 +6039,7 @@ \pnum The binary operator \tcode{->*} binds its second operand, which shall be +a prvalue of type ``pointer to member of \tcode{T}'' to its first operand, which shall be of type ``pointer to \tcode{U}'' where \tcode{U} is either \tcode{T} or @@ -6152,9 +6163,14 @@ \indextext{operator!additive} \pnum -The additive operators \tcode{+} and \tcode{-} group left-to-right. The -usual arithmetic conversions\iref{expr.arith.conv} are performed for operands of arithmetic or -enumeration type. +The additive operators \tcode{+} and \tcode{-} group left-to-right. +Each operand shall be a prvalue. +If both operands have arithmetic or unscoped enumeration type, +the usual arithmetic conversions\iref{expr.arith.conv} are performed. +Otherwise, if one operand has arithmetic or unscoped enumeration type, +integral promotion is applied\iref{conv.prom} to that operand. +A converted or promoted operand is used in place of +the corresponding original operand for the remainder of this section. \indextext{operator!addition}% \indextext{addition operator|see{operator, addition}}% @@ -6171,14 +6187,14 @@ \end{bnf} \indextext{incomplete}% -For addition, either both operands shall have arithmetic or unscoped enumeration +For addition, either both operands shall have arithmetic type, or one operand shall be a pointer to a completely-defined object -type and the other shall have integral or unscoped enumeration type. +type and the other shall have integral type. \pnum For subtraction, one of the following shall hold: \begin{itemize} -\item both operands have arithmetic or unscoped enumeration type; or +\item both operands have arithmetic type; or \item \indextext{arithmetic!pointer}% @@ -6186,7 +6202,7 @@ versions of the same completely-defined object type; or \item the left operand is a pointer to a completely-defined object type -and the right operand has integral or unscoped enumeration type. +and the right operand has integral type. \end{itemize} \pnum @@ -6289,7 +6305,7 @@ shift-expression \terminal{>>} additive-expression \end{bnf} -The operands shall be of integral or unscoped enumeration type and integral +The operands shall be prvalues of integral or unscoped enumeration type and integral promotions are performed. The type of the result is that of the promoted left operand. \indextext{left shift!undefined}% From 9e751a85dcc42fa224576d3b93556411da166307 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 18:23:36 -0700 Subject: [PATCH 018/171] CWG1973 Which parameter-declaration-clause in a lambda-expression? --- source/expressions.tex | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/source/expressions.tex b/source/expressions.tex index a55f4fc35c..03e8c8602f 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -1803,10 +1803,10 @@ \end{note} \pnum -If a \grammarterm{lambda-declarator} does not include -a \grammarterm{parameter-declaration-clause}, -it is as if \tcode{()} were inserted -at the start of the \grammarterm{lambda-declarator}. +A \grammarterm{lambda-expression}{'s} \grammarterm{parameter-declaration-clause} +is the \grammarterm{parameter-declaration-clause} of +the \grammarterm{lambda-expression}{'s} \grammarterm{lambda-declarator}, if any, +or empty otherwise. If the \grammarterm{lambda-declarator} does not include a \grammarterm{trailing-return-type}, it is considered to be \tcode{-> \keyword{auto}}. @@ -1873,7 +1873,7 @@ inline function call operator (for a non-generic lambda) or function call operator template (for a generic lambda)\iref{over.call} whose parameters and return type -are described by the \grammarterm{lambda-expression}'s +are those of the \grammarterm{lambda-expression}{'s} \grammarterm{parameter-declaration-clause} and \grammarterm{trailing-return-type} respectively, and whose \grammarterm{template-parameter-list} consists of From 3c75a4eb72d5a03143acd612a45808874161b7bf Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 18:41:47 -0700 Subject: [PATCH 019/171] CWG2485 Bit-fields in integral promotions --- source/expressions.tex | 54 +++++++++++++++++++++++++++--------------- 1 file changed, 35 insertions(+), 19 deletions(-) diff --git a/source/expressions.tex b/source/expressions.tex index 03e8c8602f..b78a4d5af5 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -829,29 +829,22 @@ \rSec2[conv.prom]{Integral promotions} +\pnum +For the purposes of \ref{conv.prom}, +a \defnadj{converted}{bit-field} is a prvalue that is the result of +an lvalue-to-rvalue conversion\iref{conv.lval} applied to +a bit-field\iref{class.bit}. + \pnum \indextext{promotion!integral}% -A prvalue of an integer type other than \keyword{bool}, \keyword{char8_t}, \keyword{char16_t}, +A prvalue that is not a converted bit-field and has an integer type other than +\keyword{bool}, \keyword{char8_t}, \keyword{char16_t}, \keyword{char32_t}, or \keyword{wchar_t} whose integer conversion rank\iref{conv.rank} is less than the rank of \keyword{int} can be converted to a prvalue of type \keyword{int} if \keyword{int} can represent all the values of the source type; otherwise, the source prvalue can be converted to a prvalue of type \tcode{\keyword{unsigned} \keyword{int}}. -\pnum -\indextext{type!underlying!\idxcode{wchar_t}}% -\indextext{type!underlying!\idxcode{char16_t}}% -\indextext{type!underlying!\idxcode{char32_t}}% -A prvalue of type \keyword{char8_t}, \keyword{char16_t}, \keyword{char32_t}, or -\keyword{wchar_t}\iref{basic.fundamental} can be converted to a prvalue -of the first of the following types that can represent all the values of -its underlying type: \keyword{int}, \tcode{\keyword{unsigned} \keyword{int}}, \tcode{\keyword{long} \keyword{int}}, -\tcode{\keyword{unsigned} \keyword{long} \keyword{int}}, \tcode{\keyword{long} \keyword{long} \keyword{int}}, -or \tcode{\keyword{unsigned} \keyword{long} \keyword{long} \keyword{int}}. If none of the types in that list can -represent all the values of its underlying type, a prvalue of type -\keyword{char8_t}, \keyword{char16_t}, \keyword{char32_t}, or \keyword{wchar_t} can be converted -to a prvalue of its underlying type. - \pnum \indextext{type!underlying!enumeration}% A prvalue of an unscoped enumeration type whose underlying type is not @@ -871,15 +864,38 @@ if integral promotion can be applied to its underlying type, a prvalue of an unscoped enumeration type whose underlying type is fixed can also be converted to a prvalue of the promoted underlying type. +\begin{note} +A converted bit-field of enumeration type is treated as +any other value of that type for promotion purposes. +\end{note} \pnum -A prvalue for an integral bit-field\iref{class.bit} can be converted +A converted bit-field of integral type can be converted to a prvalue of type \keyword{int} if \keyword{int} can represent all the values of the bit-field; otherwise, it can be converted to \tcode{\keyword{unsigned} \keyword{int}} if \tcode{\keyword{unsigned} \keyword{int}} can represent all the -values of the bit-field. If the bit-field is larger yet, no integral -promotion applies to it. If the bit-field has enumeration type, it is -treated as any other value of that type for promotion purposes. +values of the bit-field. + +\pnum +\indextext{type!underlying!\idxcode{wchar_t}}% +\indextext{type!underlying!\idxcode{char16_t}}% +\indextext{type!underlying!\idxcode{char32_t}}% +A prvalue of type +\keyword{char8_t}, \keyword{char16_t}, \keyword{char32_t}, or +\keyword{wchar_t}\iref{basic.fundamental} +(including a converted bit-field that was not +already promoted to \keyword{int} or \tcode{\keyword{unsigned} \keyword{int}} +according to the rules above) +can be converted to a prvalue +of the first of the following types that can represent all the values of +its underlying type: +\keyword{int}, +\tcode{\keyword{unsigned} \keyword{int}}, +\tcode{\keyword{long} \keyword{int}}, +\tcode{\keyword{unsigned} \keyword{long} \keyword{int}}, +\tcode{\keyword{long} \keyword{long} \keyword{int}}, +\tcode{\keyword{unsigned} \keyword{long} \keyword{long} \keyword{int}}, or +its underlying type. \pnum \indextext{promotion!bool to int}% From 3d711d36346d5d56d46f0f766f358af7b77e39ea Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 18:50:31 -0700 Subject: [PATCH 020/171] CWG2519 Object representation of a bit-field --- source/basic.tex | 21 +++++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/source/basic.tex b/source/basic.tex index e7d171d6fe..b9c3fd34ef 100644 --- a/source/basic.tex +++ b/source/basic.tex @@ -4637,15 +4637,28 @@ \pnum \label{term.object.representation}% The \defnx{object representation}{representation!object} -of an object of type \tcode{T} is the +of a complete object type \tcode{T} is the sequence of \placeholder{N} \tcode{\keyword{unsigned} \keyword{char}} objects taken up -by the object of type \tcode{T}, where \placeholder{N} equals +by a non-bit-field complete object of type \tcode{T}, +where \placeholder{N} equals \tcode{\keyword{sizeof}(T)}. The \defnx{value representation}{representation!value} -of an object of type \tcode{T} is the set of bits +of a type \tcode{T} is the set of bits +in the object representation of \tcode{T} that participate in representing a value of type \tcode{T}. +The object and value representation of +a non-bit-field complete object of type \tcode{T} are +the bytes and bits, respectively, of +the object corresponding to the object and value representation of its type. +The object representation of a bit-field object is +the sequence of \placeholder{N} bits taken up by the object, +where \placeholder{N} is the width of the bit-field\iref{class.bit}. +The value representation of a bit-field object is +the set of bits in the object representation that +participate in representing its value. \label{term.padding.bits}% -Bits in the object representation that are not part of the value representation +Bits in the object representation of a type or object that are +not part of the value representation are \defn{padding bits}. For trivially copyable types, the value representation is a set of bits in the object representation that determines a From b42c704e1bb10c222c7d9f6916a5b59e33e05753 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 18:52:32 -0700 Subject: [PATCH 021/171] CWG2542 Is a closure type a structural type? --- source/expressions.tex | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/source/expressions.tex b/source/expressions.tex index b78a4d5af5..960fce3abc 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -1869,7 +1869,8 @@ types of a \grammarterm{lambda-declarator} do not affect these associated namespaces and classes. \end{note} -The closure type is not an aggregate type\iref{dcl.init.aggr}. +The closure type is not an aggregate type\iref{dcl.init.aggr} and +not a structural type\iref{temp.param}. An implementation may define the closure type differently from what is described below provided this does not alter the observable behavior of the program other than by changing: From 11ffdbf8c058dc848bb67e300e4f332987e70fac Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 18:54:59 -0700 Subject: [PATCH 022/171] CWG2550 Type "reference to cv void" outside of a declarator --- source/declarations.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/declarations.tex b/source/declarations.tex index d62abb2d05..d367002888 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -2859,7 +2859,7 @@ A reference can be thought of as a name of an object. \end{note} \indextext{\idxcode{void\&}}% -A declarator that specifies the type +Forming the type ``reference to \cv{}~\keyword{void}'' is ill-formed. From d369c1279e922a269f0cbaf768dfdf98b1213fb8 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 18:57:25 -0700 Subject: [PATCH 023/171] CWG2552 Constant evaluation of non-defining variable declarations --- source/expressions.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/expressions.tex b/source/expressions.tex index 960fce3abc..4bf0a7b037 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -7373,7 +7373,7 @@ \item a control flow that passes through -a declaration of a variable with +a declaration of a block variable\iref{basic.scope.block} with static\iref{basic.stc.static} or thread\iref{basic.stc.thread} storage duration, unless that variable is usable in constant expressions; From a661ecaba419775ff8fc75a777ddefdda086ea09 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 19:03:53 -0700 Subject: [PATCH 024/171] CWG2663 Example for member redeclarations with using-declarations --- source/declarations.tex | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/source/declarations.tex b/source/declarations.tex index d367002888..586e2c14b0 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -7903,6 +7903,22 @@ \pnum If a declaration is named by two \grammarterm{using-declarator}s that inhabit the same class scope, the program is ill-formed. +\begin{example} +\begin{codeblock} +struct C { + int i; +}; + +struct D1 : C { }; +struct D2 : C { }; + +struct D3 : D1, D2 { + using D1::i; // OK, equivalent to \tcode{using C::i} + using D1::i; // error: duplicate + using D2::i; // error: duplicate, also names \tcode{C::i} +}; +\end{codeblock} +\end{example} \pnum \begin{note} @@ -7985,6 +8001,7 @@ using A::h; // error: conflicts using B::x; using A::x; // OK, hides \tcode{struct B::x} + using A::x; // OK, does not conflict with previous \tcode{using A::x} x = 99; // assigns to \tcode{A::x} struct x x1; // \tcode{x1} has class type \tcode{B::x} } From a282091ab13f16e966204c72a58200c1583611ae Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 19:06:04 -0700 Subject: [PATCH 025/171] CWG2683 Default arguments for member functions of templated nested classes --- source/declarations.tex | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/declarations.tex b/source/declarations.tex index 586e2c14b0..7838bf1840 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -4075,7 +4075,7 @@ \end{note} \pnum -Except for member functions of class templates, the +Except for member functions of templated classes, the default arguments in a member function definition that appears outside of the class definition are added to the set of default arguments provided by the @@ -4084,9 +4084,9 @@ copy or move constructor\iref{class.copy.ctor}, or copy or move assignment operator\iref{class.copy.assign} is so declared. -Default arguments for a member function of a class template +Default arguments for a member function of a templated class shall be specified on the initial declaration of the member -function within the class template. +function within the templated class. \begin{example} \begin{codeblock} class C { From 7f17f185e5178a895c65403fd969aed70fea2039 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 19:08:36 -0700 Subject: [PATCH 026/171] CWG2697 Deduction guides using abbreviated function syntax --- source/templates.tex | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/source/templates.tex b/source/templates.tex index edac0e2650..504f7cfa4a 100644 --- a/source/templates.tex +++ b/source/templates.tex @@ -2413,7 +2413,10 @@ The same restrictions apply to the \grammarterm{parameter-declaration-clause} of a deduction guide -as in a function declaration\iref{dcl.fct}. +as in a function declaration\iref{dcl.fct}, +except that a generic parameter type placeholder\iref{dcl.spec.auto} +shall not appear in the \grammarterm{parameter-declaration-clause} of +a deduction guide. The \grammarterm{simple-template-id} shall name a class template specialization. The \grammarterm{template-name} From 13355bab24eb046169bceb7454824abe8c718240 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 19:29:30 -0700 Subject: [PATCH 027/171] CWG2698 Using extended integer types with z suffix --- source/lex.tex | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/source/lex.tex b/source/lex.tex index a253a50bae..a26a086d5c 100644 --- a/source/lex.tex +++ b/source/lex.tex @@ -1317,21 +1317,27 @@ \end{floattable} \pnum -If an \grammarterm{integer-literal} +Except for \grammarterm{integer-literal}{s} containing +a \grammarterm{size-suffix}, +if the value of an \grammarterm{integer-literal} cannot be represented by any type in its list and an extended integer type\iref{basic.fundamental} can represent its value, it may have that extended integer type. If all of the types in the list for the \grammarterm{integer-literal} are signed, -the extended integer type shall be signed. +the extended integer type is signed. If all of the types in the list for the \grammarterm{integer-literal} are unsigned, -the extended integer type shall be unsigned. +the extended integer type is unsigned. If the list contains both signed and unsigned types, the extended integer type may be signed or unsigned. -A program is ill-formed -if one of its translation units contains an \grammarterm{integer-literal} -that cannot be represented by any of the allowed types. +If an \grammarterm{integer-literal} +cannot be represented by any of the allowed types, +the program is ill-formed. +\begin{note} +An \grammarterm{integer-literal} with a \tcode{z} or \tcode{Z} suffix +is ill-formed if it cannot be represented by \tcode{std::size_t}. +\end{note} \rSec2[lex.ccon]{Character literals} From 3588b7d3fab8e6d655769d61768682b23d493164 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 19:39:56 -0700 Subject: [PATCH 028/171] CWG2699 Inconsistency of throw-expression specification --- source/expressions.tex | 29 ++++++++++++----------------- 1 file changed, 12 insertions(+), 17 deletions(-) diff --git a/source/expressions.tex b/source/expressions.tex index 4bf0a7b037..0d96760466 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -7082,19 +7082,24 @@ A \grammarterm{throw-expression} is of type \keyword{void}. \pnum -Evaluating a \grammarterm{throw-expression} with an operand throws an -exception\iref{except.throw}; the type of the exception object is determined by removing -any top-level \grammarterm{cv-qualifier}{s} from the static type of the -operand and adjusting the type -from ``array of \tcode{T}'' or function type \tcode{T} -to ``pointer to \tcode{T}''. +A \grammarterm{throw-expression} with an operand throws an +exception\iref{except.throw}. +The array-to-pointer\iref{conv.array} and function-to-pointer\iref{conv.func} +standard conversions are performed on the operand. +The type of the exception object is determined by removing +any top-level \grammarterm{cv-qualifier}{s} from the type of the +(possibly converted) operand. \pnum \indextext{exception handling!rethrow}% A \grammarterm{throw-expression} with no operand rethrows the currently handled exception\iref{except.handle}. -The exception is reactivated with the existing exception object; +\indextext{exception handling!terminate called@\tcode{terminate} called}% +\indextext{\idxcode{terminate}!called}% +If no exception is presently being handled, +the function \tcode{std::terminate} is invoked\iref{except.terminate}. +Otherwise, the exception is reactivated with the existing exception object; no new exception object is created. The exception is no longer considered to be caught. \begin{example} @@ -7110,16 +7115,6 @@ \end{codeblock} \end{example} -\pnum -\indextext{exception handling!rethrow}% -\indextext{exception handling!terminate called@\tcode{terminate} called}% -\indextext{\idxcode{terminate}!called}% -If no exception is presently being handled, -evaluating a -\grammarterm{throw-expression} -with no operand calls -\tcode{std::\brk{}terminate()}\iref{except.terminate}. - \rSec2[expr.ass]{Assignment and compound assignment operators}% \indextext{expression!assignment and compound assignment} From f4bb20593b16bcb2a3ff494787fb206d2e9434a6 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 19:42:00 -0700 Subject: [PATCH 029/171] CWG2708 Parenthesized initialization of arrays --- source/declarations.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/declarations.tex b/source/declarations.tex index 7838bf1840..25fe819961 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -4489,7 +4489,7 @@ If no initializer is specified for an object, the object is default-initialized. \pnum -If the entity being initialized does not have class type, the +If the entity being initialized does not have class or array type, the \grammarterm{expression-list} in a parenthesized initializer shall be a single expression. From e495b95b0b55e3912d309eea15b14e3fe0ba8754 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 19:51:09 -0700 Subject: [PATCH 030/171] CWG2710 Loops in constant expressions --- source/expressions.tex | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/source/expressions.tex b/source/expressions.tex index 0d96760466..7336428df5 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -7553,6 +7553,12 @@ \item a \keyword{goto} statement\iref{stmt.goto}. +\begin{note} +A \keyword{goto} statement introduced by equivalence\iref{stmt.stmt} +is not in scope. +For example, a \keyword{while} statement\iref{stmt.while} +can be executed during constant evaluation. +\end{note} \end{itemize} It is unspecified whether $E$ is a core constant expression From 19f42f6e3fba08bf5ae87698114c8edef93bcdc0 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 20:52:39 -0700 Subject: [PATCH 031/171] CWG2711 Source for copy-initializing the exception object --- source/exceptions.tex | 7 ++++--- source/expressions.tex | 2 ++ 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/source/exceptions.tex b/source/exceptions.tex index f7ce5ae44c..8dbd0304ef 100644 --- a/source/exceptions.tex +++ b/source/exceptions.tex @@ -257,13 +257,14 @@ \pnum Throwing an exception -copy-initializes\iref{dcl.init,class.copy.ctor} a temporary object, +initializes a temporary object, called the \defnx{exception object}{exception handling!exception object}. If the type of the exception object would be -an incomplete type, +an incomplete type\iref{basic.types.general}, an abstract class type\iref{class.abstract}, -or a pointer to an incomplete type other than \cv{}~\keyword{void} +or a pointer to an incomplete type other than +\cv{}~\keyword{void}\iref{basic.compound} the program is ill-formed. \pnum diff --git a/source/expressions.tex b/source/expressions.tex index 7336428df5..c5f29d1799 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -7089,6 +7089,8 @@ The type of the exception object is determined by removing any top-level \grammarterm{cv-qualifier}{s} from the type of the (possibly converted) operand. +The exception object is copy-initialized\iref{dcl.init.general} +from the (possibly converted) operand. \pnum \indextext{exception handling!rethrow}% From b3b0a0bffd2a6dfc77a2c5e60ed6d032ac1b2c99 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 20:55:21 -0700 Subject: [PATCH 032/171] CWG2712 Simplify restrictions on built-in assignment operator candidates --- source/overloading.tex | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-) diff --git a/source/overloading.tex b/source/overloading.tex index d0698b19ea..749b73c308 100644 --- a/source/overloading.tex +++ b/source/overloading.tex @@ -833,15 +833,8 @@ \end{example} \pnum -For the built-in assignment operators, conversions of the left -operand are restricted as follows: -\begin{itemize} -\item -no temporaries are introduced to hold the left operand, and -\item -no user-defined conversions are applied to the left operand to achieve -a type match with the left-most parameter of a built-in candidate. -\end{itemize} +For the first parameter of the built-in assignment operators, +only standard conversion sequences\iref{over.ics.scs} are considered. \pnum For all other operators, no such restrictions apply. From a75c7bf048242dfbd025ad021deec93f2d4e8c87 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 21:08:29 -0700 Subject: [PATCH 033/171] CWG2713 Initialization of reference-to-aggregate from designated initializer list --- source/declarations.tex | 10 ++++++++-- source/overloading.tex | 3 ++- 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/source/declarations.tex b/source/declarations.tex index 25fe819961..08eeebfc97 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -5739,7 +5739,8 @@ \begin{itemize} \item If the \grammarterm{braced-init-list} -contains a \grammarterm{designated-initializer-list}, +contains a \grammarterm{designated-initializer-list} and +\tcode{T} is not a reference type, \tcode{T} shall be an aggregate class. The ordered \grammarterm{identifier}{s} in the \grammarterm{designator}{s} @@ -5863,7 +5864,9 @@ \end{example} \item Otherwise, if -the initializer list has a single element of type \tcode{E} and either +the initializer list +is not a \grammarterm{designated-initializer-list} and +has a single element of type \tcode{E} and either \tcode{T} is not a reference type or its referenced type is reference-related to \tcode{E}, the object or reference is initialized from that element (by copy-initialization for copy-list-initialization, @@ -5908,6 +5911,9 @@ struct A { } a; struct B { explicit B(const A&); }; const B& b2{a}; // error: cannot copy-list-initialize \tcode{B} temporary from \tcode{A} + +struct C { int x; }; +C&& c = { .x = 1 }; // OK \end{codeblock} \end{example} diff --git a/source/overloading.tex b/source/overloading.tex index 749b73c308..edf9542eaa 100644 --- a/source/overloading.tex +++ b/source/overloading.tex @@ -2356,7 +2356,8 @@ expression and special rules apply for converting it to a parameter type. \pnum -If the initializer list is a \grammarterm{designated-initializer-list}, +If the initializer list is a \grammarterm{designated-initializer-list} +and the parameter is not a reference, a conversion is only possible if the parameter has an aggregate type that can be initialized from the initializer list From 5b593448f2e56cb51aa227ec05ed42b108198f27 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 21:32:34 -0700 Subject: [PATCH 034/171] CWG2715 "calling function" for parameter initialization may not exist [expr.call] Add Oxford comma in example. --- source/expressions.tex | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/source/expressions.tex b/source/expressions.tex index c5f29d1799..069585adc0 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -3291,15 +3291,17 @@ lifetime of a parameter ends when the function in which it is defined returns or at the end of the enclosing full-expression. The initialization and destruction of each parameter occurs -within the context of the calling function. +within the context of the full-expression\iref{intro.execution} +where the function call appears. \begin{example} -The access of the constructor, conversion functions or destructor is -checked at the point of call in the calling function. If a constructor -or destructor for a function parameter throws an exception, the search -for a handler starts in the calling function; in -particular, if the function called has a \grammarterm{function-try-block}\iref{except.pre} -with a handler that can handle the exception, -this handler is not considered. +The access\iref{class.access.general} of the +constructor, conversion functions, or destructor is +checked at the point of call. If a constructor +or destructor for a function parameter throws an exception, +any \grammarterm{function-try-block}\iref{except.pre} +of the called function +with a handler that can handle the exception +is not considered. \end{example} \pnum From be6d0b10fe355ce73dfcb35a99cd51337c003fdf Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 21:39:47 -0700 Subject: [PATCH 035/171] CWG2716 Rule about self-or-base conversion is normatively redundant --- source/classes.tex | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/source/classes.tex b/source/classes.tex index d508980432..39c538ecbd 100644 --- a/source/classes.tex +++ b/source/classes.tex @@ -2479,17 +2479,16 @@ returning \grammarterm{conversion-type-id}''. \pnum -A conversion function is never used to convert a (possibly cv-qualified) object -to the (possibly cv-qualified) same object type (or a reference to it), -to a (possibly cv-qualified) base class of that type (or a reference to it), +\begin{note} +A conversion function is never invoked for +implicit or explicit conversions of an object +to the same object type (or a reference to it), +to a base class of that type (or a reference to it), or to \cv{}~\keyword{void}. -\begin{footnote} -These conversions are considered -as standard conversions for the purposes of overload resolution\iref{over.best.ics,over.ics.ref} and therefore initialization\iref{dcl.init} and explicit casts\iref{expr.static.cast}. A conversion to \keyword{void} does not invoke any conversion function\iref{expr.static.cast}. Even though never directly called to perform a conversion, such conversion functions can be declared and can potentially be reached through a call to a virtual conversion function in a base class. -\end{footnote} +\end{note} \begin{example} \begin{codeblock} struct X { From 4bcdf3765f4ac39480f48e77806721680020eae0 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 21:51:15 -0700 Subject: [PATCH 036/171] CWG2717 Pack expansion for alignment-specifier --- source/templates.tex | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/source/templates.tex b/source/templates.tex index 504f7cfa4a..f0b5430748 100644 --- a/source/templates.tex +++ b/source/templates.tex @@ -2845,6 +2845,10 @@ The instantiation of a \tcode{sizeof...} expression\iref{expr.sizeof} produces an integral constant with value $N$. +\pnum +The instantiation of an \grammarterm{alignment-specifier} with an ellipsis +produces $\tcode{E}_1$ $\tcode{E}_2$ $\dotsc$ $\tcode{E}_N$. + \pnum The instantiation of a \grammarterm{fold-expression}\iref{expr.prim.fold} produces: \begin{itemize} From 8758d3abd853aece84b50b2ece1656d60dcbbebc Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 21:53:42 -0700 Subject: [PATCH 037/171] CWG2718 Type completeness for derived-to-base conversions --- source/expressions.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/expressions.tex b/source/expressions.tex index 069585adc0..d77a9aa06f 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -3966,7 +3966,7 @@ \indextext{cast!reference}% An lvalue of type ``\cvqual{cv1} \tcode{B}'', where \tcode{B} is a class type, can be cast to type ``reference to \cvqual{cv2} \tcode{D}'', where -\tcode{D} is a class derived\iref{class.derived} from \tcode{B}, +\tcode{D} is a complete class derived\iref{class.derived} from \tcode{B}, if \cvqual{cv2} is the same cv-qualification as, or greater cv-qualification than, \cvqual{cv1}. If \tcode{B} is a virtual base class of \tcode{D} From 3f3043a81a4343f288850f509e503a7b59e82cc2 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 21:59:08 -0700 Subject: [PATCH 038/171] CWG2719 Creating objects in misaligned storage --- source/basic.tex | 3 +++ source/expressions.tex | 3 ++- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/source/basic.tex b/source/basic.tex index b9c3fd34ef..e97632e4ca 100644 --- a/source/basic.tex +++ b/source/basic.tex @@ -4103,6 +4103,9 @@ at which a given object can be allocated. An object type imposes an alignment requirement on every object of that type; stricter alignment can be requested using the alignment specifier\iref{dcl.align}. +Attempting to create an object\iref{intro.object} in storage that +does not meet the alignment requirements of the object's type +is undefined behavior. \pnum A \defnadj{fundamental}{alignment} is represented by an alignment diff --git a/source/expressions.tex b/source/expressions.tex index d77a9aa06f..ac2ff34810 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -5538,7 +5538,8 @@ \begin{note} When the allocation function returns a value other than null, it must be a pointer to a block of storage in which space for the object has been -reserved. The block of storage is assumed to be appropriately aligned +reserved. The block of storage is assumed to be +appropriately aligned\iref{basic.align} and of the requested size. The address of the created object will not necessarily be the same as that of the block if the object is an array. \end{note} From a8d1e300b9d2b778656f8cb14dbb7618748648b9 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 22:10:26 -0700 Subject: [PATCH 039/171] CWG2720 Template validity rules for templated entities and alias templates --- source/templates.tex | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/source/templates.tex b/source/templates.tex index f0b5430748..67600f17e5 100644 --- a/source/templates.tex +++ b/source/templates.tex @@ -4443,7 +4443,7 @@ \pnum \indextext{checking!syntax}% \indextext{checking!point of error}% -The validity of a template may be checked prior to any instantiation. +The validity of a templated entity may be checked prior to any instantiation. \begin{note} Knowing which names are type names allows the syntax of every template to be checked in this way. @@ -4452,10 +4452,14 @@ \begin{itemize} \item no valid specialization, -ignoring \grammarterm{static_assert-declaration}{s} that fail, -can be generated for a template -or a substatement of a constexpr if statement\iref{stmt.if} within a template -and the template is not instantiated, or +ignoring \grammarterm{static_assert-declaration}{s} that fail\iref{dcl.pre}, +can be generated for a templated entity +or a substatement of a constexpr if statement\iref{stmt.if} +within a templated entity +and the innermost enclosing template is not instantiated, or +\item +no specialization of an alias template\iref{temp.alias} is valid and +no specialization of the alias template is named in the program, or \item any \grammarterm{constraint-expression} in the program, introduced or otherwise, has (in its normal form) an atomic constraint $A$ where @@ -4465,16 +4469,18 @@ every valid specialization of a variadic template requires an empty template parameter pack, or \item -a hypothetical instantiation of a template +a hypothetical instantiation of a templated entity immediately following its definition would be ill-formed -due to a construct that does not depend on a template parameter, or +due to a construct +(other than a \grammarterm{static_assert-declaration} that fails) +that does not depend on a template parameter, or \item the interpretation of such a construct in the hypothetical instantiation is different from the interpretation of the corresponding construct -in any actual instantiation of the template. +in any actual instantiation of the templated entity. \end{itemize} \begin{note} This can happen in situations including the following: From 8d14bef3b9cdce28bd4f800a2206157f2e0a195e Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 22:20:44 -0700 Subject: [PATCH 040/171] CWG2721 When exactly is storage reused? --- source/basic.tex | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/source/basic.tex b/source/basic.tex index e97632e4ca..33f107557c 100644 --- a/source/basic.tex +++ b/source/basic.tex @@ -3384,6 +3384,21 @@ \item the storage which the object occupies is released, or is reused by an object that is not nested within \placeholder{o}\iref{intro.object}. \end{itemize} +When evaluating a \grammarterm{new-expression}, +storage is considered reused after it is returned from the allocation function, +but before the evaluation of the \grammarterm{new-initializer}\iref{expr.new}. +\begin{example} +\begin{codeblock} +struct S { + int m; +}; + +void f() { + S x{1}; + new(&x) S(x.m); // undefined behavior +} +\end{codeblock} +\end{example} \pnum \indextext{reference lifetime}% From 8970cb2bf035c46b0281ae9b1b768ad6799cf75f Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 22:25:16 -0700 Subject: [PATCH 041/171] CWG2722 Temporary materialization conversion for noexcept operator --- source/expressions.tex | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/source/expressions.tex b/source/expressions.tex index ac2ff34810..5442b6f089 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -5061,8 +5061,11 @@ \end{note} \pnum +If the operand is a prvalue, +the temporary materialization conversion\iref{conv.rval} is applied. The result of the \keyword{noexcept} operator is \keyword{true} -unless the \grammarterm{expression} is potentially-throwing\iref{except.spec}. +unless the full-expression of the operand +is potentially-throwing\iref{except.spec}. \indextext{expression!unary|)} \rSec3[expr.new]{New} From a11806355e83c44f433096c529b2901006c7e62b Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 22:50:53 -0700 Subject: [PATCH 042/171] CWG2723 Range of representable values for floating-point types --- source/basic.tex | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/source/basic.tex b/source/basic.tex index 33f107557c..20d8970469 100644 --- a/source/basic.tex +++ b/source/basic.tex @@ -5089,6 +5089,22 @@ the object and value representations and accuracy of operations of floating-point types are \impldef{representation of floating-point types}. +\pnum +The minimum range of representable values for a floating-point type is +the most negative finite floating-point number representable +in that type through +the most positive finite floating-point number representable in that type. +In addition, if negative infinity is representable in a type, +the range of that type is extended to all negative real numbers; +likewise, if positive infinity is representable in a type, +the range of that type is extended to all positive real numbers. +\begin{note} +Since negative and positive infinity are representable +in ISO/IEC/IEEE 60559 formats, +all real numbers lie within the range of representable values of +a floating-point type adhering to ISO/IEC/IEEE 60559. +\end{note} + \pnum Integral and floating-point types are collectively termed \defnx{arithmetic types}{type!arithmetic}. From bf368c6c4fe5fbb2e534527d53ab9a736d2e416f Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 22:52:18 -0700 Subject: [PATCH 043/171] CWG2724 Clarify rounding for arithmetic right shift --- source/expressions.tex | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/source/expressions.tex b/source/expressions.tex index 5442b6f089..75d595e212 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -6345,7 +6345,8 @@ \end{note} \pnum -The value of \tcode{E1 >> E2} is $\tcode{E1} / 2^\tcode{E2}$, rounded down. +The value of \tcode{E1 >> E2} is $\tcode{E1} / 2^\tcode{E2}$, +rounded towards negative infinity. \begin{note} \tcode{E1} is right-shifted \tcode{E2} bit positions. Right-shift on signed integral types is an arithmetic right shift, From 42b2651b37cc7a71bf984aadac4957d25f6e8a34 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 22:59:31 -0700 Subject: [PATCH 044/171] CWG2729 Meaning of new-type-id --- source/declarations.tex | 2 +- source/expressions.tex | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/source/declarations.tex b/source/declarations.tex index 08eeebfc97..aa28c9fcdd 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -2272,7 +2272,7 @@ \tcode{typeid}, the name of a type shall be specified. This can be done with a -\grammarterm{type-id}, +\grammarterm{type-id} or \grammarterm{new-type-id}\iref{expr.new}, which is syntactically a declaration for a variable or function of that type that omits the name of the entity. diff --git a/source/expressions.tex b/source/expressions.tex index 75d595e212..6f6c9d0eff 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -5080,7 +5080,7 @@ \indextext{storage management|see{\tcode{delete}}}% \indextext{\idxcode{new}}% The \grammarterm{new-expression} attempts to create an object of the -\grammarterm{type-id}\iref{dcl.name} or \grammarterm{new-type-id} to which +\grammarterm{type-id} or \grammarterm{new-type-id}\iref{dcl.name} to which it is applied. The type of that object is the \defnadj{allocated}{type}. \indextext{type!incomplete}% This type shall be a complete object type\iref{term.incomplete.type}, From 065834a285ecf6c6ac325184e2967a1e2a67f18a Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 23:06:04 -0700 Subject: [PATCH 045/171] CWG2732 Can importable headers react to preprocessor state from point of import? --- source/modules.tex | 2 ++ 1 file changed, 2 insertions(+) diff --git a/source/modules.tex b/source/modules.tex index 78825dd401..3d299b553c 100644 --- a/source/modules.tex +++ b/source/modules.tex @@ -448,6 +448,8 @@ to the source file or header nominated by \tcode{H}, which shall not contain a \grammarterm{module-declaration}. \begin{note} +A header unit is a separate translation unit with +an independent set of defined macros. All declarations within a header unit are implicitly exported\iref{module.interface}, and are attached to the global module\iref{module.unit}. From f1e4e9ef6d84e66622e33d18a50b197e7c98e246 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 20 Jun 2023 23:09:13 -0700 Subject: [PATCH 046/171] CWG2750 construct_at without constructor call --- source/expressions.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/expressions.tex b/source/expressions.tex index 6f6c9d0eff..c93a1bbb27 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -7642,7 +7642,7 @@ \tcode{std::construct_at} or \tcode{std::ranges::construct_at} is considered to include only -the underlying constructor call +the initialization of the \tcode{T} object if the first argument (of type \tcode{T*}) points to storage allocated with \tcode{std::allocator} or to an object whose lifetime began within the evaluation of $E$. From 47dbc585f6297f03518e81bfe59d4b414ac64fb2 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Sat, 17 Jun 2023 12:25:48 +0200 Subject: [PATCH 047/171] P2621R2 Undefined behavior in the lexer Editorial notes: - Original paper title was: "UB? In my lexer?" - Added a cross-reference. --- source/lex.tex | 11 ++++++----- source/preprocessor.tex | 6 ++---- 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/source/lex.tex b/source/lex.tex index a26a086d5c..1ced646a79 100644 --- a/source/lex.tex +++ b/source/lex.tex @@ -108,10 +108,11 @@ physical source lines to form logical source lines. Only the last backslash on any physical source line shall be eligible for being part of such a splice. -Except for splices reverted in a raw string literal, if a splice results in -a character sequence that matches the -syntax of a \grammarterm{universal-character-name}, the behavior is -undefined. A source file that is not empty and that does not end in a new-line +\begin{note} +Line splicing can form +a \grammarterm{universal-character-name}\iref{lex.charset}. +\end{note} +A source file that is not empty and that does not end in a new-line character, or that ends in a splice, shall be processed as if an additional new-line character were appended to the file. @@ -488,7 +489,7 @@ operators and punctuators, and single non-whitespace characters that do not lexically match the other preprocessing token categories. If a \unicode{0027}{apostrophe} or a \unicode{0022}{quotation mark} character -matches the last category, the behavior is undefined. +matches the last category, the program is ill-formed. If any character not in the basic character set matches the last category, the program is ill-formed. Preprocessing tokens can be separated by diff --git a/source/preprocessor.tex b/source/preprocessor.tex index 0093ee7c8f..828b2c9673 100644 --- a/source/preprocessor.tex +++ b/source/preprocessor.tex @@ -1374,11 +1374,9 @@ of two placemarkers results in a single placemarker preprocessing token, and concatenation of a placemarker with a non-placemarker preprocessing token results in the non-placemarker preprocessing token. -If the result begins with a sequence matching the syntax of \grammarterm{universal-character-name}, -the behavior is undefined. \begin{note} -This determination does not consider the replacement of -\grammarterm{universal-character-name}s in translation phase 3\iref{lex.phases}. +Concatenation can form +a \grammarterm{universal-character-name}\iref{lex.charset}. \end{note} If the result is not a valid preprocessing token, the behavior is undefined. From 3d774bf6e4a1bdbfa061b113f3521a5867088c65 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Sat, 17 Jun 2023 16:50:52 +0200 Subject: [PATCH 048/171] P1854R4 Making non-encodable string literals ill-formed The wording has been reconciled with previous changes from P2314R4. --- source/lex.tex | 56 +++++++++++--------------------------------------- 1 file changed, 12 insertions(+), 44 deletions(-) diff --git a/source/lex.tex b/source/lex.tex index 1ced646a79..29016afc73 100644 --- a/source/lex.tex +++ b/source/lex.tex @@ -1436,20 +1436,14 @@ \indextext{type!\idxcode{char32_t}}% \indextext{wide-character}% \indextext{type!\idxcode{wchar_t}}% -A \defnx{non-encodable character literal}{literal!character!non-encodable} -is a \grammarterm{character-literal} -whose \grammarterm{c-char-sequence} consists of a single \grammarterm{c-char} -that is not a \grammarterm{numeric-escape-sequence} and -that specifies a character -that either lacks representation in the literal's associated character encoding -or that cannot be encoded as a single code unit. A \defnadj{multicharacter}{literal} is a \grammarterm{character-literal} whose \grammarterm{c-char-sequence} consists of more than one \grammarterm{c-char}. -The \grammarterm{encoding-prefix} of -a non-encodable character literal or a multicharacter literal -shall be absent. -Such \grammarterm{character-literal}s are conditionally-supported. +A multicharacter literal shall not have an \grammarterm{encoding-prefix}. +If a multicharacter literal contains a \grammarterm{c-char} +that is not encodable as a single code unit in the ordinary literal encoding, +the program is ill-formed. +Multicharacter literals are conditionally-supported. \pnum The kind of a \grammarterm{character-literal}, @@ -1457,21 +1451,6 @@ are determined by its \grammarterm{encoding-prefix} and its \grammarterm{c-char-sequence} as defined by \tref{lex.ccon.literal}. -The special cases for -non-encodable character literals and multicharacter literals -take precedence over the base kind. -\begin{note} -The associated character encoding for ordinary character literals -determines encodability, -but does not determine the value of -non-encodable ordinary character literals or -ordinary multicharacter literals. -The examples in \tref{lex.ccon.literal} -for non-encodable ordinary character literals assume that -the specified character lacks representation in -the ordinary literal encoding or -that encoding the character would require more than one code unit. -\end{note} \begin{floattable}{Character literals}{lex.ccon.literal} {l|l|l|l|l} @@ -1482,15 +1461,10 @@ none & \defnx{ordinary character literal}{literal!character!ordinary} & \keyword{char} & -ordinary & +ordinary literal & \tcode{'v'} \\ \cline{2-3}\cline{5-5} & -non-encodable ordinary character literal & -\keyword{int} & -literal & -\tcode{'\textbackslash U0001F525'} \\ \cline{2-3}\cline{5-5} - & -ordinary multicharacter literal & +multicharacter literal & \keyword{int} & encoding & \tcode{'abcd'} \\ \hline @@ -1522,8 +1496,7 @@ the value of a \grammarterm{character-literal} is determined using the range of representable values of the \grammarterm{character-literal}'s type in translation phase 7. -A non-encodable character literal or a multicharacter literal -has an +A multicharacter literal has an \impldef{value of non-encodable character literal or multicharacter literal} value. The value of any other kind of \grammarterm{character-literal} @@ -1537,12 +1510,10 @@ \grammarterm{universal-character-name} is the code unit value of the specified character as encoded in the literal's associated character encoding. -\begin{note} If the specified character lacks representation in the literal's associated character encoding or if it cannot be encoded as a single code unit, -then the literal is a non-encodable character literal. -\end{note} +then the program is ill-formed. \item A \grammarterm{character-literal} with a \grammarterm{c-char-sequence} consisting of @@ -1568,7 +1539,7 @@ $v$ does not exceed the range of representable values of the corresponding unsigned type for the underlying type of the \grammarterm{character-literal}'s type, then the value is the unique value of the \grammarterm{character-literal}'s type \tcode{T} that is congruent to $v$ modulo $2^N$, where $N$ is the width of \tcode{T}. \item -Otherwise, the \grammarterm{character-literal} is ill-formed. +Otherwise, the program is ill-formed. \end{itemize} \item A \grammarterm{character-literal} with @@ -2006,10 +1977,7 @@ is encoded to a code unit sequence using the \grammarterm{string-literal}'s associated character encoding. If a character lacks representation in the associated character encoding, -then the \grammarterm{string-literal} is conditionally-supported and -an -\impldef{code unit sequence for non-representable \grammarterm{string-literal}} -code unit sequence is encoded. +then the program is ill-formed. \begin{note} No character lacks representation in any Unicode encoding form. \end{note} @@ -2050,7 +2018,7 @@ the \grammarterm{string-literal}'s array element type \tcode{T} that is congruent to $v$ modulo $2^N$, where $N$ is the width of \tcode{T}. \item -Otherwise, the \grammarterm{string-literal} is ill-formed. +Otherwise, the program is ill-formed. \end{itemize} When encoding a stateful character encoding, these sequences should have no effect on encoding state. From 8d7e1993ffeacc418c12dc6be3ca98340c97c4e1 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Sat, 17 Jun 2023 20:21:36 +0200 Subject: [PATCH 049/171] P2361R6 Unevaluated strings --- source/declarations.tex | 48 +++++++++++++++++++++++------------------ source/lex.tex | 22 +++++++++++++++++++ source/overloading.tex | 11 +++++----- 3 files changed, 55 insertions(+), 26 deletions(-) diff --git a/source/declarations.tex b/source/declarations.tex index aa28c9fcdd..0b70486f08 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -77,7 +77,7 @@ \begin{bnf} \nontermdef{static_assert-declaration}\br \keyword{static_assert} \terminal{(} constant-expression \terminal{)} \terminal{;}\br - \keyword{static_assert} \terminal{(} constant-expression \terminal{,} string-literal \terminal{)} \terminal{;} + \keyword{static_assert} \terminal{(} constant-expression \terminal{,} unevaluated-string \terminal{)} \terminal{;} \end{bnf} \begin{bnf} @@ -264,7 +264,7 @@ the \grammarterm{static_assert-declaration} \defnx{fails}{\idxcode{static_assert}!failed}, the program is ill-formed, and the resulting diagnostic message\iref{intro.compliance} should include the text of -the \grammarterm{string-literal}, if one is supplied. +the \grammarterm{unevaluated-string}, if one is supplied. \begin{example} \begin{codeblock} static_assert(sizeof(int) == sizeof(void*), "wrong pointer size"); @@ -8169,11 +8169,12 @@ An \tcode{asm} declaration has the form \begin{bnf} \nontermdef{asm-declaration}\br - \opt{attribute-specifier-seq} \keyword{asm} \terminal{(} string-literal \terminal{)} \terminal{;} + \opt{attribute-specifier-seq} \keyword{asm} \terminal{(} balanced-token-seq \terminal{)} \terminal{;} \end{bnf} -The \tcode{asm} declaration is conditionally-supported; its meaning is -\impldef{meaning of \tcode{asm} declaration}. +The \tcode{asm} declaration is conditionally-supported; +any restrictions on the \grammarterm{balanced-token-seq} and +its meaning are \impldef{meaning of \tcode{asm} declaration}. The optional \grammarterm{attribute-specifier-seq} in an \grammarterm{asm-declaration} appertains to the \tcode{asm} declaration. \begin{note} @@ -8209,25 +8210,30 @@ % \begin{bnf} \nontermdef{linkage-specification}\br - \keyword{extern} string-literal \terminal{\{} \opt{declaration-seq} \terminal{\}}\br - \keyword{extern} string-literal name-declaration + \keyword{extern} unevaluated-string \terminal{\{} \opt{declaration-seq} \terminal{\}}\br + \keyword{extern} unevaluated-string name-declaration \end{bnf} -The \grammarterm{string-literal} indicates the required language linkage. +The \grammarterm{unevaluated-string} indicates the required language linkage. +\begin{note} +Escape sequences and \grammarterm{universal-character-name}s +have been replaced\iref{lex.string.uneval}. +\end{note} This document specifies the semantics for the -\grammarterm{string-literal}{s} \tcode{"C"} and \tcode{"C++"}. Use of a -\grammarterm{string-literal} other than \tcode{"C"} or \tcode{"C++"} is -conditionally-supported, with \impldef{semantics of linkage specifiers} semantics. +\grammarterm{unevaluated-string}{s} \tcode{"C"} and \tcode{"C++"}. +Use of an \grammarterm{unevaluated-string} +other than \tcode{"C"} or \tcode{"C++"} is conditionally-supported, +with \impldef{semantics of linkage specifiers} semantics. \begin{note} -Therefore, a linkage-specification with a \grammarterm{string-literal} that -is unknown to the implementation requires a diagnostic. +Therefore, a \grammarterm{linkage-specification} with a language linkage +that is unknown to the implementation requires a diagnostic. \end{note} \recommended -The spelling of the \grammarterm{string-literal} should be -taken from the document defining that language. For example, \tcode{Ada} -(not \tcode{ADA}) and \tcode{Fortran} or \tcode{FORTRAN}, depending on -the vintage. +The spelling of the language linkage should be taken +from the document defining that language. +For example, \tcode{Ada} (not \tcode{ADA}) and +\tcode{Fortran} or \tcode{FORTRAN}, depending on the vintage. \pnum \indextext{specification!linkage!implementation-defined}% @@ -8830,10 +8836,10 @@ An \grammarterm{attribute-argument-clause} may be present and, if present, it shall have the form: \begin{ncbnf} -\terminal{(} string-literal \terminal{)} +\terminal{(} unevaluated-string \terminal{)} \end{ncbnf} \begin{note} -The \grammarterm{string-literal} in the \grammarterm{attribute-argument-clause} +The \grammarterm{unevaluated-string} in the \grammarterm{attribute-argument-clause} can be used to explain the rationale for deprecation and/or to suggest a replacing entity. \end{note} @@ -9044,7 +9050,7 @@ and, if present, shall have the form: \begin{ncbnf} -\terminal{(} string-literal \terminal{)} +\terminal{(} unevaluated-string \terminal{)} \end{ncbnf} \pnum @@ -9091,7 +9097,7 @@ This is typically because discarding the return value of a nodiscard call has surprising consequences. \end{note} -The \grammarterm{string-literal} +The \grammarterm{unevaluated-string} in a \tcode{nodiscard} \grammarterm{attribute-argument-clause} should be used in the message of the warning as the rationale for why the result should not be discarded. diff --git a/source/lex.tex b/source/lex.tex index 29016afc73..006632b4a6 100644 --- a/source/lex.tex +++ b/source/lex.tex @@ -2033,6 +2033,28 @@ what effect these sequences have on encoding state. \end{itemize} +\rSec2[lex.string.uneval]{Unevaluated strings} + +\begin{bnf} +\nontermdef{unevaluated-string}\br + string-literal +\end{bnf} + +\pnum +An \grammarterm{unevaluated-string} shall have no \grammarterm{encoding-prefix}. + +\pnum +Each \grammarterm{universal-character-name} and each \grammarterm{simple-escape-sequence} in an \grammarterm{unevaluated-string} is +replaced by the member of the translation character set it denotes. +An \grammarterm{unevaluated-string} that contains +a \grammarterm{numeric-escape-sequence} or +a \grammarterm{conditional-escape-sequence} +is ill-formed. + +\pnum +An \grammarterm{unevaluated-string} is never evaluated and +its interpretation depends on the context in which it appears. + \rSec2[lex.bool]{Boolean literals} \indextext{literal!boolean}% diff --git a/source/overloading.tex b/source/overloading.tex index edf9542eaa..04a4fb351c 100644 --- a/source/overloading.tex +++ b/source/overloading.tex @@ -3936,15 +3936,16 @@ \begin{bnf} \nontermdef{literal-operator-id}\br - \keyword{operator} string-literal identifier\br + \keyword{operator} unevaluated-string identifier\br \keyword{operator} user-defined-string-literal \end{bnf} \pnum -The \grammarterm{string-literal} or \grammarterm{user-defined-string-literal} -in a \grammarterm{literal-operator-id} shall have no -\grammarterm{encoding-prefix} and shall contain no characters other than the -implicit terminating \tcode{'\textbackslash 0'}. +The \grammarterm{user-defined-string-literal} +in a \grammarterm{literal-operator-id} +shall have no \grammarterm{encoding-prefix}. +The \grammarterm{unevaluated-string} or +\grammarterm{user-defined-string-literal} shall be empty. The \grammarterm{ud-suffix} of the \grammarterm{user-defined-string-literal} or the \grammarterm{identifier} in a \grammarterm{literal-operator-id} is called a \defnx{literal suffix identifier}{literal!suffix identifier}. From 13c692363126b40d5a7cd2dda7308000baab484a Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Sun, 18 Jun 2023 09:08:01 +0200 Subject: [PATCH 050/171] P2558R2 Add @, $, and ` to the basic character set --- source/lex.tex | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/source/lex.tex b/source/lex.tex index 006632b4a6..c2b3db8c33 100644 --- a/source/lex.tex +++ b/source/lex.tex @@ -262,7 +262,7 @@ \pnum The \defnadj{basic}{character set} is a subset of the translation character set, -consisting of 96 characters as specified in \tref{lex.charset.basic}. +consisting of 99 characters as specified in \tref{lex.charset.basic}. \begin{note} Unicode short names are given only as a means to identifying the character; the numerical value has no other meaning in this context. @@ -279,6 +279,7 @@ \ucode{0021} & \uname{exclamation mark} & \tcode{!} \\ \ucode{0022} & \uname{quotation mark} & \tcode{"} \\ \ucode{0023} & \uname{number sign} & \tcode{\#} \\ +\ucode{0024} & \uname{dollar sign} & \tcode{\$} \\ \ucode{0025} & \uname{percent sign} & \tcode{\%} \\ \ucode{0026} & \uname{ampersand} & \tcode{\&} \\ \ucode{0027} & \uname{apostrophe} & \tcode{'} \\ @@ -297,6 +298,7 @@ \ucode{003d} & \uname{equals sign} & \tcode{=} \\ \ucode{003e} & \uname{greater-than sign} & \tcode{>} \\ \ucode{003f} & \uname{question mark} & \tcode{?} \\ +\ucode{0040} & \uname{commercial at} & \tcode{@} \\ \ucode{0041} .. \ucode{005a} & \uname{latin capital letter a .. z} & \tcode{A B C D E F G H I J K L M} \\ & & \tcode{N O P Q R S T U V W X Y Z} \\ \ucode{005b} & \uname{left square bracket} & \tcode{[} \\ @@ -304,6 +306,7 @@ \ucode{005d} & \uname{right square bracket} & \tcode{]} \\ \ucode{005e} & \uname{circumflex accent} & \tcode{\caret} \\ \ucode{005f} & \uname{low line} & \tcode{_} \\ +\ucode{0060} & \uname{grave accent} & \tcode{\`} \\ \ucode{0061} .. \ucode{007a} & \uname{latin small letter a .. z} & \tcode{a b c d e f g h i j k l m} \\ & & \tcode{n o p q r s t u v w x y z} \\ \ucode{007b} & \uname{left curly bracket} & \tcode{\{} \\ From 39948207ff13da8b69a9f431084940424869aadf Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Sun, 18 Jun 2023 09:14:11 +0200 Subject: [PATCH 051/171] P2738R1 constexpr cast from void*: towards constexpr type-erasure --- source/expressions.tex | 5 ++++- source/preprocessor.tex | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/source/expressions.tex b/source/expressions.tex index c93a1bbb27..65802d7594 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -7491,7 +7491,10 @@ \end{note} \item -a conversion from type \cv{}~\tcode{\keyword{void}*} to a pointer-to-object type; +a conversion +from a prvalue \tcode{P} of type ``pointer to \cv{}~\keyword{void}'' +to a pointer-to-object type \tcode{T} +unless \tcode{P} points to an object whose type is similar to \tcode{T}; \item a \keyword{reinterpret_cast}\iref{expr.reinterpret.cast}; diff --git a/source/preprocessor.tex b/source/preprocessor.tex index 828b2c9673..8e4abe23e8 100644 --- a/source/preprocessor.tex +++ b/source/preprocessor.tex @@ -1812,7 +1812,7 @@ \defnxname{cpp_char8_t} & \tcode{202207L} \\ \rowsep \defnxname{cpp_concepts} & \tcode{202002L} \\ \rowsep \defnxname{cpp_conditional_explicit} & \tcode{201806L} \\ \rowsep -\defnxname{cpp_constexpr} & \tcode{202211L} \\ \rowsep +\defnxname{cpp_constexpr} & \tcode{202306L} \\ \rowsep \defnxname{cpp_constexpr_dynamic_alloc} & \tcode{201907L} \\ \rowsep \defnxname{cpp_constexpr_in_decltype} & \tcode{201711L} \\ \rowsep \defnxname{cpp_consteval} & \tcode{202211L} \\ \rowsep From 1cf424ec03baf6f2e82003b338e8d1327fc3eaac Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 21 Jun 2023 01:58:33 -0700 Subject: [PATCH 052/171] P2915R0 Proposed resolution for CWG1223 Editorial notes: - [dcl.ambig.res] Use "is to be considered a" instead of "is" to avoid redefining the grammar production /type-id/. - [stmt.ambig] Likewise, don't use \grammarterm "declaration" in "is a declaration" to avoid redefining /declaration/. - [stmt.ambig] Reword comment in example for consistency. --- source/declarations.tex | 19 +++++++++++++++++++ source/statements.tex | 34 +++++++++++++++++++++++++++++++++- 2 files changed, 52 insertions(+), 1 deletion(-) diff --git a/source/declarations.tex b/source/declarations.tex index 0b70486f08..04fa7dcd69 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -2371,6 +2371,11 @@ such as the potential parameter declaration, that could possibly be a declaration to be a declaration. +However, a construct that can syntactically be a \grammarterm{declaration} +whose outermost \grammarterm{declarator} +would match the grammar of a \grammarterm{declarator} +with a \grammarterm{trailing-return-type} +is a declaration only if it starts with \keyword{auto}. \begin{note} A declaration can be explicitly disambiguated by adding parentheses around the argument. @@ -2382,6 +2387,7 @@ struct S { S(int); }; +typedef struct BB { int C[2]; } *B, C; void foo(double a) { S w(int(a)); // function declaration @@ -2389,6 +2395,8 @@ S y((int(a))); // object declaration S y((int)a); // object declaration S z = int(a); // object declaration + S a(B()->C); // object declaration + S b(auto()->C); // function declaration } \end{codeblock} \end{example} @@ -2401,6 +2409,11 @@ \grammarterm{type-id} in its syntactic context shall be considered a \grammarterm{type-id}. +However, a construct that can syntactically be a \grammarterm{type-id} +whose outermost \grammarterm{abstract-declarator} +would match the grammar of an \grammarterm{abstract-declarator} +with a \grammarterm{trailing-return-type} +is a \grammarterm{type-id} only if it starts with \keyword{auto}. \begin{example} \begin{codeblock} template struct X {}; @@ -2419,6 +2432,12 @@ (int(a))+1; // expression (int(unsigned(a)))+1; // type-id (ill-formed) } + +typedef struct BB { int C[2]; } *B, C; +void g() { + sizeof(B()->C[1]); // OK, \tcode{\keyword{sizeof}(}expression\tcode{)} + sizeof(auto()->C[1]); // error: \keyword{sizeof} of a function returning an array +} \end{codeblock} \end{example} diff --git a/source/statements.tex b/source/statements.tex index aa9ae2bbbf..608f577935 100644 --- a/source/statements.tex +++ b/source/statements.tex @@ -1081,7 +1081,8 @@ conversion\iref{expr.type.conv} as its leftmost subexpression can be indistinguishable from a \grammarterm{declaration} where the first \grammarterm{declarator} starts with a \tcode{(}. In those cases the -\grammarterm{statement} is a \grammarterm{declaration}. +\grammarterm{statement} is a \grammarterm{declaration}, +except as specified below. \pnum \begin{note} @@ -1163,4 +1164,35 @@ } \end{codeblock} \end{example} + +\pnum +A syntactically ambiguous statement that can syntactically be +a \grammarterm{declaration} with an outermost \grammarterm{declarator} +with a \grammarterm{trailing-return-type} +is a \grammarterm{declaration} only if it starts with \keyword{auto}. +\begin{example} +\begin{codeblock} +struct M; +struct S { + S* operator()(); + int N; + int M; + + void mem(S s) { + auto(s)()->M; // expression, \tcode{S::M} hides \tcode{::M} + } +}; + +void f(S s) { + { + auto(s)()->N; // expression + auto(s)()->M; // function declaration + } + { + S(s)()->N; // expression + S(s)()->M; // expression + } +} +\end{codeblock} +\end{example} \indextext{statement|)} From 9b9ebcc9c3135cc349381b2ce7fa9b426988831f Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Thu, 29 Jun 2023 15:55:02 -0700 Subject: [PATCH 053/171] [dcl.ambig.res][stmt.ambig] Change "is" to "is considered". This avoids suggesting that any \grammarterms are being (re)defined. --- source/declarations.tex | 2 +- source/statements.tex | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/source/declarations.tex b/source/declarations.tex index 04fa7dcd69..e244170c6b 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -2413,7 +2413,7 @@ whose outermost \grammarterm{abstract-declarator} would match the grammar of an \grammarterm{abstract-declarator} with a \grammarterm{trailing-return-type} -is a \grammarterm{type-id} only if it starts with \keyword{auto}. +is considered a \grammarterm{type-id} only if it starts with \keyword{auto}. \begin{example} \begin{codeblock} template struct X {}; diff --git a/source/statements.tex b/source/statements.tex index 608f577935..4f0c773c51 100644 --- a/source/statements.tex +++ b/source/statements.tex @@ -1081,7 +1081,7 @@ conversion\iref{expr.type.conv} as its leftmost subexpression can be indistinguishable from a \grammarterm{declaration} where the first \grammarterm{declarator} starts with a \tcode{(}. In those cases the -\grammarterm{statement} is a \grammarterm{declaration}, +\grammarterm{statement} is considered a \grammarterm{declaration}, except as specified below. \pnum @@ -1169,7 +1169,7 @@ A syntactically ambiguous statement that can syntactically be a \grammarterm{declaration} with an outermost \grammarterm{declarator} with a \grammarterm{trailing-return-type} -is a \grammarterm{declaration} only if it starts with \keyword{auto}. +is considered a \grammarterm{declaration} only if it starts with \keyword{auto}. \begin{example} \begin{codeblock} struct M; From 99dccefc758ec3e38af963254af55b1c13ca617f Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Sun, 18 Jun 2023 10:34:28 +0200 Subject: [PATCH 054/171] P2552R3 On the ignorability of standard attributes --- source/declarations.tex | 39 ++++++++++++++++++++++++++++++++++++++- source/preprocessor.tex | 6 ++++-- 2 files changed, 42 insertions(+), 3 deletions(-) diff --git a/source/declarations.tex b/source/declarations.tex index e244170c6b..124905b8f6 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -8746,6 +8746,11 @@ deduce information used to optimize the program. Implementations are not required to deduce any information from any particular assumption. +It is expected that the value of +a \grammarterm{has-attribute-expression} for the \tcode{assume} attribute +is \tcode{0} +if an implementation does not attempt to deduce +any such information from assumptions. \end{note} \begin{example} \begin{codeblock} @@ -8894,6 +8899,10 @@ declaration that specifies the attribute. The diagnostic message should include the text provided within the \grammarterm{attribute-argument-clause} of any \tcode{deprecated} attribute applied to the name or entity. +The value of +a \grammarterm{has-attribute-expression} for the \tcode{deprecated} attribute +should be \tcode{0} +unless the implementation can issue such diagnostic messages. \rSec2[dcl.attr.fallthrough]{Fallthrough attribute} \indextext{attribute!fallthrough} @@ -8920,6 +8929,10 @@ a warning that an implementation might otherwise issue for a case or default label that is reachable from another case or default label along some path of execution. +The value of +a \grammarterm{has-attribute-expression} for the \tcode{fallthrough} attribute +should be \tcode{0} +if the attribute does not cause suppression of such warnings. Implementations should issue a warning if a fallthrough statement is not dynamically reachable. @@ -8969,7 +8982,7 @@ that contains the \grammarterm{attribute-token} \tcode{unlikely}. \pnum -\recommended +\begin{note} The use of the \tcode{likely} attribute is intended to allow implementations to optimize for the case where paths of execution including it @@ -8982,8 +8995,14 @@ are arbitrarily more unlikely than any alternative path of execution that does not include such an attribute on a statement or label. +It is expected that the value of a \grammarterm{has-attribute-expression} +for the \tcode{likely} and \tcode{unlikely} attributes +is \tcode{0} +if the implementation does not attempt to use these attributes +for such optimizations. A path of execution includes a label if and only if it contains a jump to that label. +\end{note} \begin{note} Excessive usage of either of these attributes is liable to result in performance degradation. @@ -9044,6 +9063,10 @@ For a structured binding declaration not marked \tcode{maybe_unused}, implementations should not emit such a warning unless all of its structured bindings are unused. +The value of +a \grammarterm{has-attribute-expression} for the \tcode{maybe_unused} attribute +should be \tcode{0} +if the attribute does not cause suppression of such warnings. \pnum \begin{example} @@ -9112,6 +9135,9 @@ a potentially-evaluated discarded-value expression\iref{expr.prop} is discouraged unless explicitly cast to \keyword{void}. Implementations should issue a warning in such cases. +The value of +a \grammarterm{has-attribute-expression} for the \tcode{nodiscard} attribute +should be \tcode{0} unless the implementation can issue such warnings. \begin{note} This is typically because discarding the return value of a nodiscard call has surprising consequences. @@ -9174,6 +9200,9 @@ \recommended Implementations should issue a warning if a function marked \tcode{[[noreturn]]} might return. +The value of +a \grammarterm{has-attribute-expression} for the \tcode{noreturn} attribute +should be \tcode{0} unless the implementation can issue such warnings. \pnum \begin{example} @@ -9208,6 +9237,14 @@ at the end of the object can be reused as storage for other members. \end{note} + +\recommended +The value of a \grammarterm{has-attribute-expression} +for the \tcode{no_unique_address} attribute +should be \tcode{0} for a given implementation +unless this attribute can cause a potentially-overlapping subobject +to have zero size. + \begin{example} \begin{codeblock} template Date: Sun, 18 Jun 2023 10:53:55 +0200 Subject: [PATCH 055/171] P2752R3 Static storage for braced initializers --- source/compatibility.tex | 30 ++++++++++++++++++++ source/declarations.tex | 59 ++++++++++++++++++++++++++++------------ source/macros.tex | 1 + 3 files changed, 73 insertions(+), 17 deletions(-) diff --git a/source/compatibility.tex b/source/compatibility.tex index 0bdb90b9cc..fd56f1a4d6 100644 --- a/source/compatibility.tex +++ b/source/compatibility.tex @@ -1,6 +1,36 @@ %!TEX root = std.tex \infannex{diff}{Compatibility} +\rSec1[diff.cpp23]{\Cpp{} and ISO \CppXXIII{}} + +\rSec2[diff.cpp23.general]{General} + +\pnum +\indextext{summary!compatibility with ISO \CppXXIII{}}% +Subclause \ref{diff.cpp23} lists the differences between \Cpp{} and +ISO \CppXXIII{} (ISO/IEC 14882:2023, \doccite{Programming Languages --- \Cpp{}}), +by the chapters of this document. + +\rSec2[diff.cpp23.expr]{\ref{expr}: expressions} + +\diffref{dcl.init.list} +\change +Pointer comparisons between \tcode{initializer_list} objects' backing arrays +are unspecified. +\rationale +Permit the implementation to store backing arrays in static read-only memory. +\effect +Valid \CppXXIII{} code +that relies on the result of pointer comparison between backing arrays +may change behavior. +For example: +\begin{example} +bool ne(std::initializer_list a, std::initializer_list b) { + return a.begin() != b.begin() + 1; +} +bool b = ne({2,3}, {1,2,3}); // unspecified result; previously \tcode{false} +\end{example} + \rSec1[diff.cpp20]{\Cpp{} and ISO \CppXX{}} \rSec2[diff.cpp20.general]{General} diff --git a/source/declarations.tex b/source/declarations.tex index 124905b8f6..8725c426b0 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -5991,36 +5991,64 @@ an initializer list as if the implementation generated and materialized\iref{conv.rval} a prvalue of type ``array of $N$ \tcode{const E}'', -where $N$ is the number of elements in the -initializer list. Each element of that array is copy-initialized with the +where $N$ is the number of elements in the initializer list; +this is called the initializer list's \defnadj{backing}{array}. +Each element of the backing array is copy-initialized with the corresponding element of the initializer list, and the \tcode{std::initializer_list} object is constructed to refer to that array. \begin{note} A constructor or conversion function selected for the copy is required to be accessible\iref{class.access} in the context of the initializer list. \end{note} -If a narrowing conversion is required to initialize any of the elements, the program is ill-formed. +If a narrowing conversion is required to initialize any of the elements, +the program is ill-formed. +Whether all backing arrays are distinct +(that is, are stored in non-overlapping objects) is unspecified. + +\pnum +The backing array has the same lifetime as any other temporary +object\iref{class.temporary}, except that initializing an +\tcode{initializer_list} object from the array extends the lifetime of +the array exactly like binding a reference to a temporary. \begin{example} \begin{codeblock} -struct X { - X(std::initializer_list v); +void f(std::initializer_list il); +void g(float x) { + f({1, x, 3}); +} +void h() { + f({1, 2, 3}); +} + +struct A { + mutable int i; }; -X x{ 1,2,3 }; +void q(std::initializer_list); +void r() { + q({A{1}, A{2}, A{3}}); +} \end{codeblock} The initialization will be implemented in a way roughly equivalent to this: \begin{codeblock} -const double __a[3] = {double{1}, double{2}, double{3}}; -X x(std::initializer_list(__a, __a+3)); +void g(float x) { + const double __a[3] = {double{1}, double{x}, double{3}}; // backing array + f(std::initializer_list(__a, __a+3)); +} +void h() { + static constexpr double __b[3] = {double{1}, double{2}, double{3}}; // backing array + f(std::initializer_list(__b, __b+3)); +} +void r() { + const A __c[3] = {A{1}, A{2}, A{3}}; // backing array + q(std::initializer_list(__c, __c+3)); +} \end{codeblock} -assuming that the implementation can construct an \tcode{initializer_list} object with a pair of pointers. +assuming that the implementation +can construct an \tcode{initializer_list} object with a pair of pointers, and +with the understanding that \tcode{__b} does not outlive the call to \tcode{f}. \end{example} -\pnum -The array has the same lifetime as any other temporary -object\iref{class.temporary}, except that initializing an -\tcode{initiali\-zer_list} object from the array extends the lifetime of -the array exactly like binding a reference to a temporary. \begin{example} \begin{codeblock} typedef std::complex cmplx; @@ -6047,9 +6075,6 @@ a temporary array to a reference member, so the program is ill-formed\iref{class.base.init}. \end{example} -\begin{note} -The implementation is free to allocate the array in read-only memory if an explicit array with the same initializer can be so allocated. -\end{note} \pnum A \defnadj{narrowing}{conversion} is an implicit conversion diff --git a/source/macros.tex b/source/macros.tex index 13a4203294..3d6541e5aa 100644 --- a/source/macros.tex +++ b/source/macros.tex @@ -274,6 +274,7 @@ \newcommand{\CppXIV}{\Cpp{} 2014} \newcommand{\CppXVII}{\Cpp{} 2017} \newcommand{\CppXX}{\Cpp{} 2020} +\newcommand{\CppXXIII}{\Cpp{} 2023} \newcommand{\opt}[1]{#1\ensuremath{_\mathit{\color{black}opt}}} \newcommand{\bigoh}[1]{\ensuremath{\mathscr{O}(#1)}} From 3d30638b02e23073be8ba045cb3042ff02707845 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Mon, 19 Jun 2023 19:03:11 +0200 Subject: [PATCH 056/171] P2741R3 User-generated static_assert messages --- source/declarations.tex | 73 ++++++++++++++++++++++++++++++++++------- source/preprocessor.tex | 2 +- 2 files changed, 63 insertions(+), 12 deletions(-) diff --git a/source/declarations.tex b/source/declarations.tex index 8725c426b0..58962c889a 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -74,10 +74,16 @@ \opt{attribute-specifier-seq} decl-specifier-seq \opt{ref-qualifier} \terminal{[} identifier-list \terminal{]} initializer \terminal{;} \end{bnf} +\begin{bnf} +\nontermdef{static_assert-message}\br + unevaluated-string\br + conditional-expression +\end{bnf} + \begin{bnf} \nontermdef{static_assert-declaration}\br \keyword{static_assert} \terminal{(} constant-expression \terminal{)} \terminal{;}\br - \keyword{static_assert} \terminal{(} constant-expression \terminal{,} unevaluated-string \terminal{)} \terminal{;} + \keyword{static_assert} \terminal{(} constant-expression \terminal{,} static_assert-message \terminal{)} \terminal{;} \end{bnf} \begin{bnf} @@ -250,21 +256,66 @@ \grammarterm{explicit-specialization}\iref{temp.expl.spec}. \end{note} +\pnum +If a \grammarterm{static_assert-message} +matches the syntactic requirements of \grammarterm{unevaluated-string}, +it is an \grammarterm{unevaluated-string} and +the text of the \grammarterm{static_assert-message} is +the text of the \grammarterm{unevaluated-string}. +Otherwise, a \grammarterm{static_assert-message} shall be an expression $M$ +such that +\begin{itemize} +\item +the expression \tcode{$M$.size()} is +implicitly convertible to the type \tcode{std::size_t}, and +\item +the expression \tcode{$M$.data()} is +implicitly convertible to the type ``pointer to \tcode{\keyword{const} \keyword{char}}''. +\end{itemize} + \pnum \indextext{\idxcode{static_assert}}% In a \grammarterm{static_assert-declaration}, -the \grammarterm{constant-expression} +the \grammarterm{constant-expression} $E$ is contextually converted to \keyword{bool} and the converted expression shall be a constant expression\iref{expr.const}. -If the value of the expression when -so converted is \tcode{true} -or the expression is evaluated in the context of a template definition, -the declaration has no -effect. Otherwise, -the \grammarterm{static_assert-declaration} \defnx{fails}{\idxcode{static_assert}!failed}, -the program is ill-formed, and the resulting -diagnostic message\iref{intro.compliance} should include the text of -the \grammarterm{unevaluated-string}, if one is supplied. +If the value of the expression $E$ when so converted is \tcode{true} or +the expression is evaluated in the context of a template definition, +the declaration has no effect and +the \grammarterm{static_assert-message} is +an unevaluated operand\iref{term.unevaluated.operand}. +Otherwise, +the \grammarterm{static_assert-declaration} \defnx{fails}{\idxcode{static_assert}!failed} and +\begin{itemize} +\item +the program is ill-formed, and +\item +if the \grammarterm{static_assert-message} is +a \grammarterm{conditional-expression} $M$, +\begin{itemize} +\item +\tcode{$M$.size()} shall be a converted constant expression of +type \tcode{std::size_t} and +let $N$ denote the value of that expression, +\item +\tcode{$M$.data()}, implicitly converted to +the type ``pointer to \tcode{\keyword{const} \keyword{char}}'', +shall be a core constant expression and let $D$ denote the converted expression, +\item +for each $i$ where $0 \le i < N$, +\tcode{$D$[$i$]} shall be an integral constant expression, and +\item +the text of the \grammarterm{static_assert-message} is formed by +the sequence of $N$ code units, starting at $D$, of +the ordinary literal encoding\iref{lex.charset}. +\end{itemize} +\end{itemize} + +\pnum +\recommended +When a \grammarterm{static_assert-declaration} fails, +the resulting diagnostic message should include the text of +the \grammarterm{static_assert-message}, if one is supplied. \begin{example} \begin{codeblock} static_assert(sizeof(int) == sizeof(void*), "wrong pointer size"); diff --git a/source/preprocessor.tex b/source/preprocessor.tex index 3758cf2429..23f2fe9bbf 100644 --- a/source/preprocessor.tex +++ b/source/preprocessor.tex @@ -1856,7 +1856,7 @@ \defnxname{cpp_rvalue_references} & \tcode{200610L} \\ \rowsep \defnxname{cpp_size_t_suffix} & \tcode{202011L} \\ \rowsep \defnxname{cpp_sized_deallocation} & \tcode{201309L} \\ \rowsep -\defnxname{cpp_static_assert} & \tcode{201411L} \\ \rowsep +\defnxname{cpp_static_assert} & \tcode{202306L} \\ \rowsep \defnxname{cpp_static_call_operator} & \tcode{202207L} \\ \rowsep \defnxname{cpp_structured_bindings} & \tcode{201606L} \\ \rowsep \defnxname{cpp_template_template_args} & \tcode{201611L} \\ \rowsep From 28c4ef0522ff70d04856e9963881b8973294bc2a Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Mon, 19 Jun 2023 23:53:33 +0200 Subject: [PATCH 057/171] P2169R4 A nice placeholder with no name --- source/basic.tex | 39 ++++++++++++++++++++++++++++++++++++--- source/declarations.tex | 16 ++++++++++++++-- source/preprocessor.tex | 1 + 3 files changed, 51 insertions(+), 5 deletions(-) diff --git a/source/basic.tex b/source/basic.tex index 20d8970469..a87a7bdb73 100644 --- a/source/basic.tex +++ b/source/basic.tex @@ -987,14 +987,32 @@ \end{codeblock} \end{example} +\pnum +A declaration is \defnx{name-independent}{declaration!name-independent} +if its name is \tcode{_} and it declares +a variable with automatic storage duration, +a structured binding not inhabiting a namespace scope, +the variable introduced by an \grammarterm{init-capture}, or +a non-static data member. + +\recommended +Implementations should not emit a warning +that a name-independent declaration is used or unused. + \pnum \indextext{declaration!potentially conflict}% Two declarations \defn{potentially conflict} if they correspond and cause their shared name to denote different entities\iref{basic.link}. The program is ill-formed -if, in any scope, a name is bound to two declarations -that potentially conflict and one precedes the other\iref{basic.lookup}. +if, in any scope, a name is bound to two declarations $A$ and $B$ +that potentially conflict and $A$ precedes $B$\iref{basic.lookup}, +unless $B$ is name-independent. +\begin{note} +An \grammarterm{id-expression} that names a unique name-independent declaration +is usable until an additional declaration of the same name +is introduced in the same scope\iref{basic.lookup.general}. +\end{note} \begin{note} Overload resolution can consider potentially conflicting declarations found in multiple scopes @@ -1015,6 +1033,18 @@ namespace B = B; // OK, no effect namespace A = B; // OK, no effect namespace B {} // error: different entity for \tcode{B} + +void g() { + int _; + _ = 0; // OK + int _; // OK, name-independent declaration + _ = 0; // error: two non-function declarations in the lookup set +} +void h () { + int _; // \#1 + _ ++; // OK + static int _; // error: conflicts with \#1 because static variables are not name-independent +} \end{codeblock} \end{example} @@ -1236,7 +1266,9 @@ \end{example} \pnum -If a declaration whose target scope is the block scope $S$ of a +If a declaration +that is not a name-independent declaration and +whose target scope is the block scope $S$ of a \begin{itemize} \item \grammarterm{compound-statement} of a \grammarterm{lambda-expression}, @@ -2728,6 +2760,7 @@ for linkage purposes, if any\iref{dcl.typedef,dcl.enum}, they correspond\iref{basic.scope.scope}, have the same target scope that is not a function or template parameter scope, +neither is a name-independent declaration, and either \begin{itemize} \item diff --git a/source/declarations.tex b/source/declarations.tex index 58962c889a..15c6dc71e5 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -8055,9 +8055,21 @@ \pnum If a declaration named by a \grammarterm{using-declaration} -that inhabits the target scope of another declaration +that inhabits the target scope of another declaration $B$ potentially conflicts with it\iref{basic.scope.scope}, and -either is reachable from the other, the program is ill-formed. +either is reachable from the other, the program is ill-formed +unless $B$ is name-independent and +the \grammarterm{using-declaration} precedes $B$. +\begin{example} +\begin{codeblock} +int _; +void f() { + int _; // B + _ = 0; + using ::_; // error: \grammarterm{using-declaration} does not precede B +} +\end{codeblock} +\end{example} If two declarations named by \grammarterm{using-declaration}s that inhabit the same scope potentially conflict, either is reachable from the other, and diff --git a/source/preprocessor.tex b/source/preprocessor.tex index 23f2fe9bbf..c0e21559f9 100644 --- a/source/preprocessor.tex +++ b/source/preprocessor.tex @@ -1849,6 +1849,7 @@ \defnxname{cpp_nontype_template_args} & \tcode{201911L} \\ \rowsep \defnxname{cpp_nontype_template_parameter_auto} & \tcode{201606L} \\ \rowsep \defnxname{cpp_nsdmi} & \tcode{200809L} \\ \rowsep +\defnxname{cpp_placeholder_variables} & \tcode{202306L} \\ \rowsep \defnxname{cpp_range_based_for} & \tcode{202211L} \\ \rowsep \defnxname{cpp_raw_strings} & \tcode{200710L} \\ \rowsep \defnxname{cpp_ref_qualifiers} & \tcode{200710L} \\ \rowsep From d9c8933328cfb4a057fb45f0b615b85b6a0756b1 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Tue, 20 Jun 2023 08:37:56 +0200 Subject: [PATCH 058/171] [basic.scope.scope] Add Unicode name for underscore --- source/basic.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/basic.tex b/source/basic.tex index a87a7bdb73..4ba58bb4e7 100644 --- a/source/basic.tex +++ b/source/basic.tex @@ -989,7 +989,7 @@ \pnum A declaration is \defnx{name-independent}{declaration!name-independent} -if its name is \tcode{_} and it declares +if its name is \tcode{_} (\unicode{005f}{low line}) and it declares a variable with automatic storage duration, a structured binding not inhabiting a namespace scope, the variable introduced by an \grammarterm{init-capture}, or From 051d17d38bc782b13b588b0e3827e59a2050577f Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 21 Jun 2023 12:09:55 -0700 Subject: [PATCH 059/171] LWG2994 Needless UB for basic_string and basic_string_view --- source/strings.tex | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/strings.tex b/source/strings.tex index 66fc8b2094..3bd859e555 100644 --- a/source/strings.tex +++ b/source/strings.tex @@ -2368,9 +2368,7 @@ function or operator has no other effect on the \tcode{basic_string} object. \pnum -In every specialization \tcode{basic_string}, -the type \tcode{allocator_traits::value_type} shall name the same type -as \tcode{charT}. Every object of type +Every object of type \tcode{basic_string} uses an object of type \tcode{Allocator} to allocate and free storage for the contained \tcode{charT} objects as needed. The \tcode{Allocator} object used is @@ -2383,6 +2381,8 @@ an allocator-aware container, but does not use the allocator's \tcode{construct} and \tcode{destroy} member functions\iref{container.requirements.pre}. +The program is ill-formed if +\tcode{Allocator::value_type} is not the same type as \tcode{charT}. \end{note} \begin{note} The program is ill-formed if \tcode{traits::char_type} From 03da5baa5317c28b7d4c1e5e43ebadb995e4c663 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 21 Jun 2023 12:32:44 -0700 Subject: [PATCH 060/171] LWG3884 flat_foo is missing allocator-extended copy/move constructors --- source/containers.tex | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/source/containers.tex b/source/containers.tex index 39d1107df5..0a8a417d4d 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -14758,6 +14758,11 @@ // \ref{flat.map.cons}, construct/copy/destroy flat_map() : flat_map(key_compare()) { } + template + flat_map(const flat_map&, const Allocator& a); + template + flat_map(flat_map&&, const Allocator& a); + flat_map(key_container_type key_cont, mapped_container_type mapped_cont, const key_compare& comp = key_compare()); template @@ -15166,6 +15171,10 @@ \indexlibraryctor{flat_map}% \begin{itemdecl} +template + flat_map(const flat_map&, const Allocator& a); +template + flat_map(flat_map&&, const Allocator& a); template flat_map(const key_compare& comp, const Allocator& a); template @@ -15938,6 +15947,11 @@ // \ref{flat.multimap.cons}, construct/copy/destroy flat_multimap() : flat_multimap(key_compare()) { } + template + flat_multimap(const flat_multimap&, const Allocator& a); + template + flat_multimap(flat_multimap&&, const Allocator& a); + flat_multimap(key_container_type key_cont, mapped_container_type mapped_cont, const key_compare& comp = key_compare()); template @@ -16308,6 +16322,10 @@ \indexlibraryctor{flat_multimap}% \begin{itemdecl} +template + flat_multimap(const flat_multimap&, const Allocator& a); +template + flat_multimap(flat_multimap&&, const Allocator& a); template flat_multimap(const key_compare& comp, const Allocator& a); template @@ -16499,6 +16517,11 @@ // \ref{flat.set.cons}, constructors flat_set() : flat_set(key_compare()) { } + template + flat_set(const flat_set&, const Allocator& a); + template + flat_set(flat_set&&, const Allocator& a); + explicit flat_set(container_type cont, const key_compare& comp = key_compare()); template flat_set(const container_type& cont, const Allocator& a); @@ -16808,6 +16831,10 @@ \indexlibraryctor{flat_set}% \begin{itemdecl} +template + flat_set(const flat_set&, const Allocator& a); +template + flat_set(flat_set&&, const Allocator& a); template flat_set(const key_compare& comp, const Allocator& a); template @@ -17153,6 +17180,11 @@ // \ref{flat.multiset.cons}, constructors flat_multiset() : flat_multiset(key_compare()) { } + template + flat_multiset(const flat_multiset&, const Allocator& a); + template + flat_multiset(flat_multiset&&, const Allocator& a); + explicit flat_multiset(container_type cont, const key_compare& comp = key_compare()); template flat_multiset(const container_type& cont, const Allocator& a); @@ -17464,6 +17496,10 @@ \indexlibraryctor{flat_multiset}% \begin{itemdecl} +template + flat_multiset(const flat_multiset&, const Allocator& a); +template + flat_multiset(flat_multiset&&, const Allocator& a); template flat_multiset(const key_compare& comp, const Allocator& a); template From aa4dd7792470d33b8bb9254a8712416038910345 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 21 Jun 2023 12:35:30 -0700 Subject: [PATCH 061/171] LWG3885 'op' should be in [zombie.names] --- source/lib-intro.tex | 1 + 1 file changed, 1 insertion(+) diff --git a/source/lib-intro.tex b/source/lib-intro.tex index f5039472b1..944afab25e 100644 --- a/source/lib-intro.tex +++ b/source/lib-intro.tex @@ -2968,6 +2968,7 @@ \item \indexlibraryzombie{argument_type} \tcode{argument_type}, \item \indexlibraryzombie{first_argument_type} \tcode{first_argument_type}, \item \indexlibraryzombie{io_state} \tcode{io_state}, +\item \indexlibraryzombie{op} \tcode{op}, \item \indexlibraryzombie{open_mode} \tcode{open_mode}, \item \indexlibraryzombie{preferred} \tcode{preferred}, \item \indexlibraryzombie{second_argument_type} \tcode{second_argument_type}, From e25a755305c2250c358149994c3837d856813de5 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 21 Jun 2023 12:46:07 -0700 Subject: [PATCH 062/171] LWG3893 LWG 3661 broke atomic> a; a = nullptr; --- source/threads.tex | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/source/threads.tex b/source/threads.tex index e4fa6273c9..527bf57e7a 100644 --- a/source/threads.tex +++ b/source/threads.tex @@ -4905,6 +4905,7 @@ operator shared_ptr() const noexcept; void store(shared_ptr desired, memory_order order = memory_order::seq_cst) noexcept; void operator=(shared_ptr desired) noexcept; + void operator=(nullptr_t) noexcept; shared_ptr exchange(shared_ptr desired, memory_order order = memory_order::seq_cst) noexcept; @@ -4991,6 +4992,17 @@ Equivalent to \tcode{store(desired)}. \end{itemdescr} +\indexlibrarymember{operator=}{atomic>}% +\begin{itemdecl} +void operator=(nullptr_t) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Equivalent to \tcode{store(nullptr)}. +\end{itemdescr} + \indexlibrarymember{load}{atomic>}% \begin{itemdecl} shared_ptr load(memory_order order = memory_order::seq_cst) const noexcept; From 8f03433864cc4a8f783ce6c9560500ff27d8748f Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 21 Jun 2023 12:49:27 -0700 Subject: [PATCH 063/171] LWG3894 generator::promise_type::yield_value(ranges::elements_of) should not be noexcept --- source/ranges.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/ranges.tex b/source/ranges.tex index 851ed0248e..77da1e74ef 100644 --- a/source/ranges.tex +++ b/source/ranges.tex @@ -15957,7 +15957,7 @@ template requires @\libconcept{convertible_to}@, yielded> - auto yield_value(ranges::elements_of r) noexcept; + auto yield_value(ranges::elements_of r); void await_transform() = delete; @@ -16121,7 +16121,7 @@ \begin{itemdecl} template requires @\libconcept{convertible_to}@, yielded> - auto yield_value(ranges::elements_of r) noexcept; + auto yield_value(ranges::elements_of r); \end{itemdecl} \begin{itemdescr} From 0ce870684c5b88093ba8b106be551b4b8dbcf03e Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 21 Jun 2023 12:51:25 -0700 Subject: [PATCH 064/171] LWG3903 span destructor is redundantly noexcept --- source/containers.tex | 2 -- 1 file changed, 2 deletions(-) diff --git a/source/containers.tex b/source/containers.tex index 0a8a417d4d..3ec378df65 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -17844,8 +17844,6 @@ template constexpr explicit(@\seebelow@) span(const span& s) noexcept; - ~span() noexcept = default; - constexpr span& operator=(const span& other) noexcept = default; // \ref{span.sub}, subviews From fe5702cf22d6b57bb2004725bf7b624f3c196555 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 21 Jun 2023 12:54:06 -0700 Subject: [PATCH 065/171] LWG3904 lazy_split_view::outer-iterator's const-converting constructor isn't setting trailing_empty_ --- source/ranges.tex | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/source/ranges.tex b/source/ranges.tex index 77da1e74ef..71527b1726 100644 --- a/source/ranges.tex +++ b/source/ranges.tex @@ -7803,8 +7803,9 @@ \begin{itemdescr} \pnum \effects -Initializes \exposid{parent_} with \tcode{i.\exposid{parent_}} and -\exposid{current_} with \tcode{std::move(i.\exposid{current_})}. +Initializes \exposid{parent_} with \tcode{i.\exposid{parent_}}, +\exposid{current_} with \tcode{std::move(i.\exposid{current_})}, and +\exposid{trailing_empty_} with \tcode{i.\exposid{trailing_empty_}}. \end{itemdescr} \indexlibrarymember{operator*}{lazy_split_view::\exposid{outer-iterator}}% From b4e5007ba2f8e2ef04a34484114119ace4b2c1c5 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 21 Jun 2023 12:55:41 -0700 Subject: [PATCH 066/171] LWG3905 Type of std::fexcept_t --- source/numerics.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/numerics.tex b/source/numerics.tex index 785bb29f51..3f9a3cde71 100644 --- a/source/numerics.tex +++ b/source/numerics.tex @@ -125,7 +125,7 @@ namespace std { // types using fenv_t = @\textit{object type}@; - using fexcept_t = @\textit{integer type}@; + using fexcept_t = @\textit{object type}@; // functions int feclearexcept(int except); From e45205ca8c5d135feb39597ef5079d1ec306c1df Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 21 Jun 2023 13:39:14 -0700 Subject: [PATCH 067/171] LWG3912 enumerate_view::iterator::operator- should be noexcept --- source/ranges.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/ranges.tex b/source/ranges.tex index 71527b1726..a0ec16dd42 100644 --- a/source/ranges.tex +++ b/source/ranges.tex @@ -9634,7 +9634,7 @@ requires @\libconcept{random_access_range}@<@\exposid{Base}@>; friend constexpr @\exposid{iterator}@ operator-(const @\exposid{iterator}@& x, difference_type y) requires @\libconcept{random_access_range}@<@\exposid{Base}@>; - friend constexpr difference_type operator-(const @\exposid{iterator}@& x, const @\exposid{iterator}@& y); + friend constexpr difference_type operator-(const @\exposid{iterator}@& x, const @\exposid{iterator}@& y) noexcept; friend constexpr auto iter_move(const @\exposid{iterator}@& i) noexcept(noexcept(ranges::iter_move(i.@\exposid{current_}@)) && @@ -9901,7 +9901,7 @@ \indexlibrarymember{operator-}{enumerate_view::\exposid{iterator}}% \begin{itemdecl} -friend constexpr difference_type operator-(const @\exposid{iterator}@& x, const @\exposid{iterator}@& y); +friend constexpr difference_type operator-(const @\exposid{iterator}@& x, const @\exposid{iterator}@& y) noexcept; \end{itemdecl} \begin{itemdescr} From 6ed8e7aa6459d18470b0b61b68831a2ff708ef7c Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 21 Jun 2023 13:41:14 -0700 Subject: [PATCH 068/171] LWG3914 Inconsistent template-head of ranges::enumerate_view --- source/ranges.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/ranges.tex b/source/ranges.tex index a0ec16dd42..25021fd30c 100644 --- a/source/ranges.tex +++ b/source/ranges.tex @@ -433,8 +433,8 @@ } // \ref{range.enumerate}, enumerate view - template<@\libconcept{input_range}@ View> - requires @\libconcept{view}@ + template<@\libconcept{view}@ V> + requires @\seebelow@ class enumerate_view; // freestanding template From 0c3b5309b153edb2b2bfcf32b1f93f23fa9e29ac Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 21 Jun 2023 13:44:10 -0700 Subject: [PATCH 069/171] LWG3915 Redundant paragraph about expression variations --- source/ranges.tex | 8 -------- 1 file changed, 8 deletions(-) diff --git a/source/ranges.tex b/source/ranges.tex index 25021fd30c..c30a56a901 100644 --- a/source/ranges.tex +++ b/source/ranges.tex @@ -1265,14 +1265,6 @@ \end{itemdecl} \begin{itemdescr} -\pnum -The required expressions -\tcode{ranges::begin(t)} -and -\tcode{ranges::end(t)} -of the \libconcept{range} concept -do not require implicit expression variations\iref{concepts.equality}. - \pnum Given an expression \tcode{t} such that \tcode{decltype((t))} is \tcode{T\&}, \tcode{T} models \libconcept{range} only if From 32acefaf129ef9614da9744add6baf46bec2fd5b Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 21 Jun 2023 13:49:09 -0700 Subject: [PATCH 070/171] LWG3925 Concept formattable's definition is incorrect --- source/utilities.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/utilities.tex b/source/utilities.tex index c99d900ebc..86bdd254b9 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -15851,7 +15851,7 @@ template concept @\deflibconcept{formattable}@ = - @\exposconcept{formattable-with}@, basic_format_context<@\placeholder{fmt-iter-for}@>>; + @\exposconcept{formattable-with}@, basic_format_context<@\placeholder{fmt-iter-for}@, charT>>; \end{codeblock} \pnum From 90dc5f0898adf439d676a7931fd35ee1ed816146 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 21 Jun 2023 13:59:20 -0700 Subject: [PATCH 071/171] LWG3927 Unclear preconditions for operator[] for sequence containers --- source/containers.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/containers.tex b/source/containers.tex index 3ec378df65..4d49855d66 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -2176,8 +2176,8 @@ \tcode{reference; const_reference} for constant \tcode{a} \pnum -\returns -\tcode{*(a.begin() + n)} +\effects +Equivalent to: \tcode{return *(a.begin() + n);} \pnum \remarks From c0579dde6ff9584bead5ae9ccdff86ae681e1b11 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 21 Jun 2023 14:04:10 -0700 Subject: [PATCH 072/171] LWG3935 template constexpr complex& operator=(const complex&) has no specification --- source/numerics.tex | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/source/numerics.tex b/source/numerics.tex index 3f9a3cde71..81efc1e347 100644 --- a/source/numerics.tex +++ b/source/numerics.tex @@ -500,6 +500,23 @@ \tcode{*this}. \end{itemdescr} +\indexlibrarymember{operator=}{complex}% +\begin{itemdecl} +template constexpr complex& operator=(const complex& rhs); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Assigns the value \tcode{rhs.real()} to the real part and +the value \tcode{rhs.imag()} to the imaginary part +of the complex value \tcode{*this}. + +\pnum +\returns +\tcode{*this}. +\end{itemdescr} + \indexlibrarymember{operator+=}{complex}% \begin{itemdecl} template constexpr complex& operator+=(const complex& rhs); From 756d2cac8df25e08c3da86ca7b31bb1d2310367a Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 21 Jun 2023 14:12:27 -0700 Subject: [PATCH 073/171] LWG3938 Cannot use std::expected monadic ops with move-only error_type --- source/utilities.tex | 44 ++++++++++++++++++++++---------------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/source/utilities.tex b/source/utilities.tex index 86bdd254b9..8cb4e79509 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -8310,7 +8310,7 @@ \begin{itemdescr} \pnum -Let \tcode{U} be \tcode{remove_cvref_t>}. +Let \tcode{U} be \tcode{remove_cvref_t>}. \pnum \constraints @@ -8326,7 +8326,7 @@ Equivalent to: \begin{codeblock} if (has_value()) - return invoke(std::forward(f), value()); + return invoke(std::forward(f), **this); else return U(unexpect, error()); \end{codeblock} @@ -8341,7 +8341,7 @@ \begin{itemdescr} \pnum Let \tcode{U} be -\tcode{remove_cvref_t>}. +\tcode{remove_cvref_t>}. \pnum \constraints @@ -8357,7 +8357,7 @@ Equivalent to: \begin{codeblock} if (has_value()) - return invoke(std::forward(f), std::move(value())); + return invoke(std::forward(f), std::move(**this)); else return U(unexpect, std::move(error())); \end{codeblock} @@ -8375,7 +8375,7 @@ \pnum \constraints -\tcode{is_constructible_v} is \tcode{true}. +\tcode{is_constructible_v} is \tcode{true}. \pnum \mandates @@ -8387,7 +8387,7 @@ Equivalent to: \begin{codeblock} if (has_value()) - return G(in_place, value()); + return G(in_place, **this); else return invoke(std::forward(f), error()); \end{codeblock} @@ -8406,7 +8406,7 @@ \pnum \constraints -\tcode{is_constructible_v} is \tcode{true}. +\tcode{is_constructible_v} is \tcode{true}. \pnum \mandates @@ -8418,7 +8418,7 @@ Equivalent to: \begin{codeblock} if (has_value()) - return G(in_place, std::move(value())); + return G(in_place, std::move(**this)); else return invoke(std::forward(f), std::move(error())); \end{codeblock} @@ -8433,7 +8433,7 @@ \begin{itemdescr} \pnum Let \tcode{U} be -\tcode{remove_cv_t>}. +\tcode{remove_cv_t>}. \pnum \constraints @@ -8445,7 +8445,7 @@ If \tcode{is_void_v} is \tcode{false}, the declaration \begin{codeblock} -U u(invoke(std::forward(f), value())); +U u(invoke(std::forward(f), **this)); \end{codeblock} is well-formed. @@ -8459,9 +8459,9 @@ Otherwise, if \tcode{is_void_v} is \tcode{false}, returns an \tcode{expected} object whose \exposid{has_val} member is \tcode{true} and \exposid{val} member is direct-non-list-initialized with -\tcode{invoke(std::forward(f), value())}. +\tcode{invoke(std::forward(f), **this)}. \item -Otherwise, evaluates \tcode{invoke(std::forward(f), value())} and then +Otherwise, evaluates \tcode{invoke(std::forward(f), **this)} and then returns \tcode{expected()}. \end{itemize} \end{itemdescr} @@ -8475,7 +8475,7 @@ \begin{itemdescr} \pnum Let \tcode{U} be -\tcode{remove_cv_t>}. +\tcode{remove_cv_t>}. \pnum \constraints @@ -8486,9 +8486,9 @@ \tcode{U} is a valid value type for \tcode{expected}. If \tcode{is_void_v} is \tcode{false}, the declaration \begin{codeblock} -U u(invoke(std::forward(f), std::move(value()))); +U u(invoke(std::forward(f), std::move(**this))); \end{codeblock} -is well-formed for some invented variable \tcode{u}. +is well-formed. \pnum \effects @@ -8500,10 +8500,10 @@ Otherwise, if \tcode{is_void_v} is \tcode{false}, returns an \tcode{expected} object whose \exposid{has_val} member is \tcode{true} and \exposid{val} member is direct-non-list-initialized with -\tcode{invoke(std::forward(f), std::move(value()))}. +\tcode{invoke(std::forward(f), std::move(**this))}. \item -Otherwise, evaluates \tcode{invoke(std::forward(f), std::move(value()))} and -then returns \tcode{expected()}. +Otherwise, evaluates \tcode{invoke(std::forward(f), std::move(**this))} and +then returns \tcode{ex\-pected()}. \end{itemize} \end{itemdescr} @@ -8519,7 +8519,7 @@ \pnum \constraints -\tcode{is_constructible_v} is \tcode{true}. +\tcode{is_constructible_v} is \tcode{true}. \pnum \mandates @@ -8533,7 +8533,7 @@ \pnum \returns If \tcode{has_value()} is \tcode{true}, -\tcode{expected(in_place, value())}; otherwise, an \tcode{expected} +\tcode{expected(in_place, **this)}; otherwise, an \tcode{expected} object whose \exposid{has_val} member is \tcode{false} and \exposid{unex} member is direct-non-list-initialized with \tcode{invoke(std::forward(f), error())}. \end{itemdescr} @@ -8551,7 +8551,7 @@ \pnum \constraints -\tcode{is_constructible_v} is \tcode{true}. +\tcode{is_constructible_v} is \tcode{true}. \pnum \mandates @@ -8565,7 +8565,7 @@ \pnum \returns If \tcode{has_value()} is \tcode{true}, -\tcode{expected(in_place, std::move(value()))}; otherwise, an +\tcode{expected(in_place, std::move(**this))}; otherwise, an \tcode{expected} object whose \exposid{has_val} member is \tcode{false} and \exposid{unex} member is direct-non-list-initialized with \tcode{invoke(std::forward(f), std::move(error()))}. From 14eb0ae4c95202fc9c877cf3268473a35179fdd2 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 21 Jun 2023 14:15:54 -0700 Subject: [PATCH 074/171] LWG3940 std::expected::value() also needs E to be copy constructible --- source/utilities.tex | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/source/utilities.tex b/source/utilities.tex index 8cb4e79509..3a89948f7b 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -9188,6 +9188,10 @@ \end{itemdecl} \begin{itemdescr} +\pnum +\mandates +\tcode{is_copy_constructible_v} is \tcode{true}. + \pnum \throws \tcode{bad_expected_access(error())} if \tcode{has_value()} is \tcode{false}. @@ -9199,6 +9203,11 @@ \end{itemdecl} \begin{itemdescr} +\pnum +\mandates +\tcode{is_copy_constructible_v} is \tcode{true} and +\tcode{is_move_constructible_v} is \tcode{true}. + \pnum \throws \tcode{bad_expected_access(std::move(error()))} From b9a6c7bc8440a465e974b462509ec47968520c4a Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Wed, 21 Jun 2023 10:43:20 +0100 Subject: [PATCH 075/171] P2497R0 Testing for success or failure of functions --- source/support.tex | 2 +- source/utilities.tex | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/source/support.tex b/source/support.tex index 60320199c9..6ff283cefb 100644 --- a/source/support.tex +++ b/source/support.tex @@ -735,7 +735,7 @@ #define @\defnlibxname{cpp_lib_three_way_comparison}@ 201907L // also in \libheader{compare} #define @\defnlibxname{cpp_lib_to_address}@ 201711L // also in \libheader{memory} #define @\defnlibxname{cpp_lib_to_array}@ 201907L // also in \libheader{array} -#define @\defnlibxname{cpp_lib_to_chars}@ 201611L // also in \libheader{charconv} +#define @\defnlibxname{cpp_lib_to_chars}@ 202306L // also in \libheader{charconv} #define @\defnlibxname{cpp_lib_to_underlying}@ 202102L // also in \libheader{utility} #define @\defnlibxname{cpp_lib_transformation_trait_aliases}@ 201304L // also in \libheader{type_traits} #define @\defnlibxname{cpp_lib_transparent_operators}@ 201510L // also in \libheader{memory}, \libheader{functional} diff --git a/source/utilities.tex b/source/utilities.tex index 3a89948f7b..02efe320ba 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -14201,6 +14201,7 @@ char* ptr; errc ec; friend bool operator==(const to_chars_result&, const to_chars_result&) = default; + constexpr explicit operator bool() const noexcept { return ec == errc{}; } }; constexpr to_chars_result to_chars(char* first, char* last, @\placeholder{integer-type}@ value, int base = 10); @@ -14220,6 +14221,7 @@ const char* ptr; errc ec; friend bool operator==(const from_chars_result&, const from_chars_result&) = default; + constexpr explicit operator bool() const noexcept { return ec == errc{}; } }; constexpr from_chars_result from_chars(const char* first, const char* last, From 4ad996bb7c8c5c750928eedc9e902cf986d4c166 Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Wed, 21 Jun 2023 12:38:19 +0100 Subject: [PATCH 076/171] P2592R3 Hashing support for std::chrono value classes --- source/support.tex | 2 +- source/time.tex | 120 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 121 insertions(+), 1 deletion(-) diff --git a/source/support.tex b/source/support.tex index 6ff283cefb..ad3581bc4c 100644 --- a/source/support.tex +++ b/source/support.tex @@ -585,7 +585,7 @@ #define @\defnlibxname{cpp_lib_byteswap}@ 202110L // also in \libheader{bit} #define @\defnlibxname{cpp_lib_char8_t}@ 201907L // also in \libheader{atomic}, \libheader{filesystem}, \libheader{istream}, \libheader{limits}, \libheader{locale}, \libheader{ostream}, \libheader{string}, \libheader{string_view} -#define @\defnlibxname{cpp_lib_chrono}@ 201907L // also in \libheader{chrono} +#define @\defnlibxname{cpp_lib_chrono}@ 202306L // also in \libheader{chrono} #define @\defnlibxname{cpp_lib_chrono_udls}@ 201304L // also in \libheader{chrono} #define @\defnlibxname{cpp_lib_clamp}@ 201603L // also in \libheader{algorithm} #define @\defnlibxname{cpp_lib_common_reference}@ 202302L // also in \libheader{type_traits} diff --git a/source/time.tex b/source/time.tex index 34911e8f7e..4b75dc2a7a 100644 --- a/source/time.tex +++ b/source/time.tex @@ -942,6 +942,31 @@ namespace std::chrono { using namespace literals::chrono_literals; } + +namespace std { + // \ref{time.hash}, hash support + template struct hash; + template struct hash>; + template struct hash>; + template<> struct hash; + template<> struct hash; + template<> struct hash; + template<> struct hash; + template<> struct hash; + template<> struct hash; + template<> struct hash; + template<> struct hash; + template<> struct hash; + template<> struct hash; + template<> struct hash; + template<> struct hash; + template<> struct hash; + template<> struct hash; + template<> struct hash; + template + struct hash>; + template<> struct hash; +} \end{codeblock} \rSec1[time.clock.req]{\oldconcept{Clock} requirements} @@ -11449,6 +11474,101 @@ \indexlibrary{\idxcode{parse}|)} +\rSec1[time.hash]{Hash support} + +\indexlibrarymember{hash}{duration}% +\begin{itemdecl} +template struct hash>; +\end{itemdecl} + +\begin{itemdescr} +\pnum +The specialization \tcode{hash>} is enabled\iref{unord.hash} +if and only if \\% newline to fix overfull hbox +\tcode{hash} is enabled. +The member functions are not guaranteed to be \keyword{noexcept}. +\end{itemdescr} + +\indexlibrarymember{hash}{time_point}% +\begin{itemdecl} +template struct hash>; +\end{itemdecl} + +\begin{itemdescr} +\pnum +The specialization \tcode{hash>} is enabled\iref{unord.hash} +if and only if \tcode{hash} is enabled. +The member functions are not guaranteed to be \keyword{noexcept}. +\end{itemdescr} + +\indexlibrarymember{hash}{day}% +\indexlibrarymember{hash}{month}% +\indexlibrarymember{hash}{year}% +\indexlibrarymember{hash}{weekday}% +\indexlibrarymember{hash}{weekday_indexed}% +\indexlibrarymember{hash}{weekday_last}% +\indexlibrarymember{hash}{month_day}% +\indexlibrarymember{hash}{month_day_last}% +\indexlibrarymember{hash}{month_weekday}% +\indexlibrarymember{hash}{month_weekday_last}% +\indexlibrarymember{hash}{year_month}% +\indexlibrarymember{hash}{year_month_day}% +\indexlibrarymember{hash}{year_month_day_last}% +\indexlibrarymember{hash}{year_month_weekday}% +\indexlibrarymember{hash}{year_month_weekday_last}% +\begin{itemdecl} +template<> struct hash; +template<> struct hash; +template<> struct hash; +template<> struct hash; +template<> struct hash; +template<> struct hash; +template<> struct hash; +template<> struct hash; +template<> struct hash; +template<> struct hash; +template<> struct hash; +template<> struct hash; +template<> struct hash; +template<> struct hash; +template<> struct hash; +\end{itemdecl} + +\begin{itemdescr} +\pnum +The specializations are enabled\iref{unord.hash}. +\begin{note} +All the \tcode{hash} specializations listed above meet the +\oldconcept{Cpp17Hash} requirements, even when called on objects \tcode{k} +of type \tcode{Key} such that \tcode{k.ok()} is \tcode{false}. +\end{note} +\end{itemdescr} + +\indexlibrarymember{hash}{zoned_time}% +\begin{itemdecl} +template + struct hash>; +\end{itemdecl} + +\begin{itemdescr} +\pnum +The specialization \tcode{hash>} +is enabled\iref{unord.hash} +if and only if \tcode{hash} is enabled and +\tcode{hash} is enabled. +The member functions are not guaranteed to be \keyword{noexcept}. +\end{itemdescr} + +\indexlibrarymember{hash}{leap_second}% +\begin{itemdecl} +template<> struct hash; +\end{itemdecl} + +\begin{itemdescr} +\pnum +The specialization is enabled\iref{unord.hash}. +\end{itemdescr} + \rSec1[ctime.syn]{Header \tcode{} synopsis} \indexheader{ctime}% From de67fc3b31c606da2a279739aa7542c299b4d53f Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Wed, 21 Jun 2023 11:37:48 +0100 Subject: [PATCH 077/171] P2587R3 to_string or not to_string Editorial notes: - Fixed incorrect output in [diff.cpp23.strings] example. --- source/compatibility.tex | 18 ++++++++++++++++++ source/strings.tex | 27 ++------------------------- source/support.tex | 1 + 3 files changed, 21 insertions(+), 25 deletions(-) diff --git a/source/compatibility.tex b/source/compatibility.tex index fd56f1a4d6..d3dad60bbf 100644 --- a/source/compatibility.tex +++ b/source/compatibility.tex @@ -31,6 +31,24 @@ bool b = ne({2,3}, {1,2,3}); // unspecified result; previously \tcode{false} \end{example} +\rSec2[diff.cpp23.strings]{\ref{strings}: strings library} + +\diffref{string.conversions} +\change +Output of floating-point overloads of \tcode{to_string} and \tcode{to_wstring}. +\rationale +Prevent loss of information and improve consistency with other formatting +facilities. +\effect +\tcode{to_string} and \tcode{to_wstring} function calls that take +floating-point arguments may produce a different output. +For example: +\begin{codeblock} +auto s = std::to_string(1e-7); // \tcode{"1e-07"} + // previously \tcode{"0.000000"} with \tcode{'.'} possibly + // changed according to the global C locale +\end{codeblock} + \rSec1[diff.cpp20]{\Cpp{} and ISO \CppXX{}} \rSec2[diff.cpp20.general]{General} diff --git a/source/strings.tex b/source/strings.tex index 3bd859e555..55b41e31ee 100644 --- a/source/strings.tex +++ b/source/strings.tex @@ -5196,18 +5196,7 @@ \begin{itemdescr} \pnum \returns -Each function returns a \tcode{string} object holding the character -representation of the value of its argument that would be generated by calling -\tcode{sprintf(buf, fmt, val)} with a format specifier of -\tcode{"\%d"}, -\tcode{"\%u"}, -\tcode{"\%ld"}, -\tcode{"\%lu"}, -\tcode{"\%lld"}, \tcode{"\%llu"}, -\tcode{"\%f"}, -\tcode{"\%f"}, -or \tcode{"\%Lf"}, respectively, where \tcode{buf} designates an internal -character buffer of sufficient size. +\tcode{format("\{\}", val)}. \end{itemdescr} \indexlibraryglobal{stoi}% @@ -5294,19 +5283,7 @@ \begin{itemdescr} \pnum \returns -Each function returns a \tcode{wstring} object holding the character -representation of the value of its argument that would be generated by calling -\tcode{swprintf(buf, buffsz, fmt, val)} with a format specifier of -\tcode{L"\%d"}, -\tcode{L"\%u"}, -\tcode{L"\%ld"}, -\tcode{L"\%lu"}, -\tcode{L"\%lld"}, -\tcode{L"\%llu"}, -\tcode{L"\%f"}, -\tcode{L"\%f"}, -or \tcode{L"\%Lf"}, respectively, where \tcode{buf} designates an -internal character buffer of sufficient size \tcode{buffsz}. +\tcode{format(L"\{\}", val)}. \end{itemdescr} \rSec2[basic.string.hash]{Hash support} diff --git a/source/support.tex b/source/support.tex index ad3581bc4c..86e15e178e 100644 --- a/source/support.tex +++ b/source/support.tex @@ -736,6 +736,7 @@ #define @\defnlibxname{cpp_lib_to_address}@ 201711L // also in \libheader{memory} #define @\defnlibxname{cpp_lib_to_array}@ 201907L // also in \libheader{array} #define @\defnlibxname{cpp_lib_to_chars}@ 202306L // also in \libheader{charconv} +#define @\defnlibxname{cpp_lib_to_string}@ 202306L // also in \libheader{string} #define @\defnlibxname{cpp_lib_to_underlying}@ 202102L // also in \libheader{utility} #define @\defnlibxname{cpp_lib_transformation_trait_aliases}@ 201304L // also in \libheader{type_traits} #define @\defnlibxname{cpp_lib_transparent_operators}@ 201510L // also in \libheader{memory}, \libheader{functional} From f66d6cd28790df80ae4aa5c80be78345c29b0f00 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Thu, 22 Jun 2023 23:52:18 +0200 Subject: [PATCH 078/171] P2562R1 constexpr Stable Sorting --- source/algorithms.tex | 34 +++++++++++++++++----------------- source/support.tex | 2 +- 2 files changed, 18 insertions(+), 18 deletions(-) diff --git a/source/algorithms.tex b/source/algorithms.tex index b6a4acd763..3925bbe20d 100644 --- a/source/algorithms.tex +++ b/source/algorithms.tex @@ -2011,9 +2011,9 @@ } template - void stable_sort(RandomAccessIterator first, RandomAccessIterator last); + constexpr void stable_sort(RandomAccessIterator first, RandomAccessIterator last); template - void stable_sort(RandomAccessIterator first, RandomAccessIterator last, + constexpr void stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp); template void stable_sort(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} @@ -2027,10 +2027,10 @@ template<@\libconcept{random_access_iterator}@ I, @\libconcept{sentinel_for}@ S, class Comp = ranges::less, class Proj = identity> requires @\libconcept{sortable}@ - I stable_sort(I first, S last, Comp comp = {}, Proj proj = {}); + constexpr I stable_sort(I first, S last, Comp comp = {}, Proj proj = {}); template<@\libconcept{random_access_range}@ R, class Comp = ranges::less, class Proj = identity> requires @\libconcept{sortable}@, Comp, Proj> - borrowed_iterator_t + constexpr borrowed_iterator_t stable_sort(R&& r, Comp comp = {}, Proj proj = {}); } @@ -2311,9 +2311,9 @@ } template - BidirectionalIterator stable_partition(BidirectionalIterator first, - BidirectionalIterator last, - Predicate pred); + constexpr BidirectionalIterator stable_partition(BidirectionalIterator first, + BidirectionalIterator last, + Predicate pred); template BidirectionalIterator stable_partition(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} BidirectionalIterator first, @@ -2324,11 +2324,11 @@ template<@\libconcept{bidirectional_iterator}@ I, @\libconcept{sentinel_for}@ S, class Proj = identity, @\libconcept{indirect_unary_predicate}@> Pred> requires @\libconcept{permutable}@ - subrange stable_partition(I first, S last, Pred pred, Proj proj = {}); + constexpr subrange stable_partition(I first, S last, Pred pred, Proj proj = {}); template<@\libconcept{bidirectional_range}@ R, class Proj = identity, @\libconcept{indirect_unary_predicate}@, Proj>> Pred> requires @\libconcept{permutable}@> - borrowed_subrange_t stable_partition(R&& r, Pred pred, Proj proj = {}); + constexpr borrowed_subrange_t stable_partition(R&& r, Pred pred, Proj proj = {}); } template - void inplace_merge(BidirectionalIterator first, - BidirectionalIterator middle, - BidirectionalIterator last); + constexpr void inplace_merge(BidirectionalIterator first, + BidirectionalIterator middle, + BidirectionalIterator last); template - void inplace_merge(BidirectionalIterator first, - BidirectionalIterator middle, - BidirectionalIterator last, Compare comp); + constexpr void inplace_merge(BidirectionalIterator first, + BidirectionalIterator middle, + BidirectionalIterator last, Compare comp); template void inplace_merge(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} BidirectionalIterator first, @@ -2449,10 +2449,10 @@ template<@\libconcept{bidirectional_iterator}@ I, @\libconcept{sentinel_for}@ S, class Comp = ranges::less, class Proj = identity> requires @\libconcept{sortable}@ - I inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {}); + constexpr I inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {}); template<@\libconcept{bidirectional_range}@ R, class Comp = ranges::less, class Proj = identity> requires @\libconcept{sortable}@, Comp, Proj> - borrowed_iterator_t + constexpr borrowed_iterator_t inplace_merge(R&& r, iterator_t middle, Comp comp = {}, Proj proj = {}); } diff --git a/source/support.tex b/source/support.tex index 86e15e178e..7628f2861c 100644 --- a/source/support.tex +++ b/source/support.tex @@ -592,7 +592,7 @@ #define @\defnlibxname{cpp_lib_common_reference_wrapper}@ 202302L // also in \libheader{functional} #define @\defnlibxname{cpp_lib_complex_udls}@ 201309L // also in \libheader{complex} #define @\defnlibxname{cpp_lib_concepts}@ 202207L // also in \libheader{concepts}, \libheader{compare} -#define @\defnlibxname{cpp_lib_constexpr_algorithms}@ 201806L // also in \libheader{algorithm}, \libheader{utility} +#define @\defnlibxname{cpp_lib_constexpr_algorithms}@ 202306L // also in \libheader{algorithm}, \libheader{utility} #define @\defnlibxname{cpp_lib_constexpr_bitset}@ 202207L // also in \libheader{bitset} #define @\defnlibxname{cpp_lib_constexpr_charconv}@ 202207L // also in \libheader{charconv} #define @\defnlibxname{cpp_lib_constexpr_cmath}@ 202202L // also in \libheader{cmath}, \libheader{cstdlib} From 086a6f36f76348a02aed26169b367e8e1aee4b82 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Sat, 24 Jun 2023 22:18:42 +0200 Subject: [PATCH 079/171] [algorithms] Apply constexpr to corresponding detailed specifications --- source/algorithms.tex | 33 +++++++++++++++++---------------- 1 file changed, 17 insertions(+), 16 deletions(-) diff --git a/source/algorithms.tex b/source/algorithms.tex index 3925bbe20d..b583ba13af 100644 --- a/source/algorithms.tex +++ b/source/algorithms.tex @@ -6714,14 +6714,14 @@ \indexlibraryglobal{stable_sort}% \begin{itemdecl} template - void stable_sort(RandomAccessIterator first, RandomAccessIterator last); + constexpr void stable_sort(RandomAccessIterator first, RandomAccessIterator last); template void stable_sort(ExecutionPolicy&& exec, RandomAccessIterator first, RandomAccessIterator last); template - void stable_sort(RandomAccessIterator first, RandomAccessIterator last, - Compare comp); + constexpr void stable_sort(RandomAccessIterator first, RandomAccessIterator last, + Compare comp); template void stable_sort(ExecutionPolicy&& exec, RandomAccessIterator first, RandomAccessIterator last, @@ -6730,10 +6730,10 @@ template<@\libconcept{random_access_iterator}@ I, @\libconcept{sentinel_for}@ S, class Comp = ranges::less, class Proj = identity> requires @\libconcept{sortable}@ - I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {}); + constexpr I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {}); template<@\libconcept{random_access_range}@ R, class Comp = ranges::less, class Proj = identity> requires @\libconcept{sortable}@, Comp, Proj> - borrowed_iterator_t + constexpr borrowed_iterator_t ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {}); \end{itemdecl} @@ -7512,7 +7512,8 @@ \begin{itemdecl} template BidirectionalIterator - stable_partition(BidirectionalIterator first, BidirectionalIterator last, Predicate pred); + constexpr stable_partition(BidirectionalIterator first, BidirectionalIterator last, + Predicate pred); template BidirectionalIterator stable_partition(ExecutionPolicy&& exec, @@ -7521,11 +7522,11 @@ template<@\libconcept{bidirectional_iterator}@ I, @\libconcept{sentinel_for}@ S, class Proj = identity, @\libconcept{indirect_unary_predicate}@> Pred> requires @\libconcept{permutable}@ - subrange ranges::stable_partition(I first, S last, Pred pred, Proj proj = {}); + constexpr subrange ranges::stable_partition(I first, S last, Pred pred, Proj proj = {}); template<@\libconcept{bidirectional_range}@ R, class Proj = identity, @\libconcept{indirect_unary_predicate}@, Proj>> Pred> requires @\libconcept{permutable}@> - borrowed_subrange_t ranges::stable_partition(R&& r, Pred pred, Proj proj = {}); + constexpr borrowed_subrange_t ranges::stable_partition(R&& r, Pred pred, Proj proj = {}); \end{itemdecl} \begin{itemdescr} @@ -7792,9 +7793,9 @@ \indexlibraryglobal{inplace_merge}% \begin{itemdecl} template - void inplace_merge(BidirectionalIterator first, - BidirectionalIterator middle, - BidirectionalIterator last); + constexpr void inplace_merge(BidirectionalIterator first, + BidirectionalIterator middle, + BidirectionalIterator last); template void inplace_merge(ExecutionPolicy&& exec, BidirectionalIterator first, @@ -7802,9 +7803,9 @@ BidirectionalIterator last); template - void inplace_merge(BidirectionalIterator first, - BidirectionalIterator middle, - BidirectionalIterator last, Compare comp); + constexpr void inplace_merge(BidirectionalIterator first, + BidirectionalIterator middle, + BidirectionalIterator last, Compare comp); template void inplace_merge(ExecutionPolicy&& exec, BidirectionalIterator first, @@ -7814,7 +7815,7 @@ template<@\libconcept{bidirectional_iterator}@ I, @\libconcept{sentinel_for}@ S, class Comp = ranges::less, class Proj = identity> requires @\libconcept{sortable}@ - I ranges::inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {}); + constexpr I ranges::inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {}); \end{itemdecl} \begin{itemdescr} @@ -7865,7 +7866,7 @@ \begin{itemdecl} template<@\libconcept{bidirectional_range}@ R, class Comp = ranges::less, class Proj = identity> requires @\libconcept{sortable}@, Comp, Proj> - borrowed_iterator_t + constexpr borrowed_iterator_t ranges::inplace_merge(R&& r, iterator_t middle, Comp comp = {}, Proj proj = {}); \end{itemdecl} From 83aa524becc6db7a987a498d5c747cf0a21d5d1a Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Fri, 23 Jun 2023 01:54:40 +0200 Subject: [PATCH 080/171] P2545R4 Read-Copy Update (RCU) --- source/lib-intro.tex | 1 + source/support.tex | 1 + source/threads.tex | 359 ++++++++++++++++++++++++++++++++++++++++++- 3 files changed, 360 insertions(+), 1 deletion(-) diff --git a/source/lib-intro.tex b/source/lib-intro.tex index 944afab25e..27004e1e41 100644 --- a/source/lib-intro.tex +++ b/source/lib-intro.tex @@ -1114,6 +1114,7 @@ \tcode{} \\ \tcode{} \\ \tcode{} \\ +\tcode{} \\ \tcode{} \\ \tcode{} \\ \tcode{} \\ diff --git a/source/support.tex b/source/support.tex index 7628f2861c..9fa6a3c561 100644 --- a/source/support.tex +++ b/source/support.tex @@ -706,6 +706,7 @@ #define @\defnlibxname{cpp_lib_ranges_to_container}@ 202202L // also in \libheader{ranges} #define @\defnlibxname{cpp_lib_ranges_zip}@ 202110L // also in \libheader{ranges}, \libheader{tuple}, \libheader{utility} #define @\defnlibxname{cpp_lib_raw_memory_algorithms}@ 201606L // also in \libheader{memory} +#define @\defnlibxname{cpp_lib_rcu}@ 202306L // also in \libheader{rcu} #define @\defnlibxname{cpp_lib_reference_from_temporary}@ 202202L // also in \libheader{type_traits} #define @\defnlibxname{cpp_lib_remove_cvref}@ 201711L // also in \libheader{type_traits} #define @\defnlibxname{cpp_lib_result_of_sfinae}@ 201210L // also in \libheader{functional}, \libheader{type_traits} diff --git a/source/threads.tex b/source/threads.tex index 527bf57e7a..2e28982f72 100644 --- a/source/threads.tex +++ b/source/threads.tex @@ -20,7 +20,8 @@ \ref{thread.condition}& Condition variables & \tcode{} \\ \rowsep \ref{thread.sema} & Semaphores & \tcode{} \\ \rowsep \ref{thread.coord} & Coordination types & \tcode{} \tcode{} \\ \rowsep -\ref{futures} & Futures & \tcode{} \\ +\ref{futures} & Futures & \tcode{} \\ \rowsep +\ref{saferecl} & Safe reclamation & \tcode{} \\ \end{libsumtab} \rSec1[thread.req]{Requirements} @@ -11661,3 +11662,359 @@ \effects As if by \tcode{x.swap(y)}. \end{itemdescr} + +\rSec1[saferecl]{Safe reclamation} + +\rSec2[saferecl.general]{General} + +\pnum +Subclause \ref{saferecl} contains safe-reclamation techniques, which are most +frequently used to straightforwardly resolve access-deletion races. + +\rSec2[saferecl.rcu]{Read-copy update (RCU)} + +\rSec3[saferecl.rcu.general]{General} + +\pnum +RCU is a synchronization mechanism +that can be used for linked data structures +that are frequently read, but seldom updated. +RCU does not provide mutual exclusion, +but instead allows the user to schedule specified actions +such as deletion at some later time. + +\pnum +A class type \tcode{T} is \defn{rcu-protectable} +if it has exactly one base class of type \tcode{rcu_obj_base} +for some \tcode{D}, and that base is public and non-virtual, and +it has no base classes of type \tcode{rcu_obj_base} +for any other combination \tcode{X}, \tcode{Y}. +An object is rcu-protectable if it is of rcu-protectable type. + +\pnum +An invocation of \tcode{unlock} $U$ on an \tcode{rcu_domain dom} +corresponds to an invocation of \tcode{lock} $L$ on \tcode{dom} +if $L$ is sequenced before $U$ and either +\begin{itemize} +\item +no other invocation of \tcode{lock} on \tcode{dom} +is sequenced after $L$ and before $U$, or +\item +every invocation of \tcode{unlock} $U2$ on \tcode{dom} +such that $L$ is sequenced before $U2$ and $U2$ is sequenced before $U$ +corresponds to an invocation of \tcode{lock} $L2$ on \tcode{dom} +such that $L$ is sequenced before $L2$ and $L2$ is sequenced before $U2$. +\end{itemize} +\begin{note} +This pairs nested locks and unlocks on a given domain in each thread. +\end{note} + +\pnum +A \defn{region of RCU protection} on a domain \tcode{dom} +starts with a \tcode{lock} $L$ on \tcode{dom} and +ends with its corresponding \tcode{unlock} $U$. + +\pnum +Given a region of RCU protection $R$ on a domain \tcode{dom} and +given an evaluation $E$ that scheduled another evaluation $F$ in \tcode{dom}, +if $E$ does not strongly happen before the start of $R$, +the end of $R$ strongly happens before evaluating $F$. + +\pnum +The evaluation of a scheduled evaluation is potentially concurrent with +any other scheduled evaluation. +Each scheduled evaluation is evaluated at most once. + +\rSec3[rcu.syn]{Header \tcode{} synopsis} + +\indexheader{rcu} +\begin{codeblock} +namespace std { + // \ref{saferecl.rcu.base}, class template \tcode{rcu_obj_base} + template> class rcu_obj_base; + + // \ref{saferecl.rcu.domain}, class \tcode{rcu_domain} + class rcu_domain; + rcu_domain& rcu_default_domain() noexcept; + void rcu_synchronize(rcu_domain& dom = rcu_default_domain()) noexcept; + void rcu_barrier(rcu_domain& dom = rcu_default_domain()) noexcept; + template> + void rcu_retire(T* p, D d = D(), rcu_domain& dom = rcu_default_domain()); +} +\end{codeblock} + +\rSec3[saferecl.rcu.base]{Class template \tcode{rcu_obj_base}} + +\pnum +Objects of type \tcode{T} to be protected by RCU inherit from +a specialization of \tcode{rcu_obj_base}. + +\begin{codeblock} +namespace std { + template> + class rcu_obj_base { + public: + void retire(D d = D(), rcu_domain& dom = rcu_default_domain()) noexcept; + protected: + rcu_obj_base() = default; + rcu_obj_base(const rcu_obj_base&) = default; + rcu_obj_base(rcu_obj_base&&) = default; + rcu_obj_base& operator=(const rcu_obj_base&) = default; + rcu_obj_base& operator=(rcu_obj_base&&) = default; + ~rcu_obj_base() = default; + private: + D @\exposid{deleter}@; // \expos + }; +} +\end{codeblock} + +\pnum +The behavior of a program that adds specializations for \tcode{rcu_obj_base} +is undefined. + +\pnum +\tcode{T} may be an incomplete type. +It shall be complete before any member of the resulting specialization of +\tcode{rcu_obj_base} is referenced. + +\pnum +\tcode{D} shall be a +function object type\iref{function.objects} for which, +given a value \tcode{d} of type \tcode{D} and +a value \tcode{ptr} of type \tcode{T*}, +the expression \tcode{d(ptr)} is valid. + +\pnum +\tcode{D} shall meet the requirements for +\oldconcept{DefaultConstructible} and \oldconcept{MoveAssignable}. + +\pnum +If \tcode{D} is trivially copyable, +all specializations of \tcode{rcu_obj_base} are trivially copyable. + +\begin{itemdecl} +void retire(D d = D(), rcu_domain& dom = rcu_default_domain()) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\mandates +\tcode{T} is an rcu-protectable type. + +\pnum +\expects +\tcode{*this} is +a base class subobject of an object \tcode{x} of type \tcode{T}. +The member function \tcode{rcu_obj_base::retire} +was not invoked on \tcode{x} before. +The assignment to \exposid{deleter} does not exit via an exception. + +\pnum +\effects +Evaluates \tcode{\exposid{deleter} = std::move(d)} and +schedules the evaluation of +the expression \tcode{\exposid{deleter}(\newline addressof(x))} +in the domain \tcode{dom}; +the behavior is undefined if that evaluation exits via an exception. +May invoke scheduled evaluations in \tcode{dom}. + +\begin{note} +If such evaluations acquire resources held across any invocation of +\tcode{retire} on \tcode{dom}, deadlock can occur. +\end{note} +\end{itemdescr} + +\rSec3[saferecl.rcu.domain]{Class \tcode{rcu_domain}} + +\rSec4[saferecl.rcu.domain.general]{General} + +\pnum +This class meets the requirements of +\oldconcept{Lockable}\iref{thread.req.lockable.req} and +provides regions of RCU protection. + +\begin{example} +\begin{codeblock} +std::scoped_lock rlock(rcu_default_domain()); +\end{codeblock} +\end{example} + +\begin{codeblock} +class rcu_domain { +public: + rcu_domain(const rcu_domain&) = delete; + rcu_domain& operator=(const rcu_domain&) = delete; + + void lock() noexcept; + bool try_lock() noexcept; + void unlock() noexcept; +}; + +rcu_domain& rcu_default_domain() noexcept; +\end{codeblock} + +\pnum +The functions \tcode{lock} and \tcode{unlock} establish +(possibly nested) regions of RCU protection. + +\rSec4[saferecl.rcu.domain.members]{Member functions} + +\indexlibrarymember{lock}{rcu_domain}% +\begin{itemdecl} +void lock() noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Opens a region of RCU protection. + +\pnum +\remarks +Calls to \tcode{lock} +do not introduce a data race\iref{intro.races} involving \tcode{*this}. +\end{itemdescr} + +\indexlibrarymember{try_lock}{rcu_domain}% +\begin{itemdecl} +bool try_lock() noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Equivalent to \tcode{lock()}. + +\pnum +\returns +\tcode{true}. +\end{itemdescr} + +\indexlibrarymember{unlock}{rcu_domain}% +\begin{itemdecl} +void unlock() noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\expects +A call to \tcode{lock} +that opened an unclosed region of RCU protection +is sequenced before the call to \tcode{unlock}. + +\pnum +\effects +Closes the unclosed region of RCU protection +that was most recently opened. +May invoke scheduled evaluations in \tcode{*this}. + +\pnum +\begin{note} +If such evaluations acquire resources +held across any invocation of \tcode{unlock} on \tcode{*this}, +deadlock can occur. +\end{note} +Calls to \tcode{unlock} do not introduce a data race involving \tcode{*this}. +\begin{note} +Evaluation of scheduled evaluations can still cause a data race. +\end{note} +\end{itemdescr} + +\rSec4[saferecl.rcu.domain.func]{Non-member functions} + +\indexlibraryglobal{rcu_default_domain}% +\begin{itemdecl} +rcu_domain& rcu_default_domain() noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\returns +A reference to a static-duration object of type \tcode{rcu_domain}. +A reference to the same object is returned every time this function is called. +\end{itemdescr} + +\indexlibraryglobal{rcu_synchronize}% +\begin{itemdecl} +void rcu_synchronize(rcu_domain& dom = rcu_default_domain()) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +If the call to \tcode{rcu_synchronize} does not strongly happen before +the lock opening an RCU protection region \tcode{R} on \tcode{dom}, +blocks until the \tcode{unlock} closing \tcode{R} happens. + +\pnum +\sync +The \tcode{unlock} closing \tcode{R} +strongly happens before the return from \tcode{rcu_synchronize}. +\end{itemdescr} + +\indexlibraryglobal{rcu_barrier}% +\begin{itemdecl} +void rcu_barrier(rcu_domain& dom = rcu_default_domain()) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +May evaluate any scheduled evaluations in \tcode{dom}. +For any evaluation that happens before the call to \tcode{rcu_barrier} and +that schedules an evaluation $E$ in \tcode{dom}, +blocks until $E$ has been evaluated. + +\pnum +\sync +The evaluation of any such $E$ +strongly happens before the return from \tcode{rcu_barrier}. + +\begin{note} +A call to \tcode{rcu_barrier} does not imply +a call to \tcode{rcu_synchronize} and vice versa. +\end{note} +\end{itemdescr} + +\indexlibraryglobal{rcu_retire}% +\begin{itemdecl} +template> +void rcu_retire(T* p, D d = D(), rcu_domain& dom = rcu_default_domain()); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\mandates +\tcode{is_move_constructible_v} is \tcode{true} and +the expression \tcode{d(p)} is well-formed. + +\pnum +\expects +\tcode{D} meets the \oldconcept{MoveConstructible} and +\oldconcept{Destructible} requirements. + +\pnum +\effects +May allocate memory. +It is unspecified whether the memory allocation +is performed by invoking \tcode{\keyword{operator} \keyword{new}}. +Initializes an object \tcode{d1} of type \tcode{D} from \tcode{std::move(d)}. +Schedules the evaluation of \tcode{d1(p)} in the domain \tcode{dom}; +the behavior is undefined if that evaluation exits via an exception. +May invoke scheduled evaluations in \tcode{dom}. +\begin{note} +If \tcode{rcu_retire} exits via an exception, no evaluation +is scheduled. +\end{note} + +\pnum +\throws +\tcode{bad_alloc} or any exception thrown by the initialization of \tcode{d1}. + +\pnum +\begin{note} +If scheduled evaluations acquire resources +held across any invocation of \tcode{rcu_retire} on \tcode{dom}, +deadlock can occur. +\end{note} +\end{itemdescr} From 3608a50e381f85ae727c90752608e3789b6d969c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Tue, 18 Jul 2023 23:36:45 +0100 Subject: [PATCH 081/171] [saferecl.rcu.base] Fix description of "specialization" --- source/threads.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/threads.tex b/source/threads.tex index 2e28982f72..a4927308f5 100644 --- a/source/threads.tex +++ b/source/threads.tex @@ -11747,7 +11747,7 @@ \pnum Objects of type \tcode{T} to be protected by RCU inherit from -a specialization of \tcode{rcu_obj_base}. +a specialization \tcode{rcu_obj_base} for some \tcode{D}. \begin{codeblock} namespace std { From 8d787a2a2a62e4ebc818ec82d649240610630fa2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Thu, 20 Jul 2023 00:14:03 +0100 Subject: [PATCH 082/171] [saferecl.rcu.domain] Minor reogranization In [.general, move all paragraphs below the class synopsis, add "namespace std" to the class synopsis, and remove repeated declaration of "rcu_default_domain". Add a cross reference to [.func] to the header synopsis. --- source/threads.tex | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/source/threads.tex b/source/threads.tex index a4927308f5..b5d57ca302 100644 --- a/source/threads.tex +++ b/source/threads.tex @@ -11735,6 +11735,8 @@ // \ref{saferecl.rcu.domain}, class \tcode{rcu_domain} class rcu_domain; + + // \ref{saferecl.rcu.domain.func} non-member functions rcu_domain& rcu_default_domain() noexcept; void rcu_synchronize(rcu_domain& dom = rcu_default_domain()) noexcept; void rcu_barrier(rcu_domain& dom = rcu_default_domain()) noexcept; @@ -11828,31 +11830,30 @@ \rSec4[saferecl.rcu.domain.general]{General} +\begin{codeblock} +namespace std { + class rcu_domain { + public: + rcu_domain(const rcu_domain&) = delete; + rcu_domain& operator=(const rcu_domain&) = delete; + + void lock() noexcept; + bool try_lock() noexcept; + void unlock() noexcept; + }; +} +\end{codeblock} + \pnum This class meets the requirements of \oldconcept{Lockable}\iref{thread.req.lockable.req} and provides regions of RCU protection. - \begin{example} \begin{codeblock} std::scoped_lock rlock(rcu_default_domain()); \end{codeblock} \end{example} -\begin{codeblock} -class rcu_domain { -public: - rcu_domain(const rcu_domain&) = delete; - rcu_domain& operator=(const rcu_domain&) = delete; - - void lock() noexcept; - bool try_lock() noexcept; - void unlock() noexcept; -}; - -rcu_domain& rcu_default_domain() noexcept; -\end{codeblock} - \pnum The functions \tcode{lock} and \tcode{unlock} establish (possibly nested) regions of RCU protection. From 81111d6259affc21afc2b65d3a9e028cb9d80604 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Thu, 20 Jul 2023 00:22:53 +0100 Subject: [PATCH 083/171] [saferecl.rcu.domain.members] Add missing Remarks: element/paragraph --- source/threads.tex | 3 +++ 1 file changed, 3 insertions(+) diff --git a/source/threads.tex b/source/threads.tex index b5d57ca302..dad6e316ff 100644 --- a/source/threads.tex +++ b/source/threads.tex @@ -11915,6 +11915,9 @@ held across any invocation of \tcode{unlock} on \tcode{*this}, deadlock can occur. \end{note} + +\pnum +\remarks Calls to \tcode{unlock} do not introduce a data race involving \tcode{*this}. \begin{note} Evaluation of scheduled evaluations can still cause a data race. From 1f280466ecc7d622f11cc32994a68c559e3a2589 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Fri, 23 Jun 2023 08:44:52 +0200 Subject: [PATCH 084/171] P2530R3 Hazard Pointers for C++26 --- source/limits.tex | 2 + source/support.tex | 1 + source/threads.tex | 459 ++++++++++++++++++++++++++++++++++++++++++++- 3 files changed, 460 insertions(+), 2 deletions(-) diff --git a/source/limits.tex b/source/limits.tex index b3188315c4..60c9dc3b69 100644 --- a/source/limits.tex +++ b/source/limits.tex @@ -132,5 +132,7 @@ Handlers per try block\iref{except.handle} [256]. \item% Number of placeholders\iref{func.bind.place} [10]. +\item% +Number of hazard-protectable possibly-reclaimable objects\iref{saferecl.hp.general} [256]. \end{itemize} diff --git a/source/support.tex b/source/support.tex index 9fa6a3c561..d32d15f9b6 100644 --- a/source/support.tex +++ b/source/support.tex @@ -635,6 +635,7 @@ // also in \libheader{unordered_map}, \libheader{unordered_set} #define @\defnlibxname{cpp_lib_hardware_interference_size}@ 201703L // also in \libheader{new} #define @\defnlibxname{cpp_lib_has_unique_object_representations}@ 201606L // also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_hazard_pointer}@ 202306L // also in \libheader{hazard_pointer} #define @\defnlibxname{cpp_lib_hypot}@ 201603L // also in \libheader{cmath} #define @\defnlibxname{cpp_lib_incomplete_container_elements}@ 201505L // also in \libheader{forward_list}, \libheader{list}, \libheader{vector} diff --git a/source/threads.tex b/source/threads.tex index dad6e316ff..7f294c2a5c 100644 --- a/source/threads.tex +++ b/source/threads.tex @@ -19,9 +19,9 @@ \tcode{}, \tcode{} \\ \rowsep \ref{thread.condition}& Condition variables & \tcode{} \\ \rowsep \ref{thread.sema} & Semaphores & \tcode{} \\ \rowsep -\ref{thread.coord} & Coordination types & \tcode{} \tcode{} \\ \rowsep +\ref{thread.coord} & Coordination types & \tcode{}, \tcode{} \\ \rowsep \ref{futures} & Futures & \tcode{} \\ \rowsep -\ref{saferecl} & Safe reclamation & \tcode{} \\ +\ref{saferecl} & Safe reclamation & \tcode{}, \tcode{} \\ \end{libsumtab} \rSec1[thread.req]{Requirements} @@ -12022,3 +12022,458 @@ deadlock can occur. \end{note} \end{itemdescr} + +\rSec2[saferecl.hp]{Hazard pointers} + +\rSec3[saferecl.hp.general]{General} + +\pnum +\indextext{hazard pointer}% +A hazard pointer is a single-writer multi-reader pointer +that can be owned by at most one thread at any time. +Only the owner of the hazard pointer can set its value, +while any number of threads may read its value. +The owner thread sets the value of a hazard pointer to point to an object +in order to indicate to concurrent threads---which +may delete such an object---that +the object is not yet safe to delete. + +\pnum +A class type \tcode{T} is \defn{hazard-protectable} +if it has exactly one base class of type \tcode{hazard_pointer_obj_base} +for some \tcode{D}, +that base is public and non-virtual, and +it has no base classes of type \tcode{hazard_pointer_obj_base} +for any other combination \tcode{T2}, \tcode{D2}. +An object is \defn{hazard-protectable} if it is of hazard-protectable type. + +\pnum +The time span between creation and destruction of a hazard pointer $h$ +is partitioned into a series of \defnadjx{protection}{epochs}{epoch}; +in each protection epoch, +$h$ either is \defnx{associated with}{hazard pointer!associated} +a hazard-protectable object, or is \defnx{unassociated}{hazard pointer!unassociated}. +Upon creation, a hazard pointer is unassociated. +Changing the association (possibly to the same object) +initiates a new protection epoch and ends the preceding one. + +\pnum +An object \tcode{x} of hazard-protectable type \tcode{T} is +\defn{retired} with a deleter of type \tcode{D} +when the member function \tcode{hazard_pointer_obj_base::retire} +is invoked on \tcode{x}. +Any given object \tcode{x} shall be retired at most once. + +\pnum +A retired object \tcode{x} is \defn{reclaimed} +by invoking its deleter with a pointer to \tcode{x}; +the behavior is undefined if that invocation exits via an exception. + +\pnum +A hazard-protectable object \tcode{x} is \defn{possibly-reclaimable} +with respect to an evaluation $A$ if: +\begin{itemize} +\item +\tcode{x} is not reclaimed; and +\item +\tcode{x} is retired in an evaluation $R$ and +$A$ does not happen before $R$; and +\item +for all hazard pointers $h$ and for every protection epoch $E$ of $h$ +during which $h$ is associated with \tcode{x}: +\begin{itemize} +\item +if the beginning of $E$ happens before $R$, +the end of $E$ strongly happens before $A$; and +\item +if $E$ began by an evaluation of \tcode{try_protect} with argument \tcode{src}, +label its atomic load operation $L$. +If there exists an atomic modification $B$ on \tcode{src} +such that $L$ observes a modification that is modification-ordered before $B$, and +$B$ happens before \tcode{x} is retired, +the end of $E$ strongly happens before $A$. +\begin{note} +In typical use, a store to \tcode{src} sequenced before retiring \tcode{x} +will be such an atomic operation $B$. +\end{note} +\end{itemize} +\begin{note} +The latter two conditions convey the informal notion +that a protection epoch that began before retiring \tcode{x}, +as implied either by the happens-before relation or +the coherence order of some source, +delays the reclamation of \tcode{x}. +\end{note} +\end{itemize} + +\pnum +The number of possibly-reclaimable objects has an unspecified bound. +\begin{note} +The bound can be a function of the number of hazard pointers, +the number of threads that retire objects, and +the number of threads that use hazard pointers. +\end{note} +\begin{example} +The following example shows how hazard pointers allow updates to be carried out +in the presence of concurrent readers. +The object of type \tcode{hazard_pointer} in \tcode{print_name} +protects the object \tcode{*ptr} from being reclaimed by \tcode{ptr->retire} +until the end of the protection epoch. +\begin{codeblock} +struct Name : public hazard_pointer_obj_base { /* details */ }; +atomic name; +// called often and in parallel! +void print_name() { + hazard_pointer h = make_hazard_pointer(); + Name* ptr = h.protect(name); // Protection epoch starts + // ... safe to access \tcode{*ptr} +} // Protection epoch ends. + +// called rarely, but possibly concurrently with \tcode{print_name} +void update_name(Name* new_name) { + Name* ptr = name.exchange(new_name); + ptr->retire(); +} +\end{codeblock} +\end{example} + +\rSec3[hazard.pointer.syn]{Header \tcode{} synopsis} + +\indexheader{hazard_pointer}% +\begin{codeblock} +namespace std { + // \ref{saferecl.hp.base}, class template \tcode{hazard_pointer_obj_base} + template> class hazard_pointer_obj_base; + + // \ref{saferecl.hp.holder}, class \tcode{hazard_pointer} + class hazard_pointer; + + // \ref{saferecl.hp.holder.nonmem}, non-member functions + hazard_pointer make_hazard_pointer(); + void swap(hazard_pointer&, hazard_pointer&) noexcept; +} +\end{codeblock} + +\rSec3[saferecl.hp.base]{Class template \tcode{hazard_pointer_obj_base}} + +\begin{codeblock} +namespace std { + template> + class hazard_pointer_obj_base { + public: + void retire(D d = D()) noexcept; + protected: + hazard_pointer_obj_base() = default; + hazard_pointer_obj_base(const hazard_pointer_obj_base&) = default; + hazard_pointer_obj_base(hazard_pointer_obj_base&&) = default; + hazard_pointer_obj_base& operator=(const hazard_pointer_obj_base&) = default; + hazard_pointer_obj_base& operator=(hazard_pointer_obj_base&&) = default; + ~hazard_pointer_obj_base() = default; + private: + D @\exposid{deleter}@; // \expos + }; +} +\end{codeblock} + +\pnum +\tcode{D} shall be a function object type\iref{func.require} +for which, given a value \tcode{d} of type \tcode{D} and +a value \tcode{ptr} of type \tcode{T*}, +the expression \tcode{d(ptr)} is valid. + +\pnum +The behavior of a program +that adds specializations for \tcode{hazard_pointer_obj_base} is undefined. + +\pnum +\tcode{D} shall meet the requirements for +\oldconcept{DefaultConstructible} and \oldconcept{MoveAssignable}. + +\pnum +\tcode{T} may be an incomplete type. +It shall be complete before any member +of the resulting specialization of \tcode{hazard_pointer_obj_base} +is referenced. + +\indexlibrarymember{retire}{hazard_pointer_obj_base}% +\begin{itemdecl} +void retire(D d = D()) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\mandates +\tcode{T} is a hazard-protectable type. + +\pnum +\expects +\tcode{*this} is +a base class subobject of an object \tcode{x} of type \tcode{T}. +\tcode{x} is not retired. +Move-assigning \tcode{d} to \tcode{deleter} does not exit via an exception. + +\pnum +\effects +Move-assigns \tcode{d} to \tcode{deleter}, +thereby setting it as the deleter of \tcode{x}, +then retires \tcode{x}. +May reclaim possibly-reclaimable objects. +\end{itemdescr} + +\rSec3[saferecl.hp.holder]{Class \tcode{hazard_pointer}} + +\rSec4[saferecl.hp.holder.general]{General} + +\begin{codeblock} +namespace std { + class hazard_pointer { + public: + hazard_pointer() noexcept; + hazard_pointer(hazard_pointer&&) noexcept; + hazard_pointer& operator=(hazard_pointer&&) noexcept; + ~hazard_pointer(); + + [[nodiscard]] bool empty() const noexcept; + template T* protect(const atomic& src) noexcept; + template bool try_protect(T*& ptr, const atomic& src) noexcept; + template void reset_protection(const T* ptr) noexcept; + void reset_protection(nullptr_t = nullptr) noexcept; + void swap(hazard_pointer&) noexcept; + }; +} +\end{codeblock} + +\pnum +An object of type \tcode{hazard_pointer} is either empty or +\defnx{owns}{owning!hazard pointer} a hazard pointer. +Each hazard pointer is owned by +exactly one object of type \tcode{hazard_pointer}. +\begin{note} +An empty \tcode{hazard_pointer} object is different from +a \tcode{hazard_pointer} object +that owns an unassociated hazard pointer. +An empty \tcode{hazard_pointer} object does not own any hazard pointers. +\end{note} + +\rSec4[saferecl.hp.holder.ctor]{Constructors, destructor, and assignment} + +\indexlibraryctor{hazard_pointer}% +\begin{itemdecl} +hazard_pointer() noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\ensures +\tcode{*this} is empty. +\end{itemdescr} + +\indexlibraryctor{hazard_pointer}% +\begin{itemdecl} +hazard_pointer(hazard_pointer&& other) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\ensures +If \tcode{other} is empty, \tcode{*this} is empty. +Otherwise, +\tcode{*this} owns the hazard pointer originally owned by \tcode{other}; +\tcode{other} is empty. +\end{itemdescr} + +\indexlibrarydtor{hazard_pointer}% +\begin{itemdecl} +~hazard_pointer(); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +If \tcode{*this} is not empty, +destroys the hazard pointer owned by \tcode{*this}, +thereby ending its current protection epoch. +\end{itemdescr} + +\indexlibrarymember{operator=}{hazard_pointer}% +\begin{itemdecl} +hazard_pointer& operator=(hazard_pointer&& other) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +If \tcode{this == \&other} is \tcode{true}, no effect. +Otherwise, if \tcode{*this} is not empty, +destroys the hazard pointer owned by \tcode{*this}, +thereby ending its current protection epoch. + +\pnum +\ensures +If \tcode{other} was empty, \tcode{*this} is empty. +Otherwise, \tcode{*this} owns the hazard pointer originally +owned by \tcode{other}. +If \tcode{this != \&other} is \tcode{true}, \tcode{other} is empty. + +\pnum +\returns +\tcode{*this}. +\end{itemdescr} + +\rSec4[saferecl.hp.holder.mem]{Member functions} + +\indexlibrarymember{empty}{hazard_pointer}% +\begin{itemdecl} +[[nodiscard]] bool empty() const noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\returns +\tcode{true} if and only if \tcode{*this} is empty. +\end{itemdescr} + +\indexlibrarymember{protect}{hazard_pointer}% +\begin{itemdecl} +template T* protect(const atomic& src) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Equivalent to: +\begin{codeblock} +T* ptr = src.load(memory_order::relaxed); +while (!try_protect(ptr, src)) {} +return ptr; +\end{codeblock} +\end{itemdescr} + +\indexlibrarymember{try_protect}{hazard_pointer}% +\begin{itemdecl} +template bool try_protect(T*& ptr, const atomic& src) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\mandates +\tcode{T} is a hazard-protectable type. + +\pnum +\expects +\tcode{*this} is not empty. + +\pnum +\effects +Performs the following steps in order: +\begin{itemize} +\item Initializes a variable \tcode{old} of type \tcode{T*} with the value of \tcode{ptr}. +\item Evaluates \tcode{reset_protection(old)}. +\item Assigns the value of \tcode{src.load(memory_order::acquire)} to \tcode{ptr}. +\item If \tcode{old == ptr} is \tcode{false}, +evaluates \tcode{reset_protection()}. +\end{itemize} + +\pnum +\returns +\tcode{old == ptr}. +\end{itemdescr} + +\indexlibrarymember{reset_protection}{hazard_pointer}% +\begin{itemdecl} +template void reset_protection(const T* ptr) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\mandates +\tcode{T} is a hazard-protectable type. + +\pnum +\expects +\tcode{*this} is not empty. + +\pnum +\effects +If \tcode{ptr} is a null pointer value, invokes \tcode{reset_protection()}. +Otherwise, +associates the hazard pointer owned by \tcode{*this} with \tcode{*ptr}, +thereby ending the current protection epoch. + +\pnum +\complexity +Constant. +\end{itemdescr} + +\indexlibrarymember{reset_protection}{hazard_pointer}% +\begin{itemdecl} +void reset_protection(nullptr_t = nullptr) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\expects +\tcode{*this} is not empty. + +\pnum +\ensures +The hazard pointer owned by \tcode{*this} is unassociated. + +\pnum +\complexity +Constant. +\end{itemdescr} + +\indexlibrarymember{swap}{hazard_pointer}% +\begin{itemdecl} +void swap(hazard_pointer& other) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Swaps the hazard pointer ownership of this object with that of \tcode{other}. +\begin{note} +The owned hazard pointers, if any, remain unchanged during the swap and +continue to be associated with the respective objects +that they were protecting before the swap, if any. +No protection epochs are ended or initiated. +\end{note} + +\pnum +\complexity +Constant. +\end{itemdescr} + +\rSec4[saferecl.hp.holder.nonmem]{Non-member functions} + +\indexlibraryglobal{make_hazard_pointer}% +\begin{itemdecl} +hazard_pointer make_hazard_pointer(); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Constructs a hazard pointer. + +\pnum +\returns +A \tcode{hazard_pointer} object that owns the newly-constructed hazard pointer. + +\pnum +\throws +May throw \tcode{bad_alloc} +if memory for the hazard pointer could not be allocated. +\end{itemdescr} + +\indexlibrarymember{swap}{hazard_pointer}% +\begin{itemdecl} +void swap(hazard_pointer& a, hazard_pointer& b) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Equivalent to \tcode{a.swap(b)}. +\end{itemdescr} From 1a805a7f89eb765ea4e3a2d0c6f8e939a3cce464 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Fri, 23 Jun 2023 23:38:51 +0200 Subject: [PATCH 085/171] P2538R1 ADL-proof std::projected --- source/iterators.tex | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/source/iterators.tex b/source/iterators.tex index 0a3eb7dd14..21f233d8be 100644 --- a/source/iterators.tex +++ b/source/iterators.tex @@ -2512,16 +2512,18 @@ \indexlibraryglobal{projected}% \begin{codeblock} namespace std { - template<@\libconcept{indirectly_readable}@ I, @\libconcept{indirectly_regular_unary_invocable}@ Proj> - struct projected { - using value_type = remove_cvref_t>; - indirect_result_t operator*() const; // \notdef + template + struct @\exposidnc{projected-impl}@ { // \expos + struct @\exposidnc{type}@ { // \expos + using value_type = remove_cvref_t>; + using difference_type = iter_difference_t; // present only if \tcode{I} + // models \libconcept{weakly_incrementable} + indirect_result_t operator*() const; // \notdef + }; }; - template<@\libconcept{weakly_incrementable}@ I, class Proj> - struct incrementable_traits> { - using difference_type = iter_difference_t; - }; + template<@\libconcept{indirectly_readable}@ I, @\libconcept{indirectly_regular_unary_invocable}@ Proj> + using projected = @\exposid{projected-impl}@::@\exposid{type}@; } \end{codeblock} From 57f069a213659f5befaa4a9d88f482a16434716a Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Sat, 24 Jun 2023 22:40:06 +0200 Subject: [PATCH 086/171] P2495R3 Interfacing stringstreams with string_view --- source/iostreams.tex | 224 +++++++++++++++++++++++++++++++++++++++++++ source/support.tex | 1 + 2 files changed, 225 insertions(+) diff --git a/source/iostreams.tex b/source/iostreams.tex index bf9dbe8f30..2447cadecc 100644 --- a/source/iostreams.tex +++ b/source/iostreams.tex @@ -7952,6 +7952,13 @@ explicit basic_stringbuf( const basic_string& s, ios_base::openmode which = ios_base::in | ios_base::out); + template + explicit basic_stringbuf(const T& t, + ios_base::openmode which = ios_base::in | ios_base::out); + template + basic_stringbuf(const T& t, const Allocator& a); + template + basic_stringbuf(const T& t, ios_base::openmode which, const Allocator& a); basic_stringbuf(const basic_stringbuf&) = delete; basic_stringbuf(basic_stringbuf&& rhs); basic_stringbuf(basic_stringbuf&& rhs, const Allocator& a); @@ -7974,6 +7981,8 @@ template void str(const basic_string& s); void str(basic_string&& s); + template + void str(const T& t); protected: // \ref{stringbuf.virtuals}, overridden virtual functions @@ -8142,6 +8151,37 @@ then calls \tcode{init_buf_ptrs()}. \end{itemdescr} +\indexlibraryctor{basic_stringbuf}% +\begin{itemdecl} +template + explicit basic_stringbuf(const T& t, ios_base::openmode which = ios_base::in | ios_base::out); +template + basic_stringbuf(const T& t, const Allocator& a); +template + basic_stringbuf(const T& t, ios_base::openmode which, const Allocator& a); +\end{itemdecl} + +\begin{itemdescr} +\pnum +Let \tcode{which} be \tcode{ios_base::in | ios_base::out} +for the overload with no parameter \tcode{which}, and +\tcode{a} be \tcode{Allocator()} for the overload with no parameter \tcode{a}. + +\pnum +\constraints +\tcode{is_convertible_v>} +is \tcode{true}. + +\pnum +\effects +Creates a variable \tcode{sv} as if by +\tcode{basic_string_view sv = t}, +then value-initializes the base class, +initializes \tcode{mode} with \tcode{which}, and +direct-non-list-initializes \tcode{buf} with \tcode{sv, a}, +then calls \tcode{init_buf_ptrs()}. +\end{itemdescr} + \indexlibraryctor{basic_stringbuf}% \begin{itemdecl} basic_stringbuf(basic_stringbuf&& rhs); @@ -8444,6 +8484,28 @@ \end{codeblock} \end{itemdescr} +\indexlibrarymember{str}{basic_stringbuf}% +\begin{itemdecl} +template + void str(const T& t); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +\tcode{is_convertible_v>} +is \tcode{true}. + +\pnum +\effects +Equivalent to: +\begin{codeblock} +basic_string_view sv = t; +buf = sv; +init_buf_ptrs(); +\end{codeblock} +\end{itemdescr} + \rSec3[stringbuf.virtuals]{Overridden virtual functions} \indexlibrarymember{underflow}{basic_stringbuf}% @@ -8749,6 +8811,12 @@ explicit basic_istringstream( const basic_string& s, ios_base::openmode which = ios_base::in); + template + explicit basic_istringstream(const T& t, ios_base::openmode which = ios_base::in); + template + basic_istringstream(const T& t, const Allocator& a); + template + basic_istringstream(const T& t, ios_base::openmode which, const Allocator& a); basic_istringstream(const basic_istringstream&) = delete; basic_istringstream(basic_istringstream&& rhs); @@ -8770,6 +8838,8 @@ template void str(const basic_string& s); void str(basic_string&& s); + template + void str(const T& t); private: basic_stringbuf sb; // \expos @@ -8879,6 +8949,10 @@ \end{itemdecl} \begin{itemdescr} +\pnum +\constraints +\tcode{is_same_v} is \tcode{false}. + \pnum \effects Initializes the base class with @@ -8887,6 +8961,33 @@ \tcode{basic_stringbuf(s, which | ios_base::in)}\iref{stringbuf.cons}. \end{itemdescr} +\indexlibraryctor{basic_istringstream}% +\begin{itemdecl} +template + explicit basic_istringstream(const T& t, ios_base::openmode which = ios_base::in); +template + basic_istringstream(const T& t, const Allocator& a); +template + basic_istringstream(const T& t, ios_base::openmode which, const Allocator& a); +\end{itemdecl} + +\begin{itemdescr} +\pnum +Let \tcode{which} be \tcode{ios_base::in} +for the overload with no parameter \tcode{which}, and +\tcode{a} be \tcode{Allocator()} for the overload with no parameter \tcode{a}. + +\pnum +\constraints +\tcode{is_convertible_v>} +is \tcode{true}. + +\pnum +\effects +Initializes the base class with \tcode{addressof(sb)}, and +direct-non-list-initializes \tcode{sb} with \tcode{t, which | ios_base::in, a}. +\end{itemdescr} + \indexlibraryctor{basic_istringstream}% \begin{itemdecl} basic_istringstream(basic_istringstream&& rhs); @@ -9018,12 +9119,30 @@ \begin{itemdecl} void str(basic_string&& s); \end{itemdecl} + \begin{itemdescr} \pnum \effects Equivalent to: \tcode{rdbuf()->str(std::move(s));} \end{itemdescr} +\indexlibrarymember{str}{basic_istringstream}% +\begin{itemdecl} +template + void str(const T& t); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +\tcode{is_convertible_v>} +is \tcode{true}. + +\pnum +\effects +Equivalent to: \tcode{rdbuf()->str(t);} +\end{itemdescr} + \rSec2[ostringstream]{Class template \tcode{basic_ostringstream}} \rSec3[ostringstream.general]{General} @@ -9064,6 +9183,12 @@ explicit basic_ostringstream( const basic_string& s, ios_base::openmode which = ios_base::out); + template + explicit basic_ostringstream(const T& t, ios_base::openmode which = ios_base::out); + template + basic_ostringstream(const T& t, const Allocator& a); + template + basic_ostringstream(const T& t, ios_base::openmode which, const Allocator& a); basic_ostringstream(const basic_ostringstream&) = delete; basic_ostringstream(basic_ostringstream&& rhs); @@ -9086,6 +9211,8 @@ template void str(const basic_string& s); void str(basic_string&& s); + template + void str(const T& t); private: basic_stringbuf sb; // \expos @@ -9207,6 +9334,33 @@ \tcode{basic_stringbuf(s, which | ios_base::out)}\linebreak\iref{stringbuf.cons}. % avoid Overfull \end{itemdescr} +\indexlibraryctor{basic_ostringstream}% +\begin{itemdecl} +template + explicit basic_ostringstream(const T& t, ios_base::openmode which = ios_base::out); +template + basic_ostringstream(const T& t, const Allocator& a); +template + basic_ostringstream(const T& t, ios_base::openmode which, const Allocator& a); +\end{itemdecl} + +\begin{itemdescr} +\pnum +Let \tcode{which} be \tcode{ios_base::out} +for the overload with no parameter \tcode{which}, and +\tcode{a} be \tcode{Allocator()} for the overload with no parameter \tcode{a}. + +\pnum +\constraints +\tcode{is_convertible_v>} +is \tcode{true}. + +\pnum +\effects +Initializes the base class with \tcode{addressof(sb)}, and +direct-non-list-initializes \tcode{sb} with \tcode{t, which | ios_base::out, a}. +\end{itemdescr} + \indexlibraryctor{basic_ostringstream}% \begin{itemdecl} basic_ostringstream(basic_ostringstream&& rhs); @@ -9344,6 +9498,23 @@ Equivalent to: \tcode{rdbuf()->str(std::move(s));} \end{itemdescr} +\indexlibrarymember{str}{basic_ostringstream}% +\begin{itemdecl} +template + void str(const T& t); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +\tcode{is_convertible_v>} +is \tcode{true}. + +\pnum +\effects +Equivalent to: \tcode{rdbuf()->str(t);} +\end{itemdescr} + \rSec2[stringstream]{Class template \tcode{basic_stringstream}} \rSec3[stringstream.general]{General} @@ -9384,6 +9555,13 @@ explicit basic_stringstream( const basic_string& s, ios_base::openmode which = ios_base::out | ios_base::in); + template + explicit basic_stringstream(const T& t, + ios_base::openmode which = ios_base::out | ios_base::in); + template + basic_stringstream(const T& t, const Allocator& a); + template + basic_stringstream(const T& t, ios_base::openmode which, const Allocator& a); basic_stringstream(const basic_stringstream&) = delete; basic_stringstream(basic_stringstream&& rhs); @@ -9406,6 +9584,8 @@ template void str(const basic_string& s); void str(basic_string&& s); + template + void str(const T& t); private: basic_stringbuf sb; // \expos @@ -9532,6 +9712,33 @@ \tcode{basic_stringbuf(s, which)}\iref{stringbuf.cons}. \end{itemdescr} +\indexlibraryctor{basic_stringstream}% +\begin{itemdecl} +template + explicit basic_stringstream(const T& t, ios_base::openmode which = ios_base::out | ios_base::in); +template + basic_stringstream(const T& t, const Allocator& a); +template + basic_stringstream(const T& t, ios_base::openmode which, const Allocator& a); +\end{itemdecl} + +\begin{itemdescr} +\pnum +Let \tcode{which} be \tcode{ios_base::out | ios_base::in} +for the overload with no parameter \tcode{which}, and +\tcode{a} be \tcode{Allocator()} for the overload with no parameter \tcode{a}. + +\pnum +\constraints +\tcode{is_convertible_v>} +is \tcode{true}. + +\pnum +\effects +Initializes the base class with \tcode{addressof(sb)}, and +direct-non-list-initializes \tcode{sb} with \tcode{t, which, a}. +\end{itemdescr} + \indexlibraryctor{basic_stringstream}% \begin{itemdecl} basic_stringstream(basic_stringstream&& rhs); @@ -9669,6 +9876,23 @@ Equivalent to: \tcode{rdbuf()->str(std::move(s));} \end{itemdescr} +\indexlibrarymember{str}{basic_stringstream}% +\begin{itemdecl} +template + void str(const T&); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +\tcode{is_convertible_v>} +is \tcode{true}. + +\pnum +\effects +Equivalent to: \tcode{rdbuf()->str(t);} +\end{itemdescr} + \rSec1[span.streams]{Span-based streams} \rSec2[span.streams.overview]{Overview} diff --git a/source/support.tex b/source/support.tex index d32d15f9b6..455ae22e5c 100644 --- a/source/support.tex +++ b/source/support.tex @@ -725,6 +725,7 @@ #define @\defnlibxname{cpp_lib_span}@ 202002L // also in \libheader{span} #define @\defnlibxname{cpp_lib_spanstream}@ 202106L // also in \libheader{spanstream} #define @\defnlibxname{cpp_lib_ssize}@ 201902L // also in \libheader{iterator} +#define @\defnlibxname{cpp_lib_sstream_from_string_view}@ 202306L // also in \libheader{sstream} #define @\defnlibxname{cpp_lib_stacktrace}@ 202011L // also in \libheader{stacktrace} #define @\defnlibxname{cpp_lib_start_lifetime_as}@ 202207L // also in \libheader{memory} #define @\defnlibxname{cpp_lib_starts_ends_with}@ 201711L // also in \libheader{string}, \libheader{string_view} From 0e87bd97aa2cc987732280279d5b1bab7d81e0ee Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Mon, 26 Jun 2023 14:29:19 +0200 Subject: [PATCH 087/171] P2510R3 Formatting pointers --- source/support.tex | 2 +- source/utilities.tex | 9 +++++++-- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/source/support.tex b/source/support.tex index 455ae22e5c..af234fee20 100644 --- a/source/support.tex +++ b/source/support.tex @@ -624,7 +624,7 @@ #define @\defnlibxname{cpp_lib_filesystem}@ 201703L // also in \libheader{filesystem} #define @\defnlibxname{cpp_lib_flat_map}@ 202207L // also in \libheader{flat_map} #define @\defnlibxname{cpp_lib_flat_set}@ 202207L // also in \libheader{flat_set} -#define @\defnlibxname{cpp_lib_format}@ 202207L // also in \libheader{format} +#define @\defnlibxname{cpp_lib_format}@ 202304L // also in \libheader{format} #define @\defnlibxname{cpp_lib_format_ranges}@ 202207L // also in \libheader{format} #define @\defnlibxname{cpp_lib_formatters}@ 202302L // also in \libheader{stacktrace}, \libheader{thread} #define @\defnlibxname{cpp_lib_forward_like}@ 202207L // also in \libheader{utility} diff --git a/source/utilities.tex b/source/utilities.tex index 02efe320ba..942af1431c 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -14866,7 +14866,7 @@ \begin{ncbnf} \fmtnontermdef{type} \textnormal{one of}\br - \terminal{a A b B c d e E f F g G o p s x X ?} + \terminal{a A b B c d e E f F g G o p P s x X ?} \end{ncbnf} \pnum @@ -15048,7 +15048,7 @@ \pnum The \tcode{0} option is valid for arithmetic types -other than \tcode{charT} and \tcode{bool} or +other than \tcode{charT} and \tcode{bool}, pointer types, or when an integer presentation type is specified. For formatting arguments that have a value other than an infinity or a NaN, @@ -15408,6 +15408,11 @@ \end{codeblock} with the prefix \tcode{0x} inserted immediately before the output of \tcode{to_chars}; otherwise, implementation-defined. +\\ \rowsep +\tcode{P} & +The same as \tcode{p}, +except that it uses uppercase letters for digits above \tcode{9} and +the base prefix is \tcode{0X}. \\ \end{floattable} From 0663ecb80f9b6e8e3804fe51b80c505b5b7bae0a Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Mon, 26 Jun 2023 20:50:49 +0200 Subject: [PATCH 088/171] P2198R7 Freestanding Feature-Test Macros and Implementation-Defined Extensions --- source/lib-intro.tex | 27 ++++++ source/support.tex | 204 ++++++++++++++++++++++++------------------- 2 files changed, 142 insertions(+), 89 deletions(-) diff --git a/source/lib-intro.tex b/source/lib-intro.tex index 27004e1e41..cd158b5a0e 100644 --- a/source/lib-intro.tex +++ b/source/lib-intro.tex @@ -1470,6 +1470,33 @@ For each of the headers listed in \tref{headers.cpp.fs}, a freestanding implementation provides at least the freestanding items\iref{freestanding.item} declared in the header. + +\pnum +The \defnadj{hosted}{library facilities} are +the set of facilities described in this document +that are required for hosted implementations, +but not required for freestanding implementations. +A freestanding implementation provides +a (possibly empty) implementation-defined subset of +the hosted library facilities. +Unless otherwise specified, the requirements on +each declaration, entity, \grammarterm{typedef-name}, and macro +provided in this way are the same as +the corresponding requirements for a hosted implementation, +except that not all of the members of the namespaces are required to be present. + +\pnum +A freestanding implementation provides +deleted definitions\iref{dcl.fct.def.delete} for +a (possibly empty) implementation-defined subset of +the namespace-scope functions and function templates +from the hosted library facilities. +\begin{note} +An implementation may provide a deleted definition +so that the result of overload resolution does not silently change +when migrating a program from a freestanding implementation to +a hosted implementation. +\end{note} \indextext{implementation!freestanding|)}% \rSec2[using]{Using the library} diff --git a/source/support.tex b/source/support.tex index af234fee20..24d186bdd8 100644 --- a/source/support.tex +++ b/source/support.tex @@ -550,75 +550,77 @@ \end{note} \begin{codeblock} -#define @\defnlibxname{cpp_lib_addressof_constexpr}@ 201603L // also in \libheader{memory} +#define @\defnlibxname{cpp_lib_addressof_constexpr}@ 201603L // freestanding, also in \libheader{memory} #define @\defnlibxname{cpp_lib_algorithm_iterator_requirements}@ 202207L // also in \libheader{algorithm}, \libheader{numeric}, \libheader{memory} #define @\defnlibxname{cpp_lib_allocate_at_least}@ 202302L // also in \libheader{memory} #define @\defnlibxname{cpp_lib_allocator_traits_is_always_equal}@ 201411L - // also in \libheader{memory}, \libheader{scoped_allocator}, \libheader{string}, \libheader{deque}, \libheader{forward_list}, \libheader{list}, \libheader{vector}, - // \libheader{map}, \libheader{set}, \libheader{unordered_map}, \libheader{unordered_set} + // freestanding, also in \libheader{memory}, \libheader{scoped_allocator}, \libheader{string}, \libheader{deque}, \libheader{forward_list}, \libheader{list}, + // \libheader{vector}, \libheader{map}, \libheader{set}, \libheader{unordered_map}, \libheader{unordered_set} #define @\defnlibxname{cpp_lib_adaptor_iterator_pair_constructor}@ 202106L // also in \libheader{stack}, \libheader{queue} #define @\defnlibxname{cpp_lib_any}@ 201606L // also in \libheader{any} -#define @\defnlibxname{cpp_lib_apply}@ 201603L // also in \libheader{tuple} +#define @\defnlibxname{cpp_lib_apply}@ 201603L // freestanding, also in \libheader{tuple} #define @\defnlibxname{cpp_lib_array_constexpr}@ 201811L // also in \libheader{iterator}, \libheader{array} -#define @\defnlibxname{cpp_lib_as_const}@ 201510L // also in \libheader{utility} +#define @\defnlibxname{cpp_lib_as_const}@ 201510L // freestanding, also in \libheader{utility} #define @\defnlibxname{cpp_lib_associative_heterogeneous_erasure}@ 202110L // also in \libheader{map}, \libheader{set}, \libheader{unordered_map}, \libheader{unordered_set} -#define @\defnlibxname{cpp_lib_assume_aligned}@ 201811L // also in \libheader{memory} -#define @\defnlibxname{cpp_lib_atomic_flag_test}@ 201907L // also in \libheader{atomic} -#define @\defnlibxname{cpp_lib_atomic_float}@ 201711L // also in \libheader{atomic} -#define @\defnlibxname{cpp_lib_atomic_is_always_lock_free}@ 201603L // also in \libheader{atomic} +#define @\defnlibxname{cpp_lib_assume_aligned}@ 201811L // freestanding, also in \libheader{memory} +#define @\defnlibxname{cpp_lib_atomic_flag_test}@ 201907L // freestanding, also in \libheader{atomic} +#define @\defnlibxname{cpp_lib_atomic_float}@ 201711L // freestanding, also in \libheader{atomic} +#define @\defnlibxname{cpp_lib_atomic_is_always_lock_free}@ 201603L // freestanding, also in \libheader{atomic} #define @\defnlibxname{cpp_lib_atomic_lock_free_type_aliases}@ 201907L // also in \libheader{atomic} -#define @\defnlibxname{cpp_lib_atomic_ref}@ 201806L // also in \libheader{atomic} +#define @\defnlibxname{cpp_lib_atomic_ref}@ 201806L // freestanding, also in \libheader{atomic} #define @\defnlibxname{cpp_lib_atomic_shared_ptr}@ 201711L // also in \libheader{memory} -#define @\defnlibxname{cpp_lib_atomic_value_initialization}@ 201911L // also in \libheader{atomic}, \libheader{memory} -#define @\defnlibxname{cpp_lib_atomic_wait}@ 201907L // also in \libheader{atomic} +#define @\defnlibxname{cpp_lib_atomic_value_initialization}@ 201911L // freestanding, also in \libheader{atomic}, \libheader{memory} +#define @\defnlibxname{cpp_lib_atomic_wait}@ 201907L // freestanding, also in \libheader{atomic} #define @\defnlibxname{cpp_lib_barrier}@ 202302L // also in \libheader{barrier} -#define @\defnlibxname{cpp_lib_bind_back}@ 202202L // also in \libheader{functional} -#define @\defnlibxname{cpp_lib_bind_front}@ 201907L // also in \libheader{functional} -#define @\defnlibxname{cpp_lib_bit_cast}@ 201806L // also in \libheader{bit} -#define @\defnlibxname{cpp_lib_bitops}@ 201907L // also in \libheader{bit} -#define @\defnlibxname{cpp_lib_bool_constant}@ 201505L // also in \libheader{type_traits} -#define @\defnlibxname{cpp_lib_bounded_array_traits}@ 201902L // also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_bind_back}@ 202202L // freestanding, also in \libheader{functional} +#define @\defnlibxname{cpp_lib_bind_front}@ 201907L // freestanding, also in \libheader{functional} +#define @\defnlibxname{cpp_lib_bit_cast}@ 201806L // freestanding, also in \libheader{bit} +#define @\defnlibxname{cpp_lib_bitops}@ 201907L // freestanding, also in \libheader{bit} +#define @\defnlibxname{cpp_lib_bool_constant}@ 201505L // freestanding, also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_bounded_array_traits}@ 201902L // freestanding, also in \libheader{type_traits} #define @\defnlibxname{cpp_lib_boyer_moore_searcher}@ 201603L // also in \libheader{functional} -#define @\defnlibxname{cpp_lib_byte}@ 201603L // also in \libheader{cstddef} -#define @\defnlibxname{cpp_lib_byteswap}@ 202110L // also in \libheader{bit} +#define @\defnlibxname{cpp_lib_byte}@ 201603L // freestanding, also in \libheader{cstddef} +#define @\defnlibxname{cpp_lib_byteswap}@ 202110L // freestanding, also in \libheader{bit} #define @\defnlibxname{cpp_lib_char8_t}@ 201907L - // also in \libheader{atomic}, \libheader{filesystem}, \libheader{istream}, \libheader{limits}, \libheader{locale}, \libheader{ostream}, \libheader{string}, \libheader{string_view} + // freestanding, also in \libheader{atomic}, \libheader{filesystem}, \libheader{istream}, \libheader{limits}, \libheader{locale}, \libheader{ostream}, \libheader{string}, + // \libheader{string_view} #define @\defnlibxname{cpp_lib_chrono}@ 202306L // also in \libheader{chrono} #define @\defnlibxname{cpp_lib_chrono_udls}@ 201304L // also in \libheader{chrono} #define @\defnlibxname{cpp_lib_clamp}@ 201603L // also in \libheader{algorithm} #define @\defnlibxname{cpp_lib_common_reference}@ 202302L // also in \libheader{type_traits} #define @\defnlibxname{cpp_lib_common_reference_wrapper}@ 202302L // also in \libheader{functional} #define @\defnlibxname{cpp_lib_complex_udls}@ 201309L // also in \libheader{complex} -#define @\defnlibxname{cpp_lib_concepts}@ 202207L // also in \libheader{concepts}, \libheader{compare} +#define @\defnlibxname{cpp_lib_concepts}@ 202207L + // freestanding, also in \libheader{concepts}, \libheader{compare} #define @\defnlibxname{cpp_lib_constexpr_algorithms}@ 202306L // also in \libheader{algorithm}, \libheader{utility} #define @\defnlibxname{cpp_lib_constexpr_bitset}@ 202207L // also in \libheader{bitset} #define @\defnlibxname{cpp_lib_constexpr_charconv}@ 202207L // also in \libheader{charconv} #define @\defnlibxname{cpp_lib_constexpr_cmath}@ 202202L // also in \libheader{cmath}, \libheader{cstdlib} #define @\defnlibxname{cpp_lib_constexpr_complex}@ 201711L // also in \libheader{complex} #define @\defnlibxname{cpp_lib_constexpr_dynamic_alloc}@ 201907L // also in \libheader{memory} -#define @\defnlibxname{cpp_lib_constexpr_functional}@ 201907L // also in \libheader{functional} -#define @\defnlibxname{cpp_lib_constexpr_iterator}@ 201811L // also in \libheader{iterator} -#define @\defnlibxname{cpp_lib_constexpr_memory}@ 202202L // also in \libheader{memory} +#define @\defnlibxname{cpp_lib_constexpr_functional}@ 201907L // freestanding, also in \libheader{functional} +#define @\defnlibxname{cpp_lib_constexpr_iterator}@ 201811L // freestanding, also in \libheader{iterator} +#define @\defnlibxname{cpp_lib_constexpr_memory}@ 202202L // freestanding, also in \libheader{memory} #define @\defnlibxname{cpp_lib_constexpr_numeric}@ 201911L // also in \libheader{numeric} #define @\defnlibxname{cpp_lib_constexpr_string}@ 201907L // also in \libheader{string} #define @\defnlibxname{cpp_lib_constexpr_string_view}@ 201811L // also in \libheader{string_view} -#define @\defnlibxname{cpp_lib_constexpr_tuple}@ 201811L // also in \libheader{tuple} -#define @\defnlibxname{cpp_lib_constexpr_typeinfo}@ 202106L // also in \libheader{typeinfo} -#define @\defnlibxname{cpp_lib_constexpr_utility}@ 201811L // also in \libheader{utility} +#define @\defnlibxname{cpp_lib_constexpr_tuple}@ 201811L // freestanding, also in \libheader{tuple} +#define @\defnlibxname{cpp_lib_constexpr_typeinfo}@ 202106L // freestanding, also in \libheader{typeinfo} +#define @\defnlibxname{cpp_lib_constexpr_utility}@ 201811L // freestanding, also in \libheader{utility} #define @\defnlibxname{cpp_lib_constexpr_vector}@ 201907L // also in \libheader{vector} #define @\defnlibxname{cpp_lib_containers_ranges}@ 202202L // also in \libheader{vector}, \libheader{list}, \libheader{forward_list}, \libheader{map}, \libheader{set}, \libheader{unordered_map}, \libheader{unordered_set}, // \libheader{deque}, \libheader{queue}, \libheader{stack}, \libheader{string} #define @\defnlibxname{cpp_lib_coroutine}@ 201902L // also in \libheader{coroutine} -#define @\defnlibxname{cpp_lib_destroying_delete}@ 201806L // also in \libheader{new} +#define @\defnlibxname{cpp_lib_destroying_delete}@ 201806L // freestanding, also in \libheader{new} #define @\defnlibxname{cpp_lib_enable_shared_from_this}@ 201603L // also in \libheader{memory} -#define @\defnlibxname{cpp_lib_endian}@ 201907L // also in \libheader{bit} +#define @\defnlibxname{cpp_lib_endian}@ 201907L // freestanding, also in \libheader{bit} #define @\defnlibxname{cpp_lib_erase_if}@ 202002L // also in \libheader{string}, \libheader{deque}, \libheader{forward_list}, \libheader{list}, \libheader{vector}, \libheader{map}, \libheader{set}, \libheader{unordered_map}, // \libheader{unordered_set} -#define @\defnlibxname{cpp_lib_exchange_function}@ 201304L // also in \libheader{utility} +#define @\defnlibxname{cpp_lib_exchange_function}@ 201304L // freestanding, also in \libheader{utility} #define @\defnlibxname{cpp_lib_execution}@ 201902L // also in \libheader{execution} #define @\defnlibxname{cpp_lib_expected}@ 202211L // also in \libheader{expected} #define @\defnlibxname{cpp_lib_filesystem}@ 201703L // also in \libheader{filesystem} @@ -627,60 +629,69 @@ #define @\defnlibxname{cpp_lib_format}@ 202304L // also in \libheader{format} #define @\defnlibxname{cpp_lib_format_ranges}@ 202207L // also in \libheader{format} #define @\defnlibxname{cpp_lib_formatters}@ 202302L // also in \libheader{stacktrace}, \libheader{thread} -#define @\defnlibxname{cpp_lib_forward_like}@ 202207L // also in \libheader{utility} +#define @\defnlibxname{cpp_lib_forward_like}@ 202207L // freestanding, also in \libheader{utility} +#define @\defnlibxname{cpp_lib_freestanding_feature_test_macros}@ 202306L // freestanding +#define @\defnlibxname{cpp_lib_freestanding_functional}@ 202306L // freestanding, also in \libheader{functional} +#define @\defnlibxname{cpp_lib_freestanding_iterator}@ 202306L // freestanding, also in \libheader{iterator} +#define @\defnlibxname{cpp_lib_freestanding_memory}@ 202306L // freestanding, also in \libheader{memory>} +#define @\defnlibxname{cpp_lib_freestanding_operator_new}@ @\seebelow@ // freestanding, also in \libheader{new} +#define @\defnlibxname{cpp_lib_freestanding_ranges}@ 202306L // freestanding, also in \libheader{ranges} +#define @\defnlibxname{cpp_lib_freestanding_ratio}@ 202306L // freestanding, also in \libheader{ratio} +#define @\defnlibxname{cpp_lib_freestanding_tuple}@ 202306L // freestanding, also in \libheader{tuple} +#define @\defnlibxname{cpp_lib_freestanding_utility}@ 202306L // freestanding, also in \libheader{utility} #define @\defnlibxname{cpp_lib_gcd_lcm}@ 201606L // also in \libheader{numeric} #define @\defnlibxname{cpp_lib_generator}@ 202207L // also in \libheader{generator} #define @\defnlibxname{cpp_lib_generic_associative_lookup}@ 201304L // also in \libheader{map}, \libheader{set} #define @\defnlibxname{cpp_lib_generic_unordered_lookup}@ 201811L // also in \libheader{unordered_map}, \libheader{unordered_set} -#define @\defnlibxname{cpp_lib_hardware_interference_size}@ 201703L // also in \libheader{new} -#define @\defnlibxname{cpp_lib_has_unique_object_representations}@ 201606L // also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_hardware_interference_size}@ 201703L // freestanding, also in \libheader{new} +#define @\defnlibxname{cpp_lib_has_unique_object_representations}@ 201606L // freestanding, also in \libheader{type_traits} #define @\defnlibxname{cpp_lib_hazard_pointer}@ 202306L // also in \libheader{hazard_pointer} #define @\defnlibxname{cpp_lib_hypot}@ 201603L // also in \libheader{cmath} #define @\defnlibxname{cpp_lib_incomplete_container_elements}@ 201505L // also in \libheader{forward_list}, \libheader{list}, \libheader{vector} -#define @\defnlibxname{cpp_lib_int_pow2}@ 202002L // also in \libheader{bit} +#define @\defnlibxname{cpp_lib_int_pow2}@ 202002L // freestanding, also in \libheader{bit} #define @\defnlibxname{cpp_lib_integer_comparison_functions}@ 202002L // also in \libheader{utility} -#define @\defnlibxname{cpp_lib_integer_sequence}@ 201304L // also in \libheader{utility} -#define @\defnlibxname{cpp_lib_integral_constant_callable}@ 201304L // also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_integer_sequence}@ 201304L // freestanding, also in \libheader{utility} +#define @\defnlibxname{cpp_lib_integral_constant_callable}@ 201304L // freestanding, also in \libheader{type_traits} #define @\defnlibxname{cpp_lib_interpolate}@ 201902L // also in \libheader{cmath}, \libheader{numeric} -#define @\defnlibxname{cpp_lib_invoke}@ 201411L // also in \libheader{functional} -#define @\defnlibxname{cpp_lib_invoke_r}@ 202106L // also in \libheader{functional} +#define @\defnlibxname{cpp_lib_invoke}@ 201411L // freestanding, also in \libheader{functional} +#define @\defnlibxname{cpp_lib_invoke_r}@ 202106L // freestanding, also in \libheader{functional} #define @\defnlibxname{cpp_lib_ios_noreplace}@ 202207L // also in \libheader{ios} -#define @\defnlibxname{cpp_lib_is_aggregate}@ 201703L // also in \libheader{type_traits} -#define @\defnlibxname{cpp_lib_is_constant_evaluated}@ 201811L // also in \libheader{type_traits} -#define @\defnlibxname{cpp_lib_is_final}@ 201402L // also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_is_aggregate}@ 201703L // freestanding, also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_is_constant_evaluated}@ 201811L // freestanding, also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_is_final}@ 201402L // freestanding, also in \libheader{type_traits} #define @\defnlibxname{cpp_lib_is_implicit_lifetime}@ 202302L // also in \libheader{type_traits} -#define @\defnlibxname{cpp_lib_is_invocable}@ 201703L // also in \libheader{type_traits} -#define @\defnlibxname{cpp_lib_is_layout_compatible}@ 201907L // also in \libheader{type_traits} -#define @\defnlibxname{cpp_lib_is_nothrow_convertible}@ 201806L // also in \libheader{type_traits} -#define @\defnlibxname{cpp_lib_is_null_pointer}@ 201309L // also in \libheader{type_traits} -#define @\defnlibxname{cpp_lib_is_pointer_interconvertible}@ 201907L // also in \libheader{type_traits} -#define @\defnlibxname{cpp_lib_is_scoped_enum}@ 202011L // also in \libheader{type_traits} -#define @\defnlibxname{cpp_lib_is_swappable}@ 201603L // also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_is_invocable}@ 201703L // freestanding, also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_is_layout_compatible}@ 201907L // freestanding, also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_is_nothrow_convertible}@ 201806L // freestanding, also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_is_null_pointer}@ 201309L // freestanding, also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_is_pointer_interconvertible}@ 201907L // freestanding, also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_is_scoped_enum}@ 202011L // freestanding, also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_is_swappable}@ 201603L // freestanding, also in \libheader{type_traits} #define @\defnlibxname{cpp_lib_jthread}@ 201911L // also in \libheader{stop_token}, \libheader{thread} #define @\defnlibxname{cpp_lib_latch}@ 201907L // also in \libheader{latch} -#define @\defnlibxname{cpp_lib_launder}@ 201606L // also in \libheader{new} +#define @\defnlibxname{cpp_lib_launder}@ 201606L // freestanding, also in \libheader{new} #define @\defnlibxname{cpp_lib_list_remove_return_type}@ 201806L // also in \libheader{forward_list}, \libheader{list} -#define @\defnlibxname{cpp_lib_logical_traits}@ 201510L // also in \libheader{type_traits} -#define @\defnlibxname{cpp_lib_make_from_tuple}@ 201606L // also in \libheader{tuple} -#define @\defnlibxname{cpp_lib_make_reverse_iterator}@ 201402L // also in \libheader{iterator} +#define @\defnlibxname{cpp_lib_logical_traits}@ 201510L // freestanding, also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_make_from_tuple}@ 201606L // freestanding, also in \libheader{tuple} +#define @\defnlibxname{cpp_lib_make_reverse_iterator}@ 201402L // freestanding, also in \libheader{iterator} #define @\defnlibxname{cpp_lib_make_unique}@ 201304L // also in \libheader{memory} #define @\defnlibxname{cpp_lib_map_try_emplace}@ 201411L // also in \libheader{map} #define @\defnlibxname{cpp_lib_math_constants}@ 201907L // also in \libheader{numbers} #define @\defnlibxname{cpp_lib_math_special_functions}@ 201603L // also in \libheader{cmath} #define @\defnlibxname{cpp_lib_mdspan}@ 202207L // also in \libheader{mdspan} #define @\defnlibxname{cpp_lib_memory_resource}@ 201603L // also in \libheader{memory_resource} -#define @\defnlibxname{cpp_lib_modules}@ 202207L -#define @\defnlibxname{cpp_lib_move_iterator_concept}@ 202207L // also in \libheader{iterator} +#define @\defnlibxname{cpp_lib_modules}@ 202207L // freestanding +#define @\defnlibxname{cpp_lib_move_iterator_concept}@ 202207L // freestanding, also in \libheader{iterator} #define @\defnlibxname{cpp_lib_move_only_function}@ 202110L // also in \libheader{functional} #define @\defnlibxname{cpp_lib_node_extract}@ 201606L // also in \libheader{map}, \libheader{set}, \libheader{unordered_map}, \libheader{unordered_set} #define @\defnlibxname{cpp_lib_nonmember_container_access}@ 201411L - // also in \libheader{array}, \libheader{deque}, \libheader{forward_list}, \libheader{iterator}, \libheader{list}, \libheader{map}, \libheader{regex}, \libheader{set}, \libheader{string}, - // \libheader{unordered_map}, \libheader{unordered_set}, \libheader{vector} -#define @\defnlibxname{cpp_lib_not_fn}@ 201603L // also in \libheader{functional} -#define @\defnlibxname{cpp_lib_null_iterators}@ 201304L // also in \libheader{iterator} + // freestanding, also in \libheader{array}, \libheader{deque}, \libheader{forward_list}, \libheader{iterator}, \libheader{list}, \libheader{map}, \libheader{regex}, \libheader{set}, + // \libheader{string}, \libheader{unordered_map}, \libheader{unordered_set}, \libheader{vector} +#define @\defnlibxname{cpp_lib_not_fn}@ 201603L // freestanding, also in \libheader{functional} +#define @\defnlibxname{cpp_lib_null_iterators}@ 201304L // freestanding, also in \libheader{iterator} #define @\defnlibxname{cpp_lib_optional}@ 202110L // also in \libheader{optional} #define @\defnlibxname{cpp_lib_out_ptr}@ 202106L // also in \libheader{memory} #define @\defnlibxname{cpp_lib_parallel_algorithm}@ 201603L // also in \libheader{algorithm}, \libheader{numeric} @@ -689,28 +700,30 @@ #define @\defnlibxname{cpp_lib_quoted_string_io}@ 201304L // also in \libheader{iomanip} #define @\defnlibxname{cpp_lib_ranges}@ 202302L // also in \libheader{algorithm}, \libheader{functional}, \libheader{iterator}, \libheader{memory}, \libheader{ranges} -#define @\defnlibxname{cpp_lib_ranges_as_const}@ 202207L // also in \libheader{ranges} -#define @\defnlibxname{cpp_lib_ranges_as_rvalue}@ 202207L // also in \libheader{ranges} -#define @\defnlibxname{cpp_lib_ranges_cartesian_product}@ 202207L // also in \libheader{ranges} -#define @\defnlibxname{cpp_lib_ranges_chunk}@ 202202L // also in \libheader{ranges} -#define @\defnlibxname{cpp_lib_ranges_chunk_by}@ 202202L // also in \libheader{ranges} +#define @\defnlibxname{cpp_lib_ranges_as_const}@ 202207L // freestanding, also in \libheader{ranges} +#define @\defnlibxname{cpp_lib_ranges_as_rvalue}@ 202207L // freestanding, also in \libheader{ranges} +#define @\defnlibxname{cpp_lib_ranges_cartesian_product}@ 202207L // freestanding, also in \libheader{ranges} +#define @\defnlibxname{cpp_lib_ranges_chunk}@ 202202L // freestanding, also in \libheader{ranges} +#define @\defnlibxname{cpp_lib_ranges_chunk_by}@ 202202L // freestanding, also in \libheader{ranges} #define @\defnlibxname{cpp_lib_ranges_contains}@ 202207L // also in \libheader{algorithm} #define @\defnlibxname{cpp_lib_ranges_enumerate}@ 202302L // also in \libheader{ranges}, \libheader{version} #define @\defnlibxname{cpp_lib_ranges_find_last}@ 202207L // also in \libheader{algorithm} #define @\defnlibxname{cpp_lib_ranges_fold}@ 202207L // also in \libheader{algorithm} #define @\defnlibxname{cpp_lib_ranges_iota}@ 202202L // also in \libheader{numeric} -#define @\defnlibxname{cpp_lib_ranges_join_with}@ 202202L // also in \libheader{ranges} -#define @\defnlibxname{cpp_lib_ranges_repeat}@ 202207L // also in \libheader{ranges} -#define @\defnlibxname{cpp_lib_ranges_slide}@ 202202L // also in \libheader{ranges} +#define @\defnlibxname{cpp_lib_ranges_join_with}@ 202202L // freestanding, also in \libheader{ranges} +#define @\defnlibxname{cpp_lib_ranges_repeat}@ 202207L // freestanding, also in \libheader{ranges} +#define @\defnlibxname{cpp_lib_ranges_slide}@ 202202L // freestanding, also in \libheader{ranges} #define @\defnlibxname{cpp_lib_ranges_starts_ends_with}@ 202106L // also in \libheader{algorithm} -#define @\defnlibxname{cpp_lib_ranges_stride}@ 202207L // also in \libheader{ranges} -#define @\defnlibxname{cpp_lib_ranges_to_container}@ 202202L // also in \libheader{ranges} -#define @\defnlibxname{cpp_lib_ranges_zip}@ 202110L // also in \libheader{ranges}, \libheader{tuple}, \libheader{utility} +#define @\defnlibxname{cpp_lib_ranges_stride}@ 202207L // freestanding, also in \libheader{ranges} +#define @\defnlibxname{cpp_lib_ranges_to_container}@ 202202L // freestanding, also in \libheader{ranges} +#define @\defnlibxname{cpp_lib_ranges_zip}@ 202110L + // freestanding, also in \libheader{ranges}, \libheader{tuple}, \libheader{utility} #define @\defnlibxname{cpp_lib_raw_memory_algorithms}@ 201606L // also in \libheader{memory} #define @\defnlibxname{cpp_lib_rcu}@ 202306L // also in \libheader{rcu} -#define @\defnlibxname{cpp_lib_reference_from_temporary}@ 202202L // also in \libheader{type_traits} -#define @\defnlibxname{cpp_lib_remove_cvref}@ 201711L // also in \libheader{type_traits} -#define @\defnlibxname{cpp_lib_result_of_sfinae}@ 201210L // also in \libheader{functional}, \libheader{type_traits} +#define @\defnlibxname{cpp_lib_reference_from_temporary}@ 202202L // freestanding, also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_remove_cvref}@ 201711L // freestanding, also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_result_of_sfinae}@ 201210L + // freestanding, also in \libheader{functional}, \libheader{type_traits} #define @\defnlibxname{cpp_lib_robust_nonmodifying_seq_ops}@ 201304L // also in \libheader{algorithm} #define @\defnlibxname{cpp_lib_sample}@ 201603L // also in \libheader{algorithm} #define @\defnlibxname{cpp_lib_scoped_lock}@ 201703L // also in \libheader{mutex} @@ -721,13 +734,13 @@ #define @\defnlibxname{cpp_lib_shared_timed_mutex}@ 201402L // also in \libheader{shared_mutex} #define @\defnlibxname{cpp_lib_shift}@ 202202L // also in \libheader{algorithm} #define @\defnlibxname{cpp_lib_smart_ptr_for_overwrite}@ 202002L // also in \libheader{memory} -#define @\defnlibxname{cpp_lib_source_location}@ 201907L // also in \libheader{source_location} +#define @\defnlibxname{cpp_lib_source_location}@ 201907L // freestanding, also in \libheader{source_location} #define @\defnlibxname{cpp_lib_span}@ 202002L // also in \libheader{span} #define @\defnlibxname{cpp_lib_spanstream}@ 202106L // also in \libheader{spanstream} -#define @\defnlibxname{cpp_lib_ssize}@ 201902L // also in \libheader{iterator} +#define @\defnlibxname{cpp_lib_ssize}@ 201902L // freestanding, also in \libheader{iterator} #define @\defnlibxname{cpp_lib_sstream_from_string_view}@ 202306L // also in \libheader{sstream} #define @\defnlibxname{cpp_lib_stacktrace}@ 202011L // also in \libheader{stacktrace} -#define @\defnlibxname{cpp_lib_start_lifetime_as}@ 202207L // also in \libheader{memory} +#define @\defnlibxname{cpp_lib_start_lifetime_as}@ 202207L // freestanding, also in \libheader{memory} #define @\defnlibxname{cpp_lib_starts_ends_with}@ 201711L // also in \libheader{string}, \libheader{string_view} #define @\defnlibxname{cpp_lib_stdatomic_h}@ 202011L // also in \libheader{stdatomic.h} #define @\defnlibxname{cpp_lib_string_contains}@ 202011L // also in \libheader{string}, \libheader{string_view} @@ -735,28 +748,41 @@ #define @\defnlibxname{cpp_lib_string_udls}@ 201304L // also in \libheader{string} #define @\defnlibxname{cpp_lib_string_view}@ 201803L // also in \libheader{string}, \libheader{string_view} #define @\defnlibxname{cpp_lib_syncbuf}@ 201803L // also in \libheader{syncstream} -#define @\defnlibxname{cpp_lib_three_way_comparison}@ 201907L // also in \libheader{compare} -#define @\defnlibxname{cpp_lib_to_address}@ 201711L // also in \libheader{memory} +#define @\defnlibxname{cpp_lib_three_way_comparison}@ 201907L // freestanding, also in \libheader{compare} +#define @\defnlibxname{cpp_lib_to_address}@ 201711L // freestanding, also in \libheader{memory} #define @\defnlibxname{cpp_lib_to_array}@ 201907L // also in \libheader{array} #define @\defnlibxname{cpp_lib_to_chars}@ 202306L // also in \libheader{charconv} #define @\defnlibxname{cpp_lib_to_string}@ 202306L // also in \libheader{string} -#define @\defnlibxname{cpp_lib_to_underlying}@ 202102L // also in \libheader{utility} -#define @\defnlibxname{cpp_lib_transformation_trait_aliases}@ 201304L // also in \libheader{type_traits} -#define @\defnlibxname{cpp_lib_transparent_operators}@ 201510L // also in \libheader{memory}, \libheader{functional} +#define @\defnlibxname{cpp_lib_to_underlying}@ 202102L // freestanding, also in \libheader{utility} +#define @\defnlibxname{cpp_lib_transformation_trait_aliases}@ 201304L // freestanding, also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_transparent_operators}@ 201510L + // freestanding, also in \libheader{memory}, \libheader{functional} #define @\defnlibxname{cpp_lib_tuple_like}@ 202207L // also in \libheader{utility}, \libheader{tuple}, \libheader{map}, \libheader{unordered_map} -#define @\defnlibxname{cpp_lib_tuple_element_t}@ 201402L // also in \libheader{tuple} -#define @\defnlibxname{cpp_lib_tuples_by_type}@ 201304L // also in \libheader{utility}, \libheader{tuple} -#define @\defnlibxname{cpp_lib_type_identity}@ 201806L // also in \libheader{type_traits} -#define @\defnlibxname{cpp_lib_type_trait_variable_templates}@ 201510L // also in \libheader{type_traits} -#define @\defnlibxname{cpp_lib_uncaught_exceptions}@ 201411L // also in \libheader{exception} +#define @\defnlibxname{cpp_lib_tuple_element_t}@ 201402L // freestanding, also in \libheader{tuple} +#define @\defnlibxname{cpp_lib_tuples_by_type}@ 201304L // freestanding, also in \libheader{utility}, \libheader{tuple} +#define @\defnlibxname{cpp_lib_type_identity}@ 201806L // freestanding, also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_type_trait_variable_templates}@ 201510L // freestanding, also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_uncaught_exceptions}@ 201411L // freestanding, also in \libheader{exception} #define @\defnlibxname{cpp_lib_unordered_map_try_emplace}@ 201411L // also in \libheader{unordered_map} -#define @\defnlibxname{cpp_lib_unreachable}@ 202202L // also in \libheader{utility} -#define @\defnlibxname{cpp_lib_unwrap_ref}@ 201811L // also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_unreachable}@ 202202L // freestanding, also in \libheader{utility} +#define @\defnlibxname{cpp_lib_unwrap_ref}@ 201811L // freestanding, also in \libheader{type_traits} #define @\defnlibxname{cpp_lib_variant}@ 202106L // also in \libheader{variant} -#define @\defnlibxname{cpp_lib_void_t}@ 201411L // also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_void_t}@ 201411L // freestanding, also in \libheader{type_traits} \end{codeblock} +\pnum +The macro \xname{cpp_lib_freestanding_operator_new} is defined to +the integer literal \tcode{202306L} +if all the default versions of the replaceable global allocation functions meet +the requirements of a hosted implementation, and +to the integer literal \tcode{0} otherwise\iref{new.delete}. + +\pnum +\recommended +Freestanding implementations should only define a macro from \libheader{version} +if the implementation provides the corresponding facility in its entirety. + \rSec2[limits.syn]{Header \tcode{} synopsis} \indexheader{limits}% From 3724bb080e435ae71f998052f05c6319f113f003 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Mon, 26 Jun 2023 20:51:24 +0200 Subject: [PATCH 089/171] [compliance] Replace 'may' with 'can' in note --- source/lib-intro.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/lib-intro.tex b/source/lib-intro.tex index cd158b5a0e..a40f66a4b3 100644 --- a/source/lib-intro.tex +++ b/source/lib-intro.tex @@ -1492,7 +1492,7 @@ the namespace-scope functions and function templates from the hosted library facilities. \begin{note} -An implementation may provide a deleted definition +An implementation can provide a deleted definition so that the result of overload resolution does not silently change when migrating a program from a freestanding implementation to a hosted implementation. From 9eaf064cc3eb5a0b1e3964a7577d810ae830410b Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Mon, 26 Jun 2023 22:36:37 +0200 Subject: [PATCH 090/171] P2338R4 Freestanding Library: Character primitives and the C library Editorial notes: - sort table [tab:headers.cpp.fs] by section number --- source/diagnostics.tex | 150 ++++++++++++++++++++--------------------- source/lib-intro.tex | 35 ++++++++-- source/numerics.tex | 8 +-- source/strings.tex | 128 +++++++++++++++++------------------ source/support.tex | 51 ++++++++------ source/utilities.tex | 27 +++++--- 6 files changed, 216 insertions(+), 183 deletions(-) diff --git a/source/diagnostics.tex b/source/diagnostics.tex index be48fa0244..7a92ab5a90 100644 --- a/source/diagnostics.tex +++ b/source/diagnostics.tex @@ -575,80 +575,80 @@ \begin{codeblock} #define errno @\seebelow@ -#define E2BIG @\seebelow@ -#define EACCES @\seebelow@ -#define EADDRINUSE @\seebelow@ -#define EADDRNOTAVAIL @\seebelow@ -#define EAFNOSUPPORT @\seebelow@ -#define EAGAIN @\seebelow@ -#define EALREADY @\seebelow@ -#define EBADF @\seebelow@ -#define EBADMSG @\seebelow@ -#define EBUSY @\seebelow@ -#define ECANCELED @\seebelow@ -#define ECHILD @\seebelow@ -#define ECONNABORTED @\seebelow@ -#define ECONNREFUSED @\seebelow@ -#define ECONNRESET @\seebelow@ -#define EDEADLK @\seebelow@ -#define EDESTADDRREQ @\seebelow@ -#define EDOM @\seebelow@ -#define EEXIST @\seebelow@ -#define EFAULT @\seebelow@ -#define EFBIG @\seebelow@ -#define EHOSTUNREACH @\seebelow@ -#define EIDRM @\seebelow@ -#define EILSEQ @\seebelow@ -#define EINPROGRESS @\seebelow@ -#define EINTR @\seebelow@ -#define EINVAL @\seebelow@ -#define EIO @\seebelow@ -#define EISCONN @\seebelow@ -#define EISDIR @\seebelow@ -#define ELOOP @\seebelow@ -#define EMFILE @\seebelow@ -#define EMLINK @\seebelow@ -#define EMSGSIZE @\seebelow@ -#define ENAMETOOLONG @\seebelow@ -#define ENETDOWN @\seebelow@ -#define ENETRESET @\seebelow@ -#define ENETUNREACH @\seebelow@ -#define ENFILE @\seebelow@ -#define ENOBUFS @\seebelow@ -#define ENODEV @\seebelow@ -#define ENOENT @\seebelow@ -#define ENOEXEC @\seebelow@ -#define ENOLCK @\seebelow@ -#define ENOLINK @\seebelow@ -#define ENOMEM @\seebelow@ -#define ENOMSG @\seebelow@ -#define ENOPROTOOPT @\seebelow@ -#define ENOSPC @\seebelow@ -#define ENOSYS @\seebelow@ -#define ENOTCONN @\seebelow@ -#define ENOTDIR @\seebelow@ -#define ENOTEMPTY @\seebelow@ -#define ENOTRECOVERABLE @\seebelow@ -#define ENOTSOCK @\seebelow@ -#define ENOTSUP @\seebelow@ -#define ENOTTY @\seebelow@ -#define ENXIO @\seebelow@ -#define EOPNOTSUPP @\seebelow@ -#define EOVERFLOW @\seebelow@ -#define EOWNERDEAD @\seebelow@ -#define EPERM @\seebelow@ -#define EPIPE @\seebelow@ -#define EPROTO @\seebelow@ -#define EPROTONOSUPPORT @\seebelow@ -#define EPROTOTYPE @\seebelow@ -#define ERANGE @\seebelow@ -#define EROFS @\seebelow@ -#define ESPIPE @\seebelow@ -#define ESRCH @\seebelow@ -#define ETIMEDOUT @\seebelow@ -#define ETXTBSY @\seebelow@ -#define EWOULDBLOCK @\seebelow@ -#define EXDEV @\seebelow@ +#define E2BIG @\seebelow@ // freestanding +#define EACCES @\seebelow@ // freestanding +#define EADDRINUSE @\seebelow@ // freestanding +#define EADDRNOTAVAIL @\seebelow@ // freestanding +#define EAFNOSUPPORT @\seebelow@ // freestanding +#define EAGAIN @\seebelow@ // freestanding +#define EALREADY @\seebelow@ // freestanding +#define EBADF @\seebelow@ // freestanding +#define EBADMSG @\seebelow@ // freestanding +#define EBUSY @\seebelow@ // freestanding +#define ECANCELED @\seebelow@ // freestanding +#define ECHILD @\seebelow@ // freestanding +#define ECONNABORTED @\seebelow@ // freestanding +#define ECONNREFUSED @\seebelow@ // freestanding +#define ECONNRESET @\seebelow@ // freestanding +#define EDEADLK @\seebelow@ // freestanding +#define EDESTADDRREQ @\seebelow@ // freestanding +#define EDOM @\seebelow@ // freestanding +#define EEXIST @\seebelow@ // freestanding +#define EFAULT @\seebelow@ // freestanding +#define EFBIG @\seebelow@ // freestanding +#define EHOSTUNREACH @\seebelow@ // freestanding +#define EIDRM @\seebelow@ // freestanding +#define EILSEQ @\seebelow@ // freestanding +#define EINPROGRESS @\seebelow@ // freestanding +#define EINTR @\seebelow@ // freestanding +#define EINVAL @\seebelow@ // freestanding +#define EIO @\seebelow@ // freestanding +#define EISCONN @\seebelow@ // freestanding +#define EISDIR @\seebelow@ // freestanding +#define ELOOP @\seebelow@ // freestanding +#define EMFILE @\seebelow@ // freestanding +#define EMLINK @\seebelow@ // freestanding +#define EMSGSIZE @\seebelow@ // freestanding +#define ENAMETOOLONG @\seebelow@ // freestanding +#define ENETDOWN @\seebelow@ // freestanding +#define ENETRESET @\seebelow@ // freestanding +#define ENETUNREACH @\seebelow@ // freestanding +#define ENFILE @\seebelow@ // freestanding +#define ENOBUFS @\seebelow@ // freestanding +#define ENODEV @\seebelow@ // freestanding +#define ENOENT @\seebelow@ // freestanding +#define ENOEXEC @\seebelow@ // freestanding +#define ENOLCK @\seebelow@ // freestanding +#define ENOLINK @\seebelow@ // freestanding +#define ENOMEM @\seebelow@ // freestanding +#define ENOMSG @\seebelow@ // freestanding +#define ENOPROTOOPT @\seebelow@ // freestanding +#define ENOSPC @\seebelow@ // freestanding +#define ENOSYS @\seebelow@ // freestanding +#define ENOTCONN @\seebelow@ // freestanding +#define ENOTDIR @\seebelow@ // freestanding +#define ENOTEMPTY @\seebelow@ // freestanding +#define ENOTRECOVERABLE @\seebelow@ // freestanding +#define ENOTSOCK @\seebelow@ // freestanding +#define ENOTSUP @\seebelow@ // freestanding +#define ENOTTY @\seebelow@ // freestanding +#define ENXIO @\seebelow@ // freestanding +#define EOPNOTSUPP @\seebelow@ // freestanding +#define EOVERFLOW @\seebelow@ // freestanding +#define EOWNERDEAD @\seebelow@ // freestanding +#define EPERM @\seebelow@ // freestanding +#define EPIPE @\seebelow@ // freestanding +#define EPROTO @\seebelow@ // freestanding +#define EPROTONOSUPPORT @\seebelow@ // freestanding +#define EPROTOTYPE @\seebelow@ // freestanding +#define ERANGE @\seebelow@ // freestanding +#define EROFS @\seebelow@ // freestanding +#define ESPIPE @\seebelow@ // freestanding +#define ESRCH @\seebelow@ // freestanding +#define ETIMEDOUT @\seebelow@ // freestanding +#define ETXTBSY @\seebelow@ // freestanding +#define EWOULDBLOCK @\seebelow@ // freestanding +#define EXDEV @\seebelow@ // freestanding \end{codeblock} \pnum @@ -701,7 +701,7 @@ template struct is_error_condition_enum : public false_type {}; - enum class errc { + enum class errc { // freestanding address_family_not_supported, // \tcode{EAFNOSUPPORT} address_in_use, // \tcode{EADDRINUSE} address_not_available, // \tcode{EADDRNOTAVAIL} diff --git a/source/lib-intro.tex b/source/lib-intro.tex index a40f66a4b3..b774ca2f1a 100644 --- a/source/lib-intro.tex +++ b/source/lib-intro.tex @@ -948,6 +948,20 @@ \end{codeblock} \end{example} +\pnum +Function declarations and function template declarations +followed by a comment that include \textit{freestanding-deleted} are +\defnadjx{freestanding deleted}{functions}{function}. +On freestanding implementations, +it is \impldef{whether a freestanding deleted function is a freestanding item or a deleted function} +whether each function definition introduced by a freestanding deleted function +is a freestanding item or a deleted function\iref{dcl.fct.def.delete}. +\begin{example} +\begin{codeblock} +double abs(double j); // freestanding-deleted +\end{codeblock} +\end{example} + \rSec1[requirements]{Library-wide requirements} \rSec2[requirements.general]{General} @@ -1441,10 +1455,11 @@ \begin{libsumtab}{\Cpp{} headers for freestanding implementations}{headers.cpp.fs} \ref{support.types} & Common definitions & \tcode{} \\ \rowsep +\ref{cstdlib.syn} & C standard library & \tcode{} \\ \rowsep \ref{support.limits} & Implementation properties & - \tcode{}, \tcode{}, \tcode{}, \tcode{} \\ \rowsep + \tcode{}, \tcode{}, \tcode{}, \\ + & & \tcode{} \\ \rowsep \ref{cstdint.syn} & Integer types & \tcode{} \\ \rowsep -\ref{support.start.term} & Start and termination & \tcode{} \\ \rowsep \ref{support.dynamic} & Dynamic memory management & \tcode{} \\ \rowsep \ref{support.rtti} & Type identification & \tcode{} \\ \rowsep \ref{support.srcloc} & Source location & \tcode{} \\ \rowsep @@ -1454,16 +1469,22 @@ \ref{support.coroutine} & Coroutines support & \tcode{} \\ \rowsep \ref{support.runtime} & Other runtime support & \tcode{} \\ \rowsep \ref{concepts} & Concepts library & \tcode{} \\ \rowsep +\ref{errno} & Error numbers & \tcode{} \\ \rowsep +\ref{syserr} & System error support & \tcode{} \\ \rowsep +\ref{memory} & Memory & \tcode{} \\ \rowsep \ref{type.traits} & Type traits & \tcode{} \\ \rowsep -\ref{bit} & Bit manipulation & \tcode{} \\ \rowsep -\ref{atomics} & Atomics & \tcode{} \\ \rowsep +\ref{ratio} & Compile-time rational arithmetic & \tcode{} \\ \rowsep \ref{utility} & Utility components & \tcode{} \\ \rowsep \ref{tuple} & Tuples & \tcode{} \\ \rowsep -\ref{memory} & Memory & \tcode{} \\ \rowsep \ref{function.objects} & Function objects & \tcode{} \\ \rowsep -\ref{ratio} & Compile-time rational arithmetic & \tcode{} \\ \rowsep +\ref{charconv} & Primitive numeric conversions & \tcode{} \\ \rowsep +\ref{bit} & Bit manipulation & \tcode{} \\ \rowsep +\ref{string.classes} & String classes & \tcode{} \\ \rowsep +\ref{c.strings} & Null-terminated sequence utilities & \tcode{}, \tcode{} \\ \rowsep \ref{iterators} & Iterators library & \tcode{} \\ \rowsep -\ref{ranges} & Ranges library & \tcode{} \\ +\ref{ranges} & Ranges library & \tcode{} \\ \rowsep +\ref{c.math} & Mathematical functions for floating-point types & \tcode{} \\ \rowsep +\ref{atomics} & Atomics & \tcode{} \\ \rowsep \end{libsumtab} \pnum diff --git a/source/numerics.tex b/source/numerics.tex index 81efc1e347..680ca3dfe0 100644 --- a/source/numerics.tex +++ b/source/numerics.tex @@ -9072,10 +9072,10 @@ long double cbrtl(long double x); // \ref{c.math.abs}, absolute values - constexpr int abs(int j); - constexpr long int abs(long int j); - constexpr long long int abs(long long int j); - constexpr @\placeholder{floating-point-type}@ abs(@\placeholder{floating-point-type}@ j); + constexpr int abs(int j); // freestanding + constexpr long int abs(long int j); // freestanding + constexpr long long int abs(long long int j); // freestanding + constexpr @\placeholder{floating-point-type}@ abs(@\placeholder{floating-point-type}@ j); // freestanding-deleted constexpr @\placeholder{floating-point-type}@ fabs(@\placeholder{floating-point-type}@ x); constexpr float fabsf(float x); diff --git a/source/strings.tex b/source/strings.tex index 55b41e31ee..31e778e991 100644 --- a/source/strings.tex +++ b/source/strings.tex @@ -1793,12 +1793,12 @@ namespace std { // \ref{char.traits}, character traits - template struct char_traits; - template<> struct char_traits; - template<> struct char_traits; - template<> struct char_traits; - template<> struct char_traits; - template<> struct char_traits; + template struct char_traits; // freestanding + template<> struct char_traits; // freestanding + template<> struct char_traits; // freestanding + template<> struct char_traits; // freestanding + template<> struct char_traits; // freestanding + template<> struct char_traits; // freestanding // \ref{basic.string}, \tcode{basic_string} template, class Allocator = allocator> @@ -5492,38 +5492,38 @@ \indexlibraryglobal{strxfrm}% \begin{codeblock} namespace std { - using size_t = @\textit{see \ref{support.types.layout}}@; - - void* memcpy(void* s1, const void* s2, size_t n); - void* memmove(void* s1, const void* s2, size_t n); - char* strcpy(char* s1, const char* s2); - char* strncpy(char* s1, const char* s2, size_t n); - char* strcat(char* s1, const char* s2); - char* strncat(char* s1, const char* s2, size_t n); - int memcmp(const void* s1, const void* s2, size_t n); - int strcmp(const char* s1, const char* s2); + using size_t = @\textit{see \ref{support.types.layout}}@; // freestanding + + void* memcpy(void* s1, const void* s2, size_t n); // freestanding + void* memmove(void* s1, const void* s2, size_t n); // freestanding + char* strcpy(char* s1, const char* s2); // freestanding + char* strncpy(char* s1, const char* s2, size_t n); // freestanding + char* strcat(char* s1, const char* s2); // freestanding + char* strncat(char* s1, const char* s2, size_t n); // freestanding + int memcmp(const void* s1, const void* s2, size_t n); // freestanding + int strcmp(const char* s1, const char* s2); // freestanding int strcoll(const char* s1, const char* s2); - int strncmp(const char* s1, const char* s2, size_t n); + int strncmp(const char* s1, const char* s2, size_t n); // freestanding size_t strxfrm(char* s1, const char* s2, size_t n); - const void* memchr(const void* s, int c, size_t n); // see \ref{library.c} - void* memchr(void* s, int c, size_t n); // see \ref{library.c} - const char* strchr(const char* s, int c); // see \ref{library.c} - char* strchr(char* s, int c); // see \ref{library.c} - size_t strcspn(const char* s1, const char* s2); - const char* strpbrk(const char* s1, const char* s2); // see \ref{library.c} - char* strpbrk(char* s1, const char* s2); // see \ref{library.c} - const char* strrchr(const char* s, int c); // see \ref{library.c} - char* strrchr(char* s, int c); // see \ref{library.c} - size_t strspn(const char* s1, const char* s2); - const char* strstr(const char* s1, const char* s2); // see \ref{library.c} - char* strstr(char* s1, const char* s2); // see \ref{library.c} - char* strtok(char* s1, const char* s2); - void* memset(void* s, int c, size_t n); + const void* memchr(const void* s, int c, size_t n); // freestanding; see \ref{library.c} + void* memchr(void* s, int c, size_t n); // freestanding; see \ref{library.c} + const char* strchr(const char* s, int c); // freestanding; see \ref{library.c} + char* strchr(char* s, int c); // freestanding; see \ref{library.c} + size_t strcspn(const char* s1, const char* s2); // freestanding + const char* strpbrk(const char* s1, const char* s2); // freestanding; see \ref{library.c} + char* strpbrk(char* s1, const char* s2); // freestanding; see \ref{library.c} + const char* strrchr(const char* s, int c); // freestanding; see \ref{library.c} + char* strrchr(char* s, int c); // freestanding; see \ref{library.c} + size_t strspn(const char* s1, const char* s2); // freestanding + const char* strstr(const char* s1, const char* s2); // freestanding; see \ref{library.c} + char* strstr(char* s1, const char* s2); // freestanding; see \ref{library.c} + char* strtok(char* s1, const char* s2); // freestanding + void* memset(void* s, int c, size_t n); // freestanding char* strerror(int errnum); - size_t strlen(const char* s); + size_t strlen(const char* s); // freestanding } -#define NULL @\textit{see \ref{support.types.nullptr}}@ +#define NULL @\textit{see \ref{support.types.nullptr}}@ // freestanding \end{codeblock} \pnum @@ -5624,9 +5624,9 @@ \indexlibraryglobal{wscanf}% \begin{codeblock} namespace std { - using size_t = @\textit{see \ref{support.types.layout}}@; - using mbstate_t = @\seebelow@; - using wint_t = @\seebelow@; + using size_t = @\textit{see \ref{support.types.layout}}@; // freestanding + using mbstate_t = @\seebelow@; // freestanding + using wint_t = @\seebelow@; // freestanding struct tm; @@ -5659,32 +5659,32 @@ long long int wcstoll(const wchar_t* nptr, wchar_t** endptr, int base); unsigned long int wcstoul(const wchar_t* nptr, wchar_t** endptr, int base); unsigned long long int wcstoull(const wchar_t* nptr, wchar_t** endptr, int base); - wchar_t* wcscpy(wchar_t* s1, const wchar_t* s2); - wchar_t* wcsncpy(wchar_t* s1, const wchar_t* s2, size_t n); - wchar_t* wmemcpy(wchar_t* s1, const wchar_t* s2, size_t n); - wchar_t* wmemmove(wchar_t* s1, const wchar_t* s2, size_t n); - wchar_t* wcscat(wchar_t* s1, const wchar_t* s2); - wchar_t* wcsncat(wchar_t* s1, const wchar_t* s2, size_t n); - int wcscmp(const wchar_t* s1, const wchar_t* s2); + wchar_t* wcscpy(wchar_t* s1, const wchar_t* s2); // freestanding + wchar_t* wcsncpy(wchar_t* s1, const wchar_t* s2, size_t n); // freestanding + wchar_t* wmemcpy(wchar_t* s1, const wchar_t* s2, size_t n); // freestanding + wchar_t* wmemmove(wchar_t* s1, const wchar_t* s2, size_t n); // freestanding + wchar_t* wcscat(wchar_t* s1, const wchar_t* s2); // freestanding + wchar_t* wcsncat(wchar_t* s1, const wchar_t* s2, size_t n); // freestanding + int wcscmp(const wchar_t* s1, const wchar_t* s2); // freestanding int wcscoll(const wchar_t* s1, const wchar_t* s2); - int wcsncmp(const wchar_t* s1, const wchar_t* s2, size_t n); + int wcsncmp(const wchar_t* s1, const wchar_t* s2, size_t n); // freestanding size_t wcsxfrm(wchar_t* s1, const wchar_t* s2, size_t n); - int wmemcmp(const wchar_t* s1, const wchar_t* s2, size_t n); - const wchar_t* wcschr(const wchar_t* s, wchar_t c); // see \ref{library.c} - wchar_t* wcschr(wchar_t* s, wchar_t c); // see \ref{library.c} - size_t wcscspn(const wchar_t* s1, const wchar_t* s2); - const wchar_t* wcspbrk(const wchar_t* s1, const wchar_t* s2); // see \ref{library.c} - wchar_t* wcspbrk(wchar_t* s1, const wchar_t* s2); // see \ref{library.c} - const wchar_t* wcsrchr(const wchar_t* s, wchar_t c); // see \ref{library.c} - wchar_t* wcsrchr(wchar_t* s, wchar_t c); // see \ref{library.c} - size_t wcsspn(const wchar_t* s1, const wchar_t* s2); - const wchar_t* wcsstr(const wchar_t* s1, const wchar_t* s2); // see \ref{library.c} - wchar_t* wcsstr(wchar_t* s1, const wchar_t* s2); // see \ref{library.c} - wchar_t* wcstok(wchar_t* s1, const wchar_t* s2, wchar_t** ptr); - const wchar_t* wmemchr(const wchar_t* s, wchar_t c, size_t n); // see \ref{library.c} - wchar_t* wmemchr(wchar_t* s, wchar_t c, size_t n); // see \ref{library.c} - size_t wcslen(const wchar_t* s); - wchar_t* wmemset(wchar_t* s, wchar_t c, size_t n); + int wmemcmp(const wchar_t* s1, const wchar_t* s2, size_t n); // freestanding + const wchar_t* wcschr(const wchar_t* s, wchar_t c); // freestanding; see \ref{library.c} + wchar_t* wcschr(wchar_t* s, wchar_t c); // freestanding; see \ref{library.c} + size_t wcscspn(const wchar_t* s1, const wchar_t* s2); // freestanding + const wchar_t* wcspbrk(const wchar_t* s1, const wchar_t* s2); // freestanding; see \ref{library.c} + wchar_t* wcspbrk(wchar_t* s1, const wchar_t* s2); // freestanding; see \ref{library.c} + const wchar_t* wcsrchr(const wchar_t* s, wchar_t c); // freestanding; see \ref{library.c} + wchar_t* wcsrchr(wchar_t* s, wchar_t c); // freestanding; see \ref{library.c} + size_t wcsspn(const wchar_t* s1, const wchar_t* s2); // freestanding + const wchar_t* wcsstr(const wchar_t* s1, const wchar_t* s2); // freestanding; see \ref{library.c} + wchar_t* wcsstr(wchar_t* s1, const wchar_t* s2); // freestanding; see \ref{library.c} + wchar_t* wcstok(wchar_t* s1, const wchar_t* s2, wchar_t** ptr); // freestanding + const wchar_t* wmemchr(const wchar_t* s, wchar_t c, size_t n); // freestanding; see \ref{library.c} + wchar_t* wmemchr(wchar_t* s, wchar_t c, size_t n); // freestanding; see \ref{library.c} + size_t wcslen(const wchar_t* s); // freestanding + wchar_t* wmemset(wchar_t* s, wchar_t c, size_t n); // freestanding size_t wcsftime(wchar_t* s, size_t maxsize, const wchar_t* format, const tm* timeptr); wint_t btowc(int c); int wctob(wint_t c); @@ -5698,10 +5698,10 @@ size_t wcsrtombs(char* dst, const wchar_t** src, size_t len, mbstate_t* ps); } -#define NULL @\textit{see \ref{support.types.nullptr}}@ -#define WCHAR_MAX @\seebelow@ -#define WCHAR_MIN @\seebelow@ -#define WEOF @\seebelow@ +#define NULL @\textit{see \ref{support.types.nullptr}}@ // freestanding +#define WCHAR_MAX @\seebelow@ // freestanding +#define WCHAR_MIN @\seebelow@ // freestanding +#define WEOF @\seebelow@ // freestanding \end{codeblock} \pnum diff --git a/source/support.tex b/source/support.tex index 24d186bdd8..7e17cf0c49 100644 --- a/source/support.tex +++ b/source/support.tex @@ -150,14 +150,14 @@ \begin{codeblock} namespace std { using size_t = @\seebelow@; // freestanding - using div_t = @\seebelow@; - using ldiv_t = @\seebelow@; - using lldiv_t = @\seebelow@; + using div_t = @\seebelow@; // freestanding + using ldiv_t = @\seebelow@; // freestanding + using lldiv_t = @\seebelow@; // freestanding } #define NULL @\seebelow@ // freestanding -#define EXIT_FAILURE @\seebelow@ -#define EXIT_SUCCESS @\seebelow@ +#define EXIT_FAILURE @\seebelow@ // freestanding +#define EXIT_SUCCESS @\seebelow@ // freestanding #define RAND_MAX @\seebelow@ #define MB_CUR_MAX @\seebelow@ @@ -208,31 +208,31 @@ size_t wcstombs(char* s, const wchar_t* pwcs, size_t n); // \ref{alg.c.library}, C standard library algorithms - void* bsearch(const void* key, const void* base, size_t nmemb, size_t size, + void* bsearch(const void* key, const void* base, size_t nmemb, size_t size, // freestanding @\placeholder{c-compare-pred}@*@\itcorr[-1]@ compar); - void* bsearch(const void* key, const void* base, size_t nmemb, size_t size, + void* bsearch(const void* key, const void* base, size_t nmemb, size_t size, // freestanding @\placeholder{compare-pred}@*@\itcorr[-1]@ compar); - void qsort(void* base, size_t nmemb, size_t size, @\placeholder{c-compare-pred}@*@\itcorr[-1]@ compar); - void qsort(void* base, size_t nmemb, size_t size, @\placeholder{compare-pred}@*@\itcorr[-1]@ compar); + void qsort(void* base, size_t nmemb, size_t size, @\placeholder{c-compare-pred}@*@\itcorr[-1]@ compar); // freestanding + void qsort(void* base, size_t nmemb, size_t size, @\placeholder{compare-pred}@*@\itcorr[-1]@ compar); // freestanding // \ref{c.math.rand}, low-quality random number generation int rand(); void srand(unsigned int seed); // \ref{c.math.abs}, absolute values - constexpr int abs(int j); - constexpr long int abs(long int j); - constexpr long long int abs(long long int j); - constexpr @\placeholder{floating-point-type}@ abs(@\placeholder{floating-point-type}@ j); - - constexpr long int labs(long int j); - constexpr long long int llabs(long long int j); - - constexpr div_t div(int numer, int denom); - constexpr ldiv_t div(long int numer, long int denom); // see \ref{library.c} - constexpr lldiv_t div(long long int numer, long long int denom); // see \ref{library.c} - constexpr ldiv_t ldiv(long int numer, long int denom); - constexpr lldiv_t lldiv(long long int numer, long long int denom); + constexpr int abs(int j); // freestanding + constexpr long int abs(long int j); // freestanding + constexpr long long int abs(long long int j); // freestanding + constexpr @\placeholder{floating-point-type}@ abs(@\placeholder{floating-point-type}@ j); // freestanding-deleted + + constexpr long int labs(long int j); // freestanding + constexpr long long int llabs(long long int j); // freestanding + + constexpr div_t div(int numer, int denom); // freestanding + constexpr ldiv_t div(long int numer, long int denom); // freestanding; see \ref{library.c} + constexpr lldiv_t div(long long int numer, long long int denom); // freestanding; see \ref{library.c} + constexpr ldiv_t ldiv(long int numer, long int denom); // freestanding + constexpr lldiv_t lldiv(long long int numer, long long int denom); // freestanding } \end{codeblock} @@ -630,6 +630,13 @@ #define @\defnlibxname{cpp_lib_format_ranges}@ 202207L // also in \libheader{format} #define @\defnlibxname{cpp_lib_formatters}@ 202302L // also in \libheader{stacktrace}, \libheader{thread} #define @\defnlibxname{cpp_lib_forward_like}@ 202207L // freestanding, also in \libheader{utility} +#define @\defnlibxname{cpp_lib_freestanding_char_traits}@ 202306L // freestanding, also in \libheader{string} +#define @\defnlibxname{cpp_lib_freestanding_charconv}@ 202306L // freestanding, also in \libheader{charconv} +#define @\defnlibxname{cpp_lib_freestanding_cstdlib}@ 202306L // freestanding, also in \libheader{stdlib}, \libheader{cmath} +#define @\defnlibxname{cpp_lib_freestanding_cstring}@ 202306L // freestanding, also in \libheader{cstring} +#define @\defnlibxname{cpp_lib_freestanding_cwchar}@ 202306L // freestanding, also in \libheader{cwchar} +#define @\defnlibxname{cpp_lib_freestanding_errc}@ 202306L + // freestanding, also in \libheader{cerrno}, \libheader{system_error} #define @\defnlibxname{cpp_lib_freestanding_feature_test_macros}@ 202306L // freestanding #define @\defnlibxname{cpp_lib_freestanding_functional}@ 202306L // freestanding, also in \libheader{functional} #define @\defnlibxname{cpp_lib_freestanding_iterator}@ 202306L // freestanding, also in \libheader{iterator} diff --git a/source/utilities.tex b/source/utilities.tex index 942af1431c..ab5db626f6 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -14197,37 +14197,42 @@ \indexlibrarymember{ec}{to_chars_result} @ // \ref{charconv.to.chars}, primitive numerical output conversion - struct to_chars_result { + struct to_chars_result { // freestanding char* ptr; errc ec; friend bool operator==(const to_chars_result&, const to_chars_result&) = default; constexpr explicit operator bool() const noexcept { return ec == errc{}; } }; - constexpr to_chars_result to_chars(char* first, char* last, @\placeholder{integer-type}@ value, int base = 10); - to_chars_result to_chars(char* first, char* last, bool value, int base = 10) = delete; - - to_chars_result to_chars(char* first, char* last, @\placeholder{floating-point-type}@ value); - to_chars_result to_chars(char* first, char* last, @\placeholder{floating-point-type}@ value, chars_format fmt); - to_chars_result to_chars(char* first, char* last, @\placeholder{floating-point-type}@ value, - chars_format fmt, int precision); + constexpr to_chars_result to_chars(char* first, char* last, // freestanding + @\placeholder{integer-type}@ value, int base = 10); + to_chars_result to_chars(char* first, char* last, // freestanding + bool value, int base = 10) = delete; + + to_chars_result to_chars(char* first, char* last, // freestanding-deleted + @\placeholder{floating-point-type}@ value); + to_chars_result to_chars(char* first, char* last, // freestanding-deleted + @\placeholder{floating-point-type}@ value, chars_format fmt); + to_chars_result to_chars(char* first, char* last, // freestanding-deleted + @\placeholder{floating-point-type}@ value, chars_format fmt, int precision); @% \indexlibraryglobal{from_chars_result}% \indexlibrarymember{ptr}{from_chars_result}% \indexlibrarymember{ec}{from_chars_result} @ // \ref{charconv.from.chars}, primitive numerical input conversion - struct from_chars_result { + struct from_chars_result { // freestanding const char* ptr; errc ec; friend bool operator==(const from_chars_result&, const from_chars_result&) = default; constexpr explicit operator bool() const noexcept { return ec == errc{}; } }; - constexpr from_chars_result from_chars(const char* first, const char* last, + constexpr from_chars_result from_chars(const char* first, const char* last, // freestanding @\placeholder{integer-type}@& value, int base = 10); - from_chars_result from_chars(const char* first, const char* last, @\placeholder{floating-point-type}@& value, + from_chars_result from_chars(const char* first, const char* last, // freestanding-deleted + @\placeholder{floating-point-type}@& value, chars_format fmt = chars_format::general); } \end{codeblock} From a2b23668ccfc6db07a95cfd131fc3321274f6490 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Tue, 27 Jun 2023 16:26:39 +0200 Subject: [PATCH 091/171] P2013R5 Freestanding Language: Optional ::operator new --- source/support.tex | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/source/support.tex b/source/support.tex index 7e17cf0c49..4e7ae5bff6 100644 --- a/source/support.tex +++ b/source/support.tex @@ -2279,6 +2279,25 @@ is not a valid alignment value, the behavior is undefined. +\pnum +On freestanding implementations, +it is \impldef{whether freestanding default replaceable global allocation functions satisfy required behavior} +whether the default versions of the replaceable global allocation functions +satisfy the required behaviors +described in \ref{new.delete.single} and \ref{new.delete.array}. +\begin{note} +A freestanding implementation's default versions of +the replaceable global allocation functions +can cause undefined behavior when invoked. +During constant evaluation, +the behaviors of those default versions are irrelevant, +as those calls are omitted\iref{expr.new}. +\end{note} + +\recommended +If any of the default versions of the replaceable global allocation functions +meet the requirements of a hosted implementation, they all should. + \newcommand{\replaceabledesc}[1]{% A \Cpp{} program may define functions with #1 of these function signatures, and thereby displace the default versions defined by the From 2d7d7669a9bf18a664a66026dd3ee9fea6fe743e Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Wed, 28 Jun 2023 00:29:56 +0200 Subject: [PATCH 092/171] P2363R5 Extending associative containers with the remaining heterogeneous overloads --- source/containers.tex | 440 +++++++++++++++++++++++++++++++++++++++++- source/support.tex | 2 + 2 files changed, 439 insertions(+), 3 deletions(-) diff --git a/source/containers.tex b/source/containers.tex index 4d49855d66..327193c7e9 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -5577,6 +5577,35 @@ Constant. \end{itemdescr} +\indexunordmem{bucket}% +\begin{itemdecl} +a_tran.bucket(ke) +\end{itemdecl} + +\begin{itemdescr} +\pnum +\result +\tcode{size_type} + +\pnum +\expects +\tcode{a_tran.bucket_count() > 0}. + +\pnum +\ensures +The return value is in the range \tcode{[0, a_tran.bucket_count())}. + +\pnum +\returns +The index of the bucket +in which elements with keys equivalent to \tcode{ke} would be found, +if any such element existed. + +\pnum +\complexity +Constant. +\end{itemdescr} + \indexunordmem{bucket_size}% \begin{itemdecl} b.bucket_size(n) @@ -5859,7 +5888,7 @@ \pnum The member function templates \tcode{find}, \tcode{count}, \tcode{equal_range}, \tcode{contains}, -\tcode{extract}, and \tcode{erase} +\tcode{extract}, \tcode{erase}, and \tcode{bucket} shall not participate in overload resolution unless the \grammarterm{qualified-id}s \tcode{Pred::is_transparent} and @@ -9718,8 +9747,11 @@ // \ref{map.access}, element access mapped_type& operator[](const key_type& x); mapped_type& operator[](key_type&& x); + template mapped_type& operator[](K&& x); mapped_type& at(const key_type& x); const mapped_type& at(const key_type& x) const; + template mapped_type& at(const K& x); + template const mapped_type& at(const K& x) const; // \ref{map.modifiers}, modifiers template pair emplace(Args&&... args); @@ -9747,18 +9779,26 @@ pair try_emplace(const key_type& k, Args&&... args); template pair try_emplace(key_type&& k, Args&&... args); + template + pair try_emplace(K&& k, Args&&... args); template iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); template iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); + template + iterator try_emplace(const_iterator hint, K&& k, Args&&... args); template pair insert_or_assign(const key_type& k, M&& obj); template pair insert_or_assign(key_type&& k, M&& obj); + template + pair insert_or_assign(K&& k, M&& obj); template iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); template iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); + template + iterator insert_or_assign(const_iterator hint, K&& k, M&& obj); iterator erase(iterator position); iterator erase(const_iterator position); @@ -9932,6 +9972,22 @@ Equivalent to: \tcode{return try_emplace(std::move(x)).first->second;} \end{itemdescr} +\indexlibrary{\idxcode{operator[]}!\idxcode{map}}% +\begin{itemdecl} +template mapped_type& operator[](K&& x); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +The \grammarterm{qualified-id} \tcode{Compare::is_transparent} +is valid and denotes a type. + +\pnum +\effects +Equivalent to: \tcode{return try_emplace(std::forward(x)).first->second;} +\end{itemdescr} + \indexlibrarymember{at}{map}% \begin{itemdecl} mapped_type& at(const key_type& x); @@ -9953,6 +10009,36 @@ Logarithmic. \end{itemdescr} +\indexlibrarymember{at}{map}% +\begin{itemdecl} +template mapped_type& at(const K& x); +template const mapped_type& at(const K& x) const; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +The \grammarterm{qualified-id} \tcode{Compare::is_transparent} +is valid and denotes a type. + +\pnum +\expects +The expression \tcode{find(x)} is well-formed and has well-defined behavior. + +\pnum +\returns +A reference to \tcode{find(x)->second}. + +\pnum +\throws +An exception object of type \tcode{out_of_range} if +\tcode{find(x) == end()} is \tcode{true}. + +\pnum +\complexity +Logarithmic. +\end{itemdescr} + \rSec3[map.modifiers]{Modifiers} \indexlibrarymember{insert}{map}% @@ -10051,6 +10137,55 @@ respectively. \end{itemdescr} +\indexlibrarymember{try_emplace}{map}% +\begin{itemdecl} +template + pair try_emplace(K&& k, Args&&... args); +template + iterator try_emplace(const_iterator hint, K&& k, Args&&... args); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +The \grammarterm{qualified-id} \tcode{Compare::is_transparent} +is valid and denotes a type. +For the first overload, +\tcode{is_convertible_v} and +\tcode{is_convertible_v} +are both \tcode{false}. + +\pnum +\expects +\tcode{value_type} is \oldconcept{EmplaceConstructible} into \tcode{map} from +\tcode{piecewise_construct, forward_as_tuple(std::forward(k)), +forward_as_tuple(std::forward(args)...)}. + +\pnum +\effects +If the map already contains an element whose key is equivalent to \tcode{k}, +there is no effect. +Otherwise, let \tcode{r} be \tcode{equal_range(k)}. +Constructs an object \tcode{u} of type \tcode{value_type} with +\tcode{piecewise_construct, forward_as_tuple(std::forward(k)), +forward_as_tuple(std::forward(args)...)}.\linebreak +If \tcode{equal_range(u.first) == r} is \tcode{false}, +the behavior is undefined. +Inserts \tcode{u} into \tcode{*this}. + +\pnum +\returns +For the first overload, +the \tcode{bool} component of the returned pair is \tcode{true} +if and only if the insertion took place. +The returned iterator points to the map element +whose key is equivalent to \tcode{k}. + +\pnum +\complexity +The same as \tcode{emplace} and \tcode{emplace_hint}, respectively. +\end{itemdescr} + \indexlibrarymember{insert_or_assign}{map}% \begin{itemdecl} template @@ -10131,6 +10266,54 @@ respectively. \end{itemdescr} +\indexlibrarymember{insert_or_assign}{map}% +\begin{itemdecl} +template + pair insert_or_assign(K&& k, M&& obj); +template + iterator insert_or_assign(const_iterator hint, K&& k, M&& obj); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +The \grammarterm{qualified-id} \tcode{Compare::is_transparent} +is valid and denotes a type. + +\pnum +\mandates +\tcode{is_assignable_v} is \tcode{true}. + +\pnum +\expects +\tcode{value_type} is \oldconcept{EmplaceConstructible} into \tcode{map} from +\tcode{std::forward(k), std::\newline forward(obj)}. + +\pnum +\effects +If the map already contains an element \tcode{e} +whose key is equivalent to \tcode{k}, +assigns \tcode{std::forward\newline (obj)} to \tcode{e.second}. +Otherwise, let \tcode{r} be \tcode{equal_range(k)}. +Constructs an object \tcode{u} of type \tcode{value_type} +with \tcode{std::forward(k), std::forward(obj)}. +If \tcode{equal_range(u.first) == r} is \tcode{false}, +the behavior is undefined. +Inserts \tcode{u} into \tcode{*this}. + +\pnum +\returns +For the first overload, +the \tcode{bool} component of the returned pair is \tcode{true} +if and only if the insertion took place. +The returned iterator points to the map element +whose key is equivalent to \tcode{k}. + +\pnum +\complexity +The same as \tcode{emplace} and \tcode{emplace_hint}, respectively. +\end{itemdescr} + \rSec3[map.erasure]{Erasure} \indexlibrarymember{erase_if}{map}% @@ -10640,13 +10823,15 @@ size_type size() const noexcept; size_type max_size() const noexcept; - // modifiers + // \ref{set.modifiers}, modifiers template pair emplace(Args&&... args); template iterator emplace_hint(const_iterator position, Args&&... args); pair insert(const value_type& x); pair insert(value_type&& x); + template pair insert(K&& x); iterator insert(const_iterator position, const value_type& x); iterator insert(const_iterator position, value_type&& x); + template iterator insert(const_iterator position, K&& x); template void insert(InputIterator first, InputIterator last); template<@\exposconcept{container-compatible-range}@ R> @@ -10832,6 +11017,50 @@ \end{codeblock} \end{itemdescr} +\rSec3[set.modifiers]{Modifiers} + +\indexlibrarymember{insert}{set}% +\begin{itemdecl} +template pair insert(K&& x); +template iterator insert(const_iterator hint, K&& x); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +The \grammarterm{qualified-id} \tcode{Compare::is_transparent} +is valid and denotes a type. +For the second overload, +\tcode{is_convertible_v} and +\tcode{is_convertible_v} are both \tcode{false}. + +\pnum +\expects +\tcode{value_type} is \oldconcept{EmplaceConstructible} into \tcode{set} from +\tcode{std::forward(x)}. + +\pnum +\effects +If the set already contains an element that is equivalent to \tcode{x}, +there is no effect. +Otherwise, let \tcode{r} be \tcode{equal_range(x)}. +Constructs an object \tcode{u} of type \tcode{value_type} +with \tcode{std::forward(x)}. +If \tcode{equal_range(u) == r} is \tcode{false}, the behavior is undefined. +Inserts \tcode{u} into \tcode{*this}. + +\pnum +\returns +For the first overload, +the \tcode{bool} component of the returned pair is true +if and only if the insertion took place. +The returned iterator points to the set element that is equivalent to \tcode{x}. + +\pnum +\complexity +Logarithmic. +\end{itemdescr} + \rSec2[multiset]{Class template \tcode{multiset}} \rSec3[multiset.overview]{Overview} @@ -11464,18 +11693,26 @@ pair try_emplace(const key_type& k, Args&&... args); template pair try_emplace(key_type&& k, Args&&... args); + template + pair try_emplace(K&& k, Args&&... args); template iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); template iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); + template + iterator try_emplace(const_iterator hint, K&& k, Args&&... args); template pair insert_or_assign(const key_type& k, M&& obj); template pair insert_or_assign(key_type&& k, M&& obj); + template + pair insert_or_assign(K&& k, M&& obj); template iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); template iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); + template + iterator insert_or_assign(const_iterator hint, K&& k, M&& obj); iterator erase(iterator position); iterator erase(const_iterator position); @@ -11524,14 +11761,18 @@ // \ref{unord.map.elem}, element access mapped_type& operator[](const key_type& k); mapped_type& operator[](key_type&& k); + template mapped_type& operator[](K&& k); mapped_type& at(const key_type& k); const mapped_type& at(const key_type& k) const; + template mapped_type& at(const K& k); + template const mapped_type& at(const K& k) const; // bucket interface size_type bucket_count() const noexcept; size_type max_bucket_count() const noexcept; size_type bucket_size(size_type n) const; size_type bucket(const key_type& k) const; + template size_type bucket(const K& k) const; local_iterator begin(size_type n); const_local_iterator begin(size_type n) const; local_iterator end(size_type n); @@ -11712,6 +11953,23 @@ Equivalent to: \tcode{return try_emplace(std::move(k)).first->second;} \end{itemdescr} +\indexlibrarymember{unordered_map}{operator[]}% +\indextext{\idxcode{unordered_map}!element access}% +\begin{itemdecl} +template mapped_type& operator[](K&& k); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +The \grammarterm{qualified-id}s \tcode{Hash::is_transparent} and +\tcode{Pred::is_transparent} are valid and denote types. + +\pnum +\effects +Equivalent to: \tcode{return try_emplace(std::forward(k)).first->second;} +\end{itemdescr} + \indexlibrarymember{unordered_map}{at}% \indextext{\idxcode{unordered_map}!element access}% \begin{itemdecl} @@ -11729,6 +11987,33 @@ An exception object of type \tcode{out_of_range} if no such element is present. \end{itemdescr} +\indexlibrarymember{unordered_map}{at}% +\indextext{\idxcode{unordered_map}!element access}% +\begin{itemdecl} +template mapped_type& at(const K& k); +template const mapped_type& at(const K& k) const; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +The \grammarterm{qualified-id}s \tcode{Hash::is_transparent} and +\tcode{Pred::is_transparent} are valid and denote types. + +\pnum +\expects +The expression \tcode{find(k)} is well-formed and has well-defined behavior. + +\pnum +\returns +A reference to \tcode{find(k)->second}. + +\pnum +\throws +An exception object of type \tcode{out_of_range} +if \tcode{find(k) == end()} is \tcode{true}. +\end{itemdescr} + \rSec3[unord.map.modifiers]{Modifiers} \indexlibrarymember{unordered_map}{insert}% @@ -11841,6 +12126,55 @@ respectively. \end{itemdescr} +\indexlibrarymember{try_emplace}{unordered_map}% +\begin{itemdecl} +template + pair try_emplace(K&& k, Args&&... args); +template + iterator try_emplace(const_iterator hint, K&& k, Args&&... args); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +The \grammarterm{qualified-id}s \tcode{Hash::is_transparent} and +\tcode{Pred::is_transparent} are valid and denote types. +For the first overload, +\tcode{is_convertible_v} and +\tcode{is_convertible_v} are both \tcode{false}. + +\pnum +\expects +\tcode{value_type} is \oldconcept{EmplaceConstructible} +into \tcode{unordered_map} from +\tcode{piecewise_construct, forward_as_tuple(std::forward(k)), +forward_as_tuple(std::forward\newline (args)...)}. + +\pnum +\effects +If the map already contains an element whose key is equivalent to \tcode{k}, +there is no effect. +Otherwise, let \tcode{h} be \tcode{hash_function()(k)}. +Constructs an object \tcode{u} of type \tcode{value_type} +with \tcode{piecewise_construct, forward_as_tuple(std::forward(k)), +forward_as_tuple(std::forward(args)...)}.\newline +If \tcode{hash_function()(u.first) != h || contains(u.first)} is \tcode{true}, +the behavior is undefined. +Inserts \tcode{u} into \tcode{*this}. + +\pnum +\returns +For the first overload, +the \tcode{bool} component of the returned pair is \tcode{true} +if and only if the insertion took place. +The returned iterator points to the map element +whose key is equivalent to \tcode{k}. + +\pnum +\complexity +The same as \tcode{emplace} and \tcode{emplace_hint}, respectively. +\end{itemdescr} + \indexlibrarymember{insert_or_assign}{unordered_map}% \begin{itemdecl} template @@ -11921,6 +12255,55 @@ respectively. \end{itemdescr} +\indexlibrarymember{insert_or_assign}{unordered_map}% +\begin{itemdecl} +template + pair insert_or_assign(K&& k, M&& obj); +template + iterator insert_or_assign(const_iterator hint, K&& k, M&& obj); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +The \grammarterm{qualified-id}s \tcode{Hash::is_transparent} and +\tcode{Pred::is_transparent} are valid and denote types. + +\pnum +\mandates +\tcode{is_assignable_v} is \tcode{true}. + +\pnum +\expects +\tcode{value_type} is \oldconcept{EmplaceConstructible} +into \tcode{unordered_map} +from \tcode{std::forward\newline (k), std::forward(obj)}. + +\pnum +\effects +If the map already contains an element \tcode{e} +whose key is equivalent to \tcode{k}, +assigns \tcode{std::forward\newline (obj)} to \tcode{e.second}. +Otherwise, let \tcode{h} be \tcode{hash_function()(k)}. +Constructs an object \tcode{u} of type \tcode{value_type} +with \tcode{std::forward(k), std::forward(obj)}. +If \tcode{hash_function()(u.first) != h || contains(u.first)} is \tcode{true}, +the behavior is undefined. +Inserts \tcode{u} into \tcode{*this}. + +\pnum +\returns +For the first overload, +the \tcode{bool} component of the returned pair is \tcode{true} +if and only if the insertion took place. +The returned iterator points to the map element +whose key is equivalent to \tcode{k}. + +\pnum +\complexity +The same as \tcode{emplace} and \tcode{emplace_hint}, respectively. +\end{itemdescr} + \rSec3[unord.map.erasure]{Erasure} \indexlibrarymember{erase_if}{unordered_map}% @@ -12152,6 +12535,7 @@ size_type max_bucket_count() const noexcept; size_type bucket_size(size_type n) const; size_type bucket(const key_type& k) const; + template size_type bucket(const K& k) const; local_iterator begin(size_type n); const_local_iterator begin(size_type n) const; local_iterator end(size_type n); @@ -12504,13 +12888,15 @@ size_type size() const noexcept; size_type max_size() const noexcept; - // modifiers + // \ref{unord.set.modifiers}, modifiers template pair emplace(Args&&... args); template iterator emplace_hint(const_iterator position, Args&&... args); pair insert(const value_type& obj); pair insert(value_type&& obj); + template pair insert(K&& obj); iterator insert(const_iterator hint, const value_type& obj); iterator insert(const_iterator hint, value_type&& obj); + template iterator insert(const_iterator hint, K&& obj); template void insert(InputIterator first, InputIterator last); template<@\exposconcept{container-compatible-range}@ R> void insert_range(R&& rg); @@ -12572,6 +12958,7 @@ size_type max_bucket_count() const noexcept; size_type bucket_size(size_type n) const; size_type bucket(const key_type& k) const; + template size_type bucket(const K& k) const; local_iterator begin(size_type n); const_local_iterator begin(size_type n) const; local_iterator end(size_type n); @@ -12744,6 +13131,52 @@ \end{codeblock} \end{itemdescr} +\rSec3[unord.set.modifiers]{Modifiers} + +\indexlibrarymember{insert}{unordered_set}% +\begin{itemdecl} +template pair insert(K&& obj); +template iterator insert(const_iterator hint, K&& obj); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +The \grammarterm{qualified-id}s \tcode{Hash::is_transparent} and +\tcode{Pred::is_transparent} are valid and denote types. +For the second overload, +\tcode{is_convertible_v} and +\tcode{is_convertible_v} are both \tcode{false}. + +\pnum +\expects +\tcode{value_type} is \oldconcept{EmplaceConstructible} +into \tcode{unordered_set} from \tcode{std::forward\newline (obj)}. + +\pnum +\effects +If the set already contains an element that is equivalent to \tcode{obj}, +there is no effect. +Otherwise, let \tcode{h} be \tcode{hash_function()(obj)}. +Constructs an object \tcode{u} of type \tcode{value_type} +with \tcode{std::forward(obj)}. +If \tcode{hash_function()(u) != h || contains(u)} is \tcode{true}, +the behavior is undefined. +Inserts \tcode{u} into \tcode{*this}. + +\pnum +\returns +For the first overload, +the \tcode{bool} component of the returned pair is \tcode{true} +if and only if the insertion took place. +The returned iterator points to the set element +that is equivalent to \tcode{obj}. + +\pnum +\complexity +Average case constant, worst case linear. +\end{itemdescr} + \rSec2[unord.multiset]{Class template \tcode{unordered_multiset}}% \indexlibraryglobal{unordered_multiset} @@ -12946,6 +13379,7 @@ size_type max_bucket_count() const noexcept; size_type bucket_size(size_type n) const; size_type bucket(const key_type& k) const; + template size_type bucket(const K& k) const; local_iterator begin(size_type n); const_local_iterator begin(size_type n) const; local_iterator end(size_type n); diff --git a/source/support.tex b/source/support.tex index 4e7ae5bff6..50c7b092a9 100644 --- a/source/support.tex +++ b/source/support.tex @@ -564,6 +564,8 @@ #define @\defnlibxname{cpp_lib_as_const}@ 201510L // freestanding, also in \libheader{utility} #define @\defnlibxname{cpp_lib_associative_heterogeneous_erasure}@ 202110L // also in \libheader{map}, \libheader{set}, \libheader{unordered_map}, \libheader{unordered_set} +#define @\defnlibxname{cpp_lib_associative_heterogeneous_insertion}@ 202306L + // also in \libheader{map}, \libheader{set}, \libheader{unordered_map}, \libheader{unordered_set} #define @\defnlibxname{cpp_lib_assume_aligned}@ 201811L // freestanding, also in \libheader{memory} #define @\defnlibxname{cpp_lib_atomic_flag_test}@ 201907L // freestanding, also in \libheader{atomic} #define @\defnlibxname{cpp_lib_atomic_float}@ 201711L // freestanding, also in \libheader{atomic} From 97049c4746685aedd64ba047885aa7537e777a34 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 27 Jun 2023 16:54:35 -0700 Subject: [PATCH 093/171] P1901R2 Enabling the Use of weak_ptr as Keys in Unordered Associative Containers --- source/memory.tex | 196 +++++++++++++++++++++++++++++++++++++++++---- source/support.tex | 1 + 2 files changed, 181 insertions(+), 16 deletions(-) diff --git a/source/memory.tex b/source/memory.tex index 4b01ba4006..253e2217ca 100644 --- a/source/memory.tex +++ b/source/memory.tex @@ -551,6 +551,12 @@ // \ref{util.smartptr.ownerless}, class template \tcode{owner_less} template struct owner_less; + // \ref{util.smartptr.owner.hash}, struct \tcode{owner_hash} + struct owner_hash; + + // \ref{util.smartptr.owner.equal}, struct \tcode{owner_equal} + struct owner_equal; + // \ref{util.smartptr.enab}, class template \tcode{enable_shared_from_this} template class enable_shared_from_this; @@ -3227,6 +3233,11 @@ bool owner_before(const shared_ptr& b) const noexcept; template bool owner_before(const weak_ptr& b) const noexcept; + size_t owner_hash() const noexcept; + template + bool owner_equal(const shared_ptr& b) const noexcept; + template + bool owner_equal(const weak_ptr& b) const noexcept; }; template @@ -3833,14 +3844,45 @@ \returns An unspecified value such that \begin{itemize} -\item \tcode{x.owner_before(y)} defines a strict weak ordering as defined in~\ref{alg.sorting}; - -\item under the equivalence relation defined by \tcode{owner_before}, -\tcode{!a.owner_before(b) \&\& !b.owner_before(a)}, two \tcode{shared_ptr} or -\tcode{weak_ptr} instances are equivalent if and only if they share ownership or -are both empty. +\item +\tcode{owner_before(b)} defines a strict weak ordering as defined in~\ref{alg.sorting}; +\item +\tcode{!owner_before(b) \&\& !b.owner_before(*this)} is \tcode{true} +if and only if \tcode{owner_equal(b)} is \tcode{true}. \end{itemize} +\end{itemdescr} + +\indexlibrarymember{owner_hash}{shared_ptr}% +\begin{itemdecl} +size_t owner_hash() const noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\returns +An unspecified value such that, +for any object \tcode{x} where \tcode{owner_equal(x)} is \tcode{true}, +\tcode{owner_hash() == x.owner_hash()} is \tcode{true}. +\end{itemdescr} + +\indexlibrarymember{owner_equal}{shared_ptr}% +\begin{itemdecl} +template + bool owner_equal(const shared_ptr& b) const noexcept; +template + bool owner_equal(const weak_ptr& b) const noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\returns +\tcode{true} if and only if +\tcode{*this} and \tcode{b} share ownership or are both empty. +Otherwise returns \tcode{false}. +\pnum +\remarks +\tcode{owner_equal} is an equivalence relation. \end{itemdescr} \rSec4[util.smartptr.shared.create]{Creation} @@ -4511,6 +4553,11 @@ bool owner_before(const shared_ptr& b) const noexcept; template bool owner_before(const weak_ptr& b) const noexcept; + size_t owner_hash() const noexcept; + template + bool owner_equal(const shared_ptr& b) const noexcept; + template + bool owner_equal(const weak_ptr& b) const noexcept; }; template @@ -4711,15 +4758,45 @@ \returns An unspecified value such that \begin{itemize} -\item \tcode{x.owner_before(y)} defines a strict weak ordering as defined in~\ref{alg.sorting}; +\item \tcode{owner_before(b)} defines a strict weak ordering as defined in~\ref{alg.sorting}; -\item under the equivalence relation defined by \tcode{owner_before}, -\tcode{!a.owner_before(b) \&\& !b.owner_before(a)}, two \tcode{shared_ptr} or -\tcode{weak_ptr} instances are equivalent if and only if they share ownership or are -both empty. +\item \tcode{!owner_before(b) \&\& !b.owner_before(*this)} is \tcode{true} +if and only if \tcode{owner_equal(b)} is \tcode{true}. \end{itemize} \end{itemdescr} +\indexlibrarymember{owner_hash}{weak_ptr}% +\begin{itemdecl} +size_t owner_hash() const noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\returns +An unspecified value such that, +for any object \tcode{x} where \tcode{owner_equal(x)} is \tcode{true}, +\tcode{owner_hash() == x.owner_hash()} is \tcode{true}. +\end{itemdescr} + +\indexlibrarymember{owner_equal}{weak_ptr}% +\begin{itemdecl} +template + bool owner_equal(const shared_ptr& b) const noexcept; +template + bool owner_equal(const weak_ptr& b) const noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\returns +\tcode{true} if and only if +\tcode{*this} and \tcode{b} share ownership or are both empty. +Otherwise returns \tcode{false}. + +\pnum +\remarks +\tcode{owner_equal} is an equivalence relation. +\end{itemdescr} \rSec4[util.smartptr.weak.spec]{Specialized algorithms} @@ -4782,13 +4859,100 @@ \item \tcode{operator()} defines a strict weak ordering as defined in~\ref{alg.sorting}; \item -two \tcode{shared_ptr} or \tcode{weak_ptr} instances are equivalent -under the equivalence relation defined by \tcode{operator()}, -\tcode{!operator()(a, b) \&\& !operator()(b, a)}, -if and only if they share ownership or are both empty. +\tcode{!operator()(a, b) \&\& !operator()(b, a)} is \tcode{true} +if and only if \tcode{a.owner_equal(b)} is \tcode{true}. \end{itemize} \end{note} +\rSec3[util.smartptr.owner.hash]{Class \tcode{owner_hash}} + +\pnum +The class \tcode{owner_hash} provides ownership-based hashing. + +\indexlibraryglobal{owner_hash}% +\begin{codeblock} +namespace std { + struct owner_hash { + template + size_t operator()(const shared_ptr&) const noexcept; + + template + size_t operator()(const weak_ptr&) const noexcept; + + using is_transparent = @\unspec@; + }; +} +\end{codeblock} + +\indexlibrarymember{operator()}{owner_hash}% +\begin{itemdecl} +template + size_t operator()(const shared_ptr& x) const noexcept; +template + size_t operator()(const weak_ptr& x) const noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\returns +\tcode{x.owner_hash()}. + +\pnum +\begin{note} +For any object \tcode{y} where \tcode{x.owner_equal(y)} is \tcode{true}, +\tcode{x.owner_hash() == y.owner_hash()} is \tcode{true}. +\end{note} +\end{itemdescr} + +\rSec3[util.smartptr.owner.equal]{Class \tcode{owner_equal}} + +\pnum +The class \tcode{owner_equal} provides +ownership-based mixed equality comparisons of shared and weak pointers. + +\indexlibraryglobal{owner_equal}% +\begin{codeblock} +namespace std { + struct owner_equal { + template + bool operator()(const shared_ptr&, const shared_ptr&) const noexcept; + template + bool operator()(const shared_ptr&, const weak_ptr&) const noexcept; + template + bool operator()(const weak_ptr&, const shared_ptr&) const noexcept; + template + bool operator()(const weak_ptr&, const weak_ptr&) const noexcept; + + using is_transparent = @\unspec@; + }; +} +\end{codeblock} + +\indexlibrarymember{operator()}{owner_equal}% +\begin{itemdecl} +template + bool operator()(const shared_ptr& x, const shared_ptr& y) const noexcept; +template + bool operator()(const shared_ptr& x, const weak_ptr& y) const noexcept; +template + bool operator()(const weak_ptr& x, const shared_ptr& y) const noexcept; +template + bool operator()(const weak_ptr& x, const weak_ptr& y) const noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\returns +\tcode{x.owner_equal(y)}. + +\pnum +\begin{note} +\tcode{x.owner_equal(y)} is \tcode{true} +%FIXME: Who are "they"? +if and only if they share ownership or are both empty. +\end{note} +\end{itemdescr} + \rSec3[util.smartptr.enab]{Class template \tcode{enable_shared_from_this}} \pnum @@ -4806,7 +4970,7 @@ shared_ptr p(new X); shared_ptr q = p->shared_from_this(); assert(p == q); - assert(!p.owner_before(q) && !q.owner_before(p)); // p and q share ownership + assert(p.owner_equal(q)); // \tcode{p} and \tcode{q} share ownership } \end{codeblock} \end{example} diff --git a/source/support.tex b/source/support.tex index 50c7b092a9..2d0eeb569c 100644 --- a/source/support.tex +++ b/source/support.tex @@ -742,6 +742,7 @@ #define @\defnlibxname{cpp_lib_shared_ptr_weak_type}@ 201606L // also in \libheader{memory} #define @\defnlibxname{cpp_lib_shared_timed_mutex}@ 201402L // also in \libheader{shared_mutex} #define @\defnlibxname{cpp_lib_shift}@ 202202L // also in \libheader{algorithm} +#define @\defnlibxname{cpp_lib_smart_pointer_owner_equality}@ 202306L // also in \libheader{memory} #define @\defnlibxname{cpp_lib_smart_ptr_for_overwrite}@ 202002L // also in \libheader{memory} #define @\defnlibxname{cpp_lib_source_location}@ 201907L // freestanding, also in \libheader{source_location} #define @\defnlibxname{cpp_lib_span}@ 202002L // also in \libheader{span} From ed3e51ecd1dbdafc0d34fa18e4179e09c44ea1be Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 4 Jul 2023 12:56:38 -0700 Subject: [PATCH 094/171] [util.smartptr.owner.{hash,equal}] Make section name match synopsis. --- source/memory.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/memory.tex b/source/memory.tex index 253e2217ca..8839d4f4ca 100644 --- a/source/memory.tex +++ b/source/memory.tex @@ -4864,7 +4864,7 @@ \end{itemize} \end{note} -\rSec3[util.smartptr.owner.hash]{Class \tcode{owner_hash}} +\rSec3[util.smartptr.owner.hash]{Struct \tcode{owner_hash}} \pnum The class \tcode{owner_hash} provides ownership-based hashing. @@ -4904,7 +4904,7 @@ \end{note} \end{itemdescr} -\rSec3[util.smartptr.owner.equal]{Class \tcode{owner_equal}} +\rSec3[util.smartptr.owner.equal]{Struct \tcode{owner_equal}} \pnum The class \tcode{owner_equal} provides From 1954f1beaf2e933764f92b51ee63af6007ddf06f Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 4 Jul 2023 12:58:08 -0700 Subject: [PATCH 095/171] [util.smartptr.owner.equal] Clarify that "they" are "x and y". --- source/memory.tex | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/source/memory.tex b/source/memory.tex index 8839d4f4ca..a6cde5dbf2 100644 --- a/source/memory.tex +++ b/source/memory.tex @@ -4948,8 +4948,7 @@ \pnum \begin{note} \tcode{x.owner_equal(y)} is \tcode{true} -%FIXME: Who are "they"? -if and only if they share ownership or are both empty. +if and only if \tcode{x} and \tcode{y} share ownership or are both empty. \end{note} \end{itemdescr} From ad1e088014d7fa54aee4127eaf49f0c42dc839d0 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 27 Jun 2023 14:21:57 -0700 Subject: [PATCH 096/171] P1885R12 Naming Text Encodings to Demystify Them Editorial notes: - [text.*] Minor changes were made for consistency with existing text. - [text.encoding.overview] Fix reference for "trivially copyable type". - [text.encoding.hash] Make section match synopsis; remove stray declaration. --- source/back.tex | 8 + source/lib-intro.tex | 7 +- source/locales.tex | 735 ++++++++++++++++++++++++++++++++++++++++++- source/support.tex | 1 + 4 files changed, 747 insertions(+), 4 deletions(-) diff --git a/source/back.tex b/source/back.tex index 055fb32146..c11c841111 100644 --- a/source/back.tex +++ b/source/back.tex @@ -18,6 +18,14 @@ \chapter{Bibliography} Programming languages, their environments, and system software interfaces --- Floating-point extensions for C --- Part 3: Interchange and extended types} % Other international standards. +\item + IANA Character Sets Database. + Available from:\newline + \url{https://www.iana.org/assignments/character-sets/}, 2021-04-01 +\item + Unicode Character Mapping Markup Language [online]. + Edited by Mark Davis and Markus Scherer. Revision 5.0.1; 2017-05-31 + Available from: \url{http://www.unicode.org/reports/tr22/tr22-8.html} \item IANA Time Zone Database. Available from: \url{https://www.iana.org/time-zones} diff --git a/source/lib-intro.tex b/source/lib-intro.tex index b774ca2f1a..4b9e59445a 100644 --- a/source/lib-intro.tex +++ b/source/lib-intro.tex @@ -1093,8 +1093,8 @@ \tcode{} \\ \tcode{} \\ \tcode{} \\ -\columnbreak \tcode{} \\ +\columnbreak \tcode{} \\ \tcode{} \\ \tcode{} \\ @@ -1116,8 +1116,8 @@ \tcode{} \\ \tcode{} \\ \tcode{} \\ -\columnbreak \tcode{} \\ +\columnbreak \tcode{} \\ \tcode{} \\ \tcode{} \\ @@ -1140,8 +1140,8 @@ \tcode{} \\ \tcode{} \\ \tcode{} \\ -\columnbreak \tcode{} \\ +\columnbreak \tcode{} \\ \tcode{} \\ \tcode{} \\ @@ -1150,6 +1150,7 @@ \tcode{} \\ \tcode{} \\ \tcode{} \\ +\tcode{} \\ \tcode{} \\ \tcode{} \\ \tcode{} \\ diff --git a/source/locales.tex b/source/locales.tex index 4b6e0376e0..f9b9efa791 100644 --- a/source/locales.tex +++ b/source/locales.tex @@ -22,7 +22,8 @@ \begin{libsumtab}{Localization library summary}{localization.summary} \ref{locales} & Locales & \tcode{} \\ \ref{locale.categories} & Standard \tcode{locale} categories & \\ \rowsep -\ref{c.locales} & C library locales & \tcode{} \\ +\ref{c.locales} & C library locales & \tcode{} \\ \rowsep +\ref{text.encoding} & Text encodings identification & \tcode{} \\ \end{libsumtab} \rSec1[locale.syn]{Header \tcode{} synopsis} @@ -148,6 +149,7 @@ // locale operations string name() const; + text_encoding encoding() const; bool operator==(const locale& other) const; @@ -691,6 +693,23 @@ otherwise, the string \tcode{"*"}. \end{itemdescr} +\indexlibrarymember{locale}{encoding}% +\begin{itemdecl} +text_encoding encoding() const; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\mandates +\tcode{CHAR_BIT == 8} is \tcode{true}. + +\pnum +\returns +A \tcode{text_encoding} object representing +the implementation-defined encoding scheme +associated with the locale \tcode{*this}. +\end{itemdescr} + \rSec3[locale.operators]{Operators} \indexlibrarymember{locale}{operator==}% @@ -4632,3 +4651,717 @@ \tcode{strxfrm} & \tcode{wctomb} \\ \end{floattable} + +\rSec1[text.encoding]{Text encodings identification} + +\rSec2[text.encoding.syn]{Header \tcode{} synopsis} + +\indexheader{text_encoding}% +\begin{codeblock} +namespace std { + struct text_encoding; + + // \ref{text.encoding.hash}, hash support + template struct hash; + template<> struct hash; +} +\end{codeblock} + +\rSec2[text.encoding.class]{Class \tcode{text_encoding}} + +\rSec3[text.encoding.overview]{Overview} + +\pnum +The class \tcode{text_encoding} describes an interface +for accessing the IANA Character Sets registry. + +\indexlibraryglobal{text_encoding}% +\begin{codeblock} +namespace std { + struct text_encoding { + static constexpr size_t max_name_length = 63; + + // \ref{text.encoding.id}, enumeration \tcode{text_encoding::id} + enum class id : int_least32_t { + @\seebelow@ + }; + using enum id; + + constexpr text_encoding() = default; + constexpr explicit text_encoding(string_view enc) noexcept; + constexpr text_encoding(id i) noexcept; + + constexpr id mib() const noexcept; + constexpr const char* name() const noexcept; + + struct aliases_view; + constexpr aliases_view aliases() const noexcept; + + friend constexpr bool operator==(const text_encoding& encoding, + const text_encoding& other) noexcept; + friend constexpr bool operator==(const text_encoding& encoding, id i) noexcept; + + static consteval text_encoding literal() noexcept; + static text_encoding environment(); + template static bool environment_is(); + + private: + id @\exposid{mib_}@ = id::unknown; // \expos + char @\exposid{name_}@[max_name_length + 1] = {0}; // \expos + static constexpr bool @\exposidnc{comp-name}@(string_view a, string_view b); // \expos + }; +} +\end{codeblock} + +\pnum +Class \tcode{text_encoding} is +a trivially copyable type\iref{term.trivially.copyable.type}. + +\rSec3[text.encoding.general]{General} + +\pnum +A \defnadj{registered character}{encoding} is +a character encoding scheme in the IANA Character Sets registry. +\begin{note} +The IANA Character Sets registry uses the term ``character sets'' +to refer to character encodings. +\end{note} +The primary name of a registered character encoding is +the name of that encoding specified in the IANA Character Sets registry. + +\pnum +The set of known registered character encodings contains +every registered character encoding +specified in the IANA Character Sets registry except for the following: +\begin{itemize} +\item NATS-DANO (33) +\item NATS-DANO-ADD (34) +\end{itemize} + +\pnum +Each known registered character encoding +is identified by an enumerator in \tcode{text_encoding::id}, and +has a set of zero or more \defnx{aliases}{encoding!registered character!alias}. + +\pnum +The set of aliases of a known registered character encoding is an +\impldef{set of aliases of a known registered character encoding} +superset of the aliases specified in the IANA Character Sets registry. +No two aliases or primary names of distinct registered character encodings +are equivalent when compared by \tcode{text_encoding::\exposid{comp-name}}. + +\pnum +How a \tcode{text_encoding} object +is determined to be representative of a character encoding scheme +implemented in the translation or execution environment is +\impldef{how \tcode{text_encoding} objects are +determined to be representative of a character encoding scheme}. + +\pnum +An object \tcode{e} of type \tcode{text_encoding} such that +\tcode{e.mib() == text_encoding::id::unknown} is \tcode{false} and +\tcode{e.mib() == text_encoding::id::other} is \tcode{false} +maintains the following invariants: +\begin{itemize} +\item \tcode{e.name() == nullptr} is \tcode{false}, and +\item \tcode{e.mib() == text_encoding(e.name()).mib()} is \tcode{true}. +\end{itemize} + +\pnum +\recommended +\begin{itemize} +\item +Implementations should not consider registered encodings to be interchangeable. +\begin{example} +Shift_JIS and Windows-31J denote different encodings. +\end{example} +\item +Implementations should not use the name of a registered encoding +to describe another similar yet different non-registered encoding +unless there is a precedent on that implementation. +\begin{example} +Big5 +\end{example} +\end{itemize} + +\rSec3[text.encoding.members]{Members} + +\indexlibraryctor{text_encoding}% +\begin{itemdecl} +constexpr explicit text_encoding(string_view enc) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\expects +\begin{itemize} +\item +\tcode{enc} represents a string in the ordinary literal encoding +consisting only of elements of the basic character set\iref{lex.charset}. +\item +\tcode{enc.size() <= max_name_length} is \tcode{true}. +\item +\tcode{enc.contains('\textbackslash 0')} is \tcode{false}. +\end{itemize} + +\pnum +\ensures +\begin{itemize} +\item +If there exists a primary name or alias \tcode{a} +of a known registered character encoding such that +\tcode{\exposid{comp-name}(a, enc)} is \tcode{true}, +\exposid{mib_} has the value of the enumerator of \tcode{id} +associated with that registered character encoding. +Otherwise, \tcode{\exposid{mib_} == id::other} is \tcode{true}. +\item +\tcode{enc.compare(\exposid{name_}) == 0} is \tcode{true}. +\end{itemize} +\end{itemdescr} + +\indexlibraryctor{text_encoding}% +\begin{itemdecl} +constexpr text_encoding(id i) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\expects +\tcode{i} has the value of one of the enumerators of \tcode{id}. + +\pnum +\ensures +\begin{itemize} +\item +\tcode{\exposid{mib_} == i} is \tcode{true}. +\item +If \tcode{(\exposid{mib_} == id::unknown || \exposid{mib_} == id::other)} +is \tcode{true}, +\tcode{strlen(\exposid{name_}) == 0} is \tcode{true}. +Otherwise, +\tcode{ranges::contains(aliases(), string_view(\exposid{name_}))} +is \tcode{true}. +\end{itemize} +\end{itemdescr} + +\indexlibrarymember{mib}{text_encoding}% +\begin{itemdecl} +constexpr id mib() const noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\returns +\tcode{\exposid{mib_}}. +\end{itemdescr} + +\indexlibrarymember{name}{text_encoding}% +\begin{itemdecl} +constexpr const char* name() const noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\returns +\tcode{\exposid{name_}} if \tcode{(\exposid{name_}[0] != '\textbackslash 0')} +is \tcode{true}, and +\keyword{nullptr} otherwise. + +\pnum +\remarks +If \tcode{name() == nullptr} is \tcode{false}, +\tcode{name()} is an \ntbs{} and +accessing elements of \tcode{\exposid{name_}} +outside of the range \countedrange{name()}{strlen(name()) + 1} +is undefined behavior. +\end{itemdescr} + +\indexlibrarymember{aliases}{text_encoding}% +\begin{itemdecl} +constexpr aliases_view aliases() const noexcept; +\end{itemdecl} + +\begin{itemdescr} +Let \tcode{r} denote an instance of \tcode{aliases_view}. +If \tcode{*this} represents a known registered character encoding, then: +\begin{itemize} +\item +\tcode{r.front()} is the primary name of the registered character encoding, +\item +\tcode{r} contains the aliases of the registered character encoding, and +\item +\tcode{r} does not contain duplicate values when compared with \tcode{strcmp}. +\end{itemize} +Otherwise, \tcode{r} is an empty range. + +\pnum +Each element in \tcode{r} +is a non-null, non-empty \ntbs{} encoded in the literal character encoding and +comprising only characters from the basic character set. + +\pnum +\returns +\tcode{r}. + +\pnum +\begin{note} +The order of aliases in \tcode{r} is unspecified. +\end{note} +\end{itemdescr} + +\indexlibrarymember{literal}{text_encoding}% +\begin{itemdecl} +static consteval text_encoding literal() noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\mandates +\tcode{CHAR_BIT == 8} is \tcode{true}. + +\pnum +\returns +A \tcode{text_encoding} object representing +the ordinary character literal encoding\iref{lex.charset}. +\end{itemdescr} + +\indexlibrarymember{environment}{text_encoding}% +\begin{itemdecl} +static text_encoding environment(); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\mandates +\tcode{CHAR_BIT == 8} is \tcode{true}. + +\pnum +\returns +A \tcode{text_encoding} object representing +the \impldef{character encoding scheme of the environment} +character encoding scheme of the environment. +On a POSIX implementation, this is the encoding scheme associated with +the POSIX locale denoted by the empty string \tcode{""}. + +\pnum +\begin{note} +This function is not affected by calls to \tcode{setlocale}. +\end{note} + +\pnum +\recommended +Implementations should return a value that is not affected by calls to +the POSIX function \tcode{setenv} and +other functions which can modify the environment\iref{support.runtime}. +\end{itemdescr} + +\indexlibrarymember{environment_is}{text_encoding}% +\begin{itemdecl} +template + static bool environment_is(); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\mandates +\tcode{CHAR_BIT == 8} is \tcode{true}. + +\pnum +\returns +\tcode{environment() == i}. +\end{itemdescr} + +\indexlibrarymember{\exposid{comp-name}}{text_encoding}% +\begin{itemdecl} +static constexpr bool @\exposid{comp-name}@(string_view a, string_view b); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\returns +\tcode{true} if the two strings \tcode{a} and \tcode{b} +encoded in the ordinary literal encoding +are equal, ignoring, from left-to-right, +\begin{itemize} +\item +all elements that are not digits or letters\iref{character.seq.general}, +\item +character case, and +\item +any sequence of one or more \tcode{0} characters +not immediately preceded by a numeric prefix, where +a numeric prefix is a sequence consisting of +a digit in the range \crange{1}{9} +optionally followed by one or more elements which are not digits or letters, +\end{itemize} +and \tcode{false} otherwise. + +\begin{note} +This comparison is identical to +the ``Charset Alias Matching'' algorithm +described in the Unicode Technical Standard 22. +\end{note} + +\begin{example} +\begin{codeblock} +assert(@\exposid{comp-name}@("UTF-8", "utf8") == true); +assert(@\exposid{comp-name}@("u.t.f-008", "utf8") == true); +assert(@\exposid{comp-name}@("ut8", "utf8") == false); +assert(@\exposid{comp-name}@("utf-80", "utf8") == false); +\end{codeblock} +\end{example} +\end{itemdescr} + +\rSec3[text.encoding.cmp]{Comparison functions} + +\indexlibrarymember{operator==}{text_encoding}% +\begin{itemdecl} +friend constexpr bool operator==(const text_encoding& a, const text_encoding& b) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\returns +If \tcode{a.\exposid{mib_} == id::other \&\& b.\exposid{mib_} == id::other} +is \tcode{true}, +then \tcode{\exposid{comp-name}(a.\exposid{name_},\linebreak{}b.\exposid{name_})}. +Otherwise, \tcode{a.\exposid{mib_} == b.\exposid{mib_}}. +\end{itemdescr} + +\indexlibrarymember{operator==}{text_encoding}% +\begin{itemdecl} +friend constexpr bool operator==(const text_encoding& encoding, id i) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\returns +\tcode{encoding.\exposid{mib_} == i}. + +\pnum +\remarks +This operator induces an equivalence relation on its arguments +if and only if \tcode{i != id::other} is \tcode{true}. +\end{itemdescr} + +\rSec3[text.encoding.aliases]{Class text_encoding::aliases_view} + +\indexlibrarymember{aliases_view}{text_encoding}% +\indexlibrarymember{begin}{text_encoding::aliases_view}% +\indexlibrarymember{end}{text_encoding::aliases_view}% +\begin{itemdecl} +struct text_encoding::aliases_view : ranges::view_interface { + constexpr @\impdefx{type of \tcode{text_encoding::aliases_view::begin()}}@ begin() const; + constexpr @\impdefx{type of \tcode{text_encoding::aliases_view::end()}}@ end() const; +}; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\tcode{text_encoding::aliases_view} models +\libconcept{copyable}, +\tcode{ranges::\libconcept{view}}, +\tcode{ranges::\libconcept{random_access_range}}, and +\tcode{ranges::\libconcept{borrowed_range}}. + +\pnum +Both +\tcode{ranges::range_value_t} and +\tcode{ranges::range_reference_t} +denote \tcode{const char*}. +\end{itemdescr} + +\rSec3[text.encoding.id]{Enumeration \tcode{text_encoding::id}} + +\indexlibrarymember{id}{text_encoding}% +\begin{codeblock} +namespace std { + enum class text_encoding::id : int_least32_t { + other = 1, + unknown = 2, + ASCII = 3, + ISOLatin1 = 4, + ISOLatin2 = 5, + ISOLatin3 = 6, + ISOLatin4 = 7, + ISOLatinCyrillic = 8, + ISOLatinArabic = 9, + ISOLatinGreek = 10, + ISOLatinHebrew = 11, + ISOLatin5 = 12, + ISOLatin6 = 13, + ISOTextComm = 14, + HalfWidthKatakana = 15, + JISEncoding = 16, + ShiftJIS = 17, + EUCPkdFmtJapanese = 18, + EUCFixWidJapanese = 19, + ISO4UnitedKingdom = 20, + ISO11SwedishForNames = 21, + ISO15Italian = 22, + ISO17Spanish = 23, + ISO21German = 24, + ISO60DanishNorwegian = 25, + ISO69French = 26, + ISO10646UTF1 = 27, + ISO646basic1983 = 28, + INVARIANT = 29, + ISO2IntlRefVersion = 30, + NATSSEFI = 31, + NATSSEFIADD = 32, + ISO10Swedish = 35, + KSC56011987 = 36, + ISO2022KR = 37, + EUCKR = 38, + ISO2022JP = 39, + ISO2022JP2 = 40, + ISO13JISC6220jp = 41, + ISO14JISC6220ro = 42, + ISO16Portuguese = 43, + ISO18Greek7Old = 44, + ISO19LatinGreek = 45, + ISO25French = 46, + ISO27LatinGreek1 = 47, + ISO5427Cyrillic = 48, + ISO42JISC62261978 = 49, + ISO47BSViewdata = 50, + ISO49INIS = 51, + ISO50INIS8 = 52, + ISO51INISCyrillic = 53, + ISO54271981 = 54, + ISO5428Greek = 55, + ISO57GB1988 = 56, + ISO58GB231280 = 57, + ISO61Norwegian2 = 58, + ISO70VideotexSupp1 = 59, + ISO84Portuguese2 = 60, + ISO85Spanish2 = 61, + ISO86Hungarian = 62, + ISO87JISX0208 = 63, + ISO88Greek7 = 64, + ISO89ASMO449 = 65, + ISO90 = 66, + ISO91JISC62291984a = 67, + ISO92JISC62991984b = 68, + ISO93JIS62291984badd = 69, + ISO94JIS62291984hand = 70, + ISO95JIS62291984handadd = 71, + ISO96JISC62291984kana = 72, + ISO2033 = 73, + ISO99NAPLPS = 74, + ISO102T617bit = 75, + ISO103T618bit = 76, + ISO111ECMACyrillic = 77, + ISO121Canadian1 = 78, + ISO122Canadian2 = 79, + ISO123CSAZ24341985gr = 80, + ISO88596E = 81, + ISO88596I = 82, + ISO128T101G2 = 83, + ISO88598E = 84, + ISO88598I = 85, + ISO139CSN369103 = 86, + ISO141JUSIB1002 = 87, + ISO143IECP271 = 88, + ISO146Serbian = 89, + ISO147Macedonian = 90, + ISO150 = 91, + ISO151Cuba = 92, + ISO6937Add = 93, + ISO153GOST1976874 = 94, + ISO8859Supp = 95, + ISO10367Box = 96, + ISO158Lap = 97, + ISO159JISX02121990 = 98, + ISO646Danish = 99, + USDK = 100, + DKUS = 101, + KSC5636 = 102, + Unicode11UTF7 = 103, + ISO2022CN = 104, + ISO2022CNEXT = 105, + UTF8 = 106, + ISO885913 = 109, + ISO885914 = 110, + ISO885915 = 111, + ISO885916 = 112, + GBK = 113, + GB18030 = 114, + OSDEBCDICDF0415 = 115, + OSDEBCDICDF03IRV = 116, + OSDEBCDICDF041 = 117, + ISO115481 = 118, + KZ1048 = 119, + UCS2 = 1000, + UCS4 = 1001, + UnicodeASCII = 1002, + UnicodeLatin1 = 1003, + UnicodeJapanese = 1004, + UnicodeIBM1261 = 1005, + UnicodeIBM1268 = 1006, + UnicodeIBM1276 = 1007, + UnicodeIBM1264 = 1008, + UnicodeIBM1265 = 1009, + Unicode11 = 1010, + SCSU = 1011, + UTF7 = 1012, + UTF16BE = 1013, + UTF16LE = 1014, + UTF16 = 1015, + CESU8 = 1016, + UTF32 = 1017, + UTF32BE = 1018, + UTF32LE = 1019, + BOCU1 = 1020, + UTF7IMAP = 1021, + Windows30Latin1 = 2000, + Windows31Latin1 = 2001, + Windows31Latin2 = 2002, + Windows31Latin5 = 2003, + HPRoman8 = 2004, + AdobeStandardEncoding = 2005, + VenturaUS = 2006, + VenturaInternational = 2007, + DECMCS = 2008, + PC850Multilingual = 2009, + PC8DanishNorwegian = 2012, + PC862LatinHebrew = 2013, + PC8Turkish = 2014, + IBMSymbols = 2015, + IBMThai = 2016, + HPLegal = 2017, + HPPiFont = 2018, + HPMath8 = 2019, + HPPSMath = 2020, + HPDesktop = 2021, + VenturaMath = 2022, + MicrosoftPublishing = 2023, + Windows31J = 2024, + GB2312 = 2025, + Big5 = 2026, + Macintosh = 2027, + IBM037 = 2028, + IBM038 = 2029, + IBM273 = 2030, + IBM274 = 2031, + IBM275 = 2032, + IBM277 = 2033, + IBM278 = 2034, + IBM280 = 2035, + IBM281 = 2036, + IBM284 = 2037, + IBM285 = 2038, + IBM290 = 2039, + IBM297 = 2040, + IBM420 = 2041, + IBM423 = 2042, + IBM424 = 2043, + PC8CodePage437 = 2011, + IBM500 = 2044, + IBM851 = 2045, + PCp852 = 2010, + IBM855 = 2046, + IBM857 = 2047, + IBM860 = 2048, + IBM861 = 2049, + IBM863 = 2050, + IBM864 = 2051, + IBM865 = 2052, + IBM868 = 2053, + IBM869 = 2054, + IBM870 = 2055, + IBM871 = 2056, + IBM880 = 2057, + IBM891 = 2058, + IBM903 = 2059, + IBM904 = 2060, + IBM905 = 2061, + IBM918 = 2062, + IBM1026 = 2063, + IBMEBCDICATDE = 2064, + EBCDICATDEA = 2065, + EBCDICCAFR = 2066, + EBCDICDKNO = 2067, + EBCDICDKNOA = 2068, + EBCDICFISE = 2069, + EBCDICFISEA = 2070, + EBCDICFR = 2071, + EBCDICIT = 2072, + EBCDICPT = 2073, + EBCDICES = 2074, + EBCDICESA = 2075, + EBCDICESS = 2076, + EBCDICUK = 2077, + EBCDICUS = 2078, + Unknown8BiT = 2079, + Mnemonic = 2080, + Mnem = 2081, + VISCII = 2082, + VIQR = 2083, + KOI8R = 2084, + HZGB2312 = 2085, + IBM866 = 2086, + PC775Baltic = 2087, + KOI8U = 2088, + IBM00858 = 2089, + IBM00924 = 2090, + IBM01140 = 2091, + IBM01141 = 2092, + IBM01142 = 2093, + IBM01143 = 2094, + IBM01144 = 2095, + IBM01145 = 2096, + IBM01146 = 2097, + IBM01147 = 2098, + IBM01148 = 2099, + IBM01149 = 2100, + Big5HKSCS = 2101, + IBM1047 = 2102, + PTCP154 = 2103, + Amiga1251 = 2104, + KOI7switched = 2105, + BRF = 2106, + TSCII = 2107, + CP51932 = 2108, + windows874 = 2109, + windows1250 = 2250, + windows1251 = 2251, + windows1252 = 2252, + windows1253 = 2253, + windows1254 = 2254, + windows1255 = 2255, + windows1256 = 2256, + windows1257 = 2257, + windows1258 = 2258, + TIS620 = 2259, + CP50220 = 2260 + }; +} +\end{codeblock} + +\begin{note} +The \tcode{text_encoding::id} enumeration +contains an enumerator for each known registered character encoding. +For each encoding, the corresponding enumerator is derived from +the alias beginning with ``\tcode{cs}'', as follows +\begin{itemize} +\item +\tcode{csUnicode} is mapped to \tcode{text_encoding::id::UCS2}, +\item +\tcode{csIBBM904} is mapped to \tcode{text_encoding::id::IBM904}, and +\item +the ``\tcode{cs}'' prefix is removed from other names. +\end{itemize} +\end{note} + +\rSec3[text.encoding.hash]{Hash support} + +\indexlibrarymember{hash}{text_encoding}% +\begin{itemdecl} +template<> struct hash; +\end{itemdecl} + +\begin{itemdescr} +\pnum +The specialization is enabled\iref{unord.hash}. +\end{itemdescr} diff --git a/source/support.tex b/source/support.tex index 2d0eeb569c..5675f7dbff 100644 --- a/source/support.tex +++ b/source/support.tex @@ -758,6 +758,7 @@ #define @\defnlibxname{cpp_lib_string_udls}@ 201304L // also in \libheader{string} #define @\defnlibxname{cpp_lib_string_view}@ 201803L // also in \libheader{string}, \libheader{string_view} #define @\defnlibxname{cpp_lib_syncbuf}@ 201803L // also in \libheader{syncstream} +#define @\defnlibxname{cpp_lib_text_encoding}@ 202306L // also in \libheader{text_encoding} #define @\defnlibxname{cpp_lib_three_way_comparison}@ 201907L // freestanding, also in \libheader{compare} #define @\defnlibxname{cpp_lib_to_address}@ 201711L // freestanding, also in \libheader{memory} #define @\defnlibxname{cpp_lib_to_array}@ 201907L // also in \libheader{array} From 7798f19f1e65a84a95ae6e5fa424e1a0e0a990ed Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Thu, 29 Jun 2023 16:23:03 -0700 Subject: [PATCH 097/171] [bibliography] Move the two IANA entries together. --- source/back.tex | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/back.tex b/source/back.tex index c11c841111..f0b43a6430 100644 --- a/source/back.tex +++ b/source/back.tex @@ -22,13 +22,13 @@ \chapter{Bibliography} IANA Character Sets Database. Available from:\newline \url{https://www.iana.org/assignments/character-sets/}, 2021-04-01 +\item + IANA Time Zone Database. + Available from: \url{https://www.iana.org/time-zones} \item Unicode Character Mapping Markup Language [online]. Edited by Mark Davis and Markus Scherer. Revision 5.0.1; 2017-05-31 Available from: \url{http://www.unicode.org/reports/tr22/tr22-8.html} -\item - IANA Time Zone Database. - Available from: \url{https://www.iana.org/time-zones} % Literature references. \item Bjarne Stroustrup, From 3ca7c138e4c1de2487d3be1ce0de6414911b4e50 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 4 Jul 2023 12:19:25 -0700 Subject: [PATCH 098/171] [text.encoding.members] Use "static_assert" instead of "assert" in example. --- source/locales.tex | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/source/locales.tex b/source/locales.tex index f9b9efa791..f66886e4b8 100644 --- a/source/locales.tex +++ b/source/locales.tex @@ -5004,10 +5004,10 @@ \begin{example} \begin{codeblock} -assert(@\exposid{comp-name}@("UTF-8", "utf8") == true); -assert(@\exposid{comp-name}@("u.t.f-008", "utf8") == true); -assert(@\exposid{comp-name}@("ut8", "utf8") == false); -assert(@\exposid{comp-name}@("utf-80", "utf8") == false); +static_assert(@\exposid{comp-name}@("UTF-8", "utf8") == true); +static_assert(@\exposid{comp-name}@("u.t.f-008", "utf8") == true); +static_assert(@\exposid{comp-name}@("ut8", "utf8") == false); +static_assert(@\exposid{comp-name}@("utf-80", "utf8") == false); \end{codeblock} \end{example} \end{itemdescr} From a91769e813f4855038f0984a4f3a5123f56a81fd Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 27 Jun 2023 01:01:57 -0700 Subject: [PATCH 099/171] P0792R14 function_ref: a type-erased callable reference Editorial notes: - [func.wrap.ref.class] Fix reference for "trivially copyable type". - [func.wrap.ref.class] Change "this subclause" to "subclause [func.wrap.ref]" to account for the external use of "call-args". --- source/support.tex | 1 + source/utilities.tex | 367 ++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 366 insertions(+), 2 deletions(-) diff --git a/source/support.tex b/source/support.tex index 5675f7dbff..f446e54830 100644 --- a/source/support.tex +++ b/source/support.tex @@ -648,6 +648,7 @@ #define @\defnlibxname{cpp_lib_freestanding_ratio}@ 202306L // freestanding, also in \libheader{ratio} #define @\defnlibxname{cpp_lib_freestanding_tuple}@ 202306L // freestanding, also in \libheader{tuple} #define @\defnlibxname{cpp_lib_freestanding_utility}@ 202306L // freestanding, also in \libheader{utility} +#define @\defnlibxname{cpp_lib_function_ref}@ 202306L // also in \libheader{functional} #define @\defnlibxname{cpp_lib_gcd_lcm}@ 201606L // also in \libheader{numeric} #define @\defnlibxname{cpp_lib_generator}@ 202207L // also in \libheader{generator} #define @\defnlibxname{cpp_lib_generic_associative_lookup}@ 201304L // also in \libheader{map}, \libheader{set} diff --git a/source/utilities.tex b/source/utilities.tex index ab5db626f6..c71474ce66 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -214,6 +214,15 @@ explicit in_place_index_t() = default; }; template constexpr in_place_index_t in_place_index{}; + + // \tcode{nontype} argument tag% +\indexlibraryglobal{nontype_t}% +\indexlibraryglobal{nontype} + template + struct nontype_t { + explicit nontype_t() = default; + }; + template constexpr nontype_t nontype{}; } \end{codeblock} @@ -10576,9 +10585,14 @@ bool operator==(const function&, nullptr_t) noexcept; // \ref{func.wrap.move}, move only wrapper - template class move_only_function; // \notdef + template class move_only_function; // \notdef + template + class move_only_function; // \seebelow + + // \ref{func.wrap.ref}, non-owning wrapper + template class function_ref; // freestanding, \notdef template - class move_only_function; // \seebelow + class function_ref; // freestanding, \seebelow // \ref{func.search}, searchers template> @@ -13438,6 +13452,355 @@ \returns \tcode{true} if \tcode{f} has no target object, otherwise \tcode{false}. \end{itemdescr} + +\rSec3[func.wrap.ref]{Non-owning wrapper} + +\rSec4[func.wrap.ref.general]{General} + +\pnum +The header provides partial specializations of \tcode{function_ref} +for each combination of the possible replacements of +the placeholders \cv{} and \placeholder{noex} where: + +\begin{itemize} +\item \cv{} is either const or empty, and +\item \placeholder{noex} is either \tcode{true} or \tcode{false}. +\end{itemize} + +\rSec4[func.wrap.ref.class]{Class template \tcode{function_ref}} + +\indexlibraryglobal{function_ref}% +\begin{codeblock} +namespace std { + template class function_ref; // \notdef + + template + class function_ref { + public: + // \ref{func.wrap.ref.ctor}, constructors and assignment operators + template function_ref(F*) noexcept; + template constexpr function_ref(F&&) noexcept; + template constexpr function_ref(nontype_t) noexcept; + template constexpr function_ref(nontype_t, U&&) noexcept; + template constexpr function_ref(nontype_t, @\cv{}@ T*) noexcept; + + constexpr function_ref(const function_ref&) noexcept = default; + constexpr function_ref& operator=(const function_ref&) noexcept = default; + template function_ref& operator=(T) = delete; + + // \ref{func.wrap.ref.inv}, invocation + R operator()(ArgTypes...) const noexcept(@\placeholder{noex}@); + + private: + template + static constexpr bool @\exposid{is-invocable-using}@ = @\seebelow@; // \expos + }; + + // \ref{func.wrap.ref.deduct}, deduction guides + template + function_ref(F*) -> function_ref; + template + function_ref(nontype_t) -> function_ref<@\seebelow@>; + template + function_ref(nontype_t, auto) -> function_ref<@\seebelow@>; +} +\end{codeblock} + +\pnum +An object of class +\tcode{function_ref} +stores +%FIXME: What is "thunk-ptr"? where did it come from? +a pointer to function \exposid{thunk-ptr} and +%FIXME: What is "bound-entity"? where did it come from? +an object \exposid{bound-entity}. +\exposid{bound-entity} has +an unspecified trivially copyable type \tcode{BoundEntityType}, that +models \libconcept{copyable} and +is capable of storing a pointer to object value or a pointer to function value. +The type of \exposid{thunk-ptr} is +\tcode{R(*)(BoundEntityType, Args\&\&...) noexcept(\placeholder{noex})}. + +\pnum +Each specialization of \tcode{function_ref} is +a trivially copyable type\iref{term.trivially.copyable.type} +that models \libconcept{copyable}. + +\pnum +Within subclause \ref{func.wrap.ref}, +\tcode{\placeholder{call-args}} is an argument pack with elements such that +\tcode{decltype((\placeholder{call-args}\linebreak{}))...} denote +\tcode{Args\&\&...} respectively. + +\rSec4[func.wrap.ref.ctor]{Constructors and assignment operators} + +\indextext{function_ref::is-invocable-using@\tcode{function_ref::\exposid{is-invocable-using}}}% +\begin{itemdecl} +template + static constexpr bool @\exposid{is-invocable-using}@ = @\seebelow@; +\end{itemdecl} + +\begin{itemdescr} +\pnum +If \placeholder{noex} is \tcode{true}, +\tcode{\exposid{is-invocable-using}} is equal to: +\begin{codeblock} +is_nothrow_invocable_r_v +\end{codeblock} +Otherwise, \tcode{\exposid{is-invocable-using}} is equal to: +\begin{codeblock} +is_invocable_r_v +\end{codeblock} +\end{itemdescr} + +\indexlibraryctor{function_ref}% +\begin{itemdecl} +template function_ref(F* f) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +\begin{itemize} +\item \tcode{is_function_v} is \tcode{true}, and +\item \tcode{\exposid{is-invocable-using}} is \tcode{true}. +\end{itemize} + +\pnum +\expects +\tcode{f} is not a null pointer. + +\pnum +\effects +Initializes +\exposid{bound-entity} with \tcode{f}, and +\exposid{thunk-ptr} with the address of a function \tcode{\placeholder{thunk}} +such that +\tcode{\placeholder{thunk}(\exposid{bound-entity}, \placeholder{call-args}...)} +is expression-equivalent to +\tcode{invoke_r(f, \placeholder{call-args}...)}. +\end{itemdescr} + +\indexlibraryctor{function_ref}% +\begin{itemdecl} +template constexpr function_ref(F&& f) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +Let \tcode{T} be \tcode{remove_reference_t}. + +\pnum +\constraints +\begin{itemize} +\item \tcode{remove_cvref_t} is not the same type as \tcode{function_ref}, +\item \tcode{is_member_pointer_v} is \tcode{false}, and +\item \tcode{\exposid{is-invocable-using}<\cv{} T\&>} is \tcode{true}. +\end{itemize} + +\pnum +\effects +Initializes +\exposid{bound-entity} with \tcode{addressof(f)}, and +\exposid{thunk-ptr} with the address of a function \tcode{\placeholder{thunk}} +such that +\tcode{\placeholder{thunk}(\exposid{bound-entity}, \placeholder{call-args}...)} +is expression-equivalent to +\tcode{invoke_r(static_cast<\cv{} T\&>(f), \placeholder{call-args}...)}. +\end{itemdescr} + +\indexlibraryctor{function_ref}% +\begin{itemdecl} +template constexpr function_ref(nontype_t) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +Let \tcode{F} be \tcode{decltype(f)}. + +\pnum +\constraints +\tcode{\exposid{is-invocable-using}} is \tcode{true}. + +\pnum +\mandates +If \tcode{is_pointer_v || is_member_pointer_v} is \tcode{true}, +then \tcode{f != nullptr} is \tcode{true}. + +\pnum +\effects +Initializes +\exposid{bound-entity} with a pointer to an unspecified object or +null pointer value, and +\exposid{thunk-ptr} with the address of a function \tcode{\placeholder{thunk}} +such that +\tcode{\placeholder{thunk}(\exposid{bound-entity}, \placeholder{call-args}...)} +is expression-equivalent to +\tcode{invoke_r(f, \placeholder{call-args}...)}. +\end{itemdescr} + +\indexlibraryctor{function_ref}% +\begin{itemdecl} +template + constexpr function_ref(nontype_t, U&& obj) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +Let \tcode{T} be \tcode{remove_reference_t} and +\tcode{F} be \tcode{decltype(f)}. + +\pnum +\constraints +\begin{itemize} +\item \tcode{is_rvalue_reference_v} is \tcode{false}, and +\item \tcode{\exposid{is-invocable-using}} is \tcode{true}. +\end{itemize} + +\pnum +\mandates +If \tcode{is_pointer_v || is_member_pointer_v} is \tcode{true}, +then \tcode{f != nullptr} is \tcode{true}. + +\pnum +\effects +Initializes +\exposid{bound-entity} with \tcode{addressof(obj)}, and +\exposid{thunk-ptr} with the address of a function \tcode{\placeholder{thunk}} +such that +\tcode{\placeholder{thunk}(\exposid{bound-entity}, \placeholder{call-args}...)} +is expression-equivalent to +\tcode{invoke_r(f, static_cast<\cv{} T\&>(obj), \placeholder{call-args}...)}. +\end{itemdescr} + +\indexlibraryctor{function_ref}% +\begin{itemdecl} +template + constexpr function_ref(nontype_t, @\cv{}@ T* obj) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +Let \tcode{F} be \tcode{decltype(f)}. + +\pnum +\constraints +\tcode{\exposid{is-invocable-using}} is \tcode{true}. + +\pnum +\mandates +If \tcode{is_pointer_v || is_member_pointer_v} is \tcode{true}, +then \tcode{f != nullptr} is \tcode{true}. + +\pnum +\expects +If \tcode{is_member_pointer_v} is \tcode{true}, +\tcode{obj} is not a null pointer. + +\pnum +\effects +Initializes +\exposid{bound-entity} with \tcode{obj}, and +\exposid{thunk-ptr} with the address of a function \tcode{\placeholder{thunk}} +such that +\tcode{\placeholder{thunk}(\exposid{bound-entity}, \placeholder{call-args}...)} +is expression-equivalent to +\tcode{invoke_r(f, obj, \placeholder{call-args}...)}. +\end{itemdescr} + +\indexlibrarymember{operator=}{function_ref}% +\begin{itemdecl} +template function_ref& operator=(T) = delete; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +\begin{itemize} +\item \tcode{T} is not the same type as \tcode{function_ref}, +\item \tcode{is_pointer_v} is \tcode{false}, and +\item \tcode{T} is not a specialization of \tcode{nontype_t}. +\end{itemize} +\end{itemdescr} + +\rSec4[func.wrap.ref.inv]{Invocation} + +\indexlibrarymember{operator()}{function_ref}% +\begin{itemdecl} +R operator()(ArgTypes... args) const noexcept(@\placeholder{noex}@); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Equivalent to: +\tcode{return \exposid{thunk-ptr}(\exposid{bound-entity}, std::forward(args)...);} +\end{itemdescr} + +\rSec4[func.wrap.ref.deduct]{Deduction guides} + +\begin{itemdecl} +template + function_ref(F*) -> function_ref; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +\tcode{is_function_v} is \tcode{true}. +\end{itemdescr} + +\begin{itemdecl} +template + function_ref(nontype_t) -> function_ref<@\seebelow@>; +\end{itemdecl} + +\begin{itemdescr} +\pnum +Let \tcode{F} be \tcode{remove_pointer_t}. + +\pnum +\constraints +\tcode{is_function_v} is \tcode{true}. + +\pnum +\remarks +The deduced type is \tcode{function_ref}. +\end{itemdescr} + +\begin{itemdecl} +template + function_ref(nontype_t, T&&) -> function_ref<@\seebelow@>; +\end{itemdecl} + +\begin{itemdescr} +\pnum +Let \tcode{F} be \tcode{decltype(f)}. + +\pnum +\constraints +%FIXME: R and E should be defined outside of these constraints. +%FIXME: Define R and E via "let" in paragraph above, then use them here and below. +\begin{itemize} +\item +\tcode{F} is of the form +\tcode{R(G::*)(A...) \cv{} \opt{\&} noexcept(E)} for a type \tcode{G}, or +\item +\tcode{F} is of the form +\tcode{M G::*} for a type \tcode{G} and an object type \tcode{M}, +in which case +let \tcode{R} be \tcode{invoke_result_t}, +\tcode{A...} be an empty pack, and +\tcode{E} be \tcode{false}, or +\item +\tcode{F} is of the form +\tcode{R(*)(G, A...) noexcept(E)} for a type \tcode{G}. +\end{itemize} + +\pnum +\remarks +The deduced type is \tcode{function_ref}. +\end{itemdescr} \indextext{function object!wrapper|)} \rSec2[func.search]{Searchers} From 08defadee44ce23a44ab8a7ec437f08a894b5a5f Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 27 Jun 2023 20:06:46 -0700 Subject: [PATCH 100/171] [func.wrap.ref] Add references to [defns.expression.equivalent] on "expression-equivalent" --- source/utilities.tex | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/source/utilities.tex b/source/utilities.tex index c71474ce66..ef64169e91 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -13577,7 +13577,7 @@ \exposid{thunk-ptr} with the address of a function \tcode{\placeholder{thunk}} such that \tcode{\placeholder{thunk}(\exposid{bound-entity}, \placeholder{call-args}...)} -is expression-equivalent to +is expression-equivalent\iref{defns.expression.equivalent} to \tcode{invoke_r(f, \placeholder{call-args}...)}. \end{itemdescr} @@ -13605,7 +13605,7 @@ \exposid{thunk-ptr} with the address of a function \tcode{\placeholder{thunk}} such that \tcode{\placeholder{thunk}(\exposid{bound-entity}, \placeholder{call-args}...)} -is expression-equivalent to +is expression-equivalent\iref{defns.expression.equivalent} to \tcode{invoke_r(static_cast<\cv{} T\&>(f), \placeholder{call-args}...)}. \end{itemdescr} @@ -13635,7 +13635,7 @@ \exposid{thunk-ptr} with the address of a function \tcode{\placeholder{thunk}} such that \tcode{\placeholder{thunk}(\exposid{bound-entity}, \placeholder{call-args}...)} -is expression-equivalent to +is expression-equivalent\iref{defns.expression.equivalent} to \tcode{invoke_r(f, \placeholder{call-args}...)}. \end{itemdescr} @@ -13669,7 +13669,7 @@ \exposid{thunk-ptr} with the address of a function \tcode{\placeholder{thunk}} such that \tcode{\placeholder{thunk}(\exposid{bound-entity}, \placeholder{call-args}...)} -is expression-equivalent to +is expression-equivalent\iref{defns.expression.equivalent} to \tcode{invoke_r(f, static_cast<\cv{} T\&>(obj), \placeholder{call-args}...)}. \end{itemdescr} @@ -13704,7 +13704,7 @@ \exposid{thunk-ptr} with the address of a function \tcode{\placeholder{thunk}} such that \tcode{\placeholder{thunk}(\exposid{bound-entity}, \placeholder{call-args}...)} -is expression-equivalent to +is expression-equivalent\iref{defns.expression.equivalent} to \tcode{invoke_r(f, obj, \placeholder{call-args}...)}. \end{itemdescr} From 33d767583359e22fed2dcfaa3b27fe90c7dd8329 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Fri, 21 Jul 2023 17:38:55 +0100 Subject: [PATCH 101/171] [func.wrap.ref.class] Add expos-only members explicitly --- source/utilities.tex | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/source/utilities.tex b/source/utilities.tex index ef64169e91..06c9641bc1 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -13493,7 +13493,10 @@ private: template - static constexpr bool @\exposid{is-invocable-using}@ = @\seebelow@; // \expos + static constexpr bool @\exposidnc{is-invocable-using}@ = @\seebelownc@; // \expos + + R (*@\exposidnc{thunk-ptr}@)(@\exposidnc{BoundEntityType}@, Args&&...) noexcept(@\placeholdernc{noex}@); // \expos + @\exposidnc{BoundEntityType}@ @\exposidnc{bound-entity}@; // \expos }; // \ref{func.wrap.ref.deduct}, deduction guides @@ -13509,17 +13512,14 @@ \pnum An object of class \tcode{function_ref} -stores -%FIXME: What is "thunk-ptr"? where did it come from? -a pointer to function \exposid{thunk-ptr} and -%FIXME: What is "bound-entity"? where did it come from? +stores a pointer to function \exposid{thunk-ptr} and an object \exposid{bound-entity}. \exposid{bound-entity} has -an unspecified trivially copyable type \tcode{BoundEntityType}, that +an unspecified trivially copyable type \exposid{BoundEntityType}, that models \libconcept{copyable} and is capable of storing a pointer to object value or a pointer to function value. The type of \exposid{thunk-ptr} is -\tcode{R(*)(BoundEntityType, Args\&\&...) noexcept(\placeholder{noex})}. +\tcode{R(*)(\exposidnc{BoundEntityType}, Args\&\&...) noexcept(\placeholder{noex})}. \pnum Each specialization of \tcode{function_ref} is From 4066e89db967b1acbc47777c210259dfd60cca78 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 27 Jun 2023 20:16:15 -0700 Subject: [PATCH 102/171] [func.wrap.ref.class] Remove redundant declaration for function_ref as per #6273. --- source/utilities.tex | 2 -- 1 file changed, 2 deletions(-) diff --git a/source/utilities.tex b/source/utilities.tex index 06c9641bc1..fdc9737574 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -13472,8 +13472,6 @@ \indexlibraryglobal{function_ref}% \begin{codeblock} namespace std { - template class function_ref; // \notdef - template class function_ref { public: From 3741ce06852ed349e7f989191b45538d534b081e Mon Sep 17 00:00:00 2001 From: Alisdair Meredith Date: Tue, 20 Jun 2023 19:55:09 +0200 Subject: [PATCH 103/171] P2874R2 Mandating Annex D Replaces "Requires:" elements in Annex D with more modern wording. --- source/future.tex | 170 +++++++++++++++++++++---------------------- source/xrefdelta.tex | 3 + 2 files changed, 87 insertions(+), 86 deletions(-) diff --git a/source/future.tex b/source/future.tex index 3b75e30c7e..b3bcafe236 100644 --- a/source/future.tex +++ b/source/future.tex @@ -1,8 +1,6 @@ %!TEX root = std.tex \normannex{depr}{Compatibility features} -\newcommand{\requires}{\Fundesc{Requires}} - \rSec1[depr.general]{General} \pnum @@ -204,20 +202,6 @@ before the qualified name of a class or alias template without a template argument list is deprecated\iref{temp.names}. -\rSec1[depr.res.on.required]{Requires paragraph} - -\pnum -In addition to the elements specified in \ref{structure.specifications}, -descriptions of function semantics may also contain a \requires element -to denote the preconditions for calling a function. - -\pnum -\indextext{restriction}% -Violation of any preconditions specified in a function's \requires element -results in undefined behavior -unless the function's \throws element -specifies throwing an exception when the precondition is violated. - \rSec1[depr.numeric.limits.has.denorm]{\tcode{has_denorm} members in \tcode{numeric_limits}} \pnum @@ -306,8 +290,8 @@ \begin{itemdescr} \pnum -\requires -Type \tcode{T} is \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}). +\expects +\tcode{T} meets the \oldconcept{EqualityComparable} requirements (\tref{cpp17.equalitycomparable}). \pnum \returns @@ -321,8 +305,8 @@ \begin{itemdescr} \pnum -\requires -Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}). +\expects +\tcode{T} meets the \oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}). \pnum \returns @@ -336,8 +320,8 @@ \begin{itemdescr} \pnum -\requires -Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}). +\expects +\tcode{T} meets the \oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}). \pnum \returns @@ -351,8 +335,8 @@ \begin{itemdescr} \pnum -\requires -Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}). +\expects +\tcode{T} meets the \oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}). \pnum \returns @@ -1490,6 +1474,13 @@ any of the templates defined in this subclause is undefined, unless explicitly permitted by the specification of the corresponding template. +\pnum +\indextext{POD}% +A \term{POD class} is a class that is both a trivial class and a +standard-layout class, and has no non-static data members of type non-POD class +(or array thereof). A \term{POD type} is a scalar type, a POD class, an array +of such a type, or a cv-qualified version of one of these types. + \indexlibraryglobal{is_pod}% \begin{itemdecl} template struct is_pod; @@ -1497,19 +1488,15 @@ \begin{itemdescr} \pnum -\requires +\expects \tcode{remove_all_extents_t} shall be a complete type or \cv{} \keyword{void}. \pnum +\remarks \tcode{is_pod} is a \oldconcept{UnaryTypeTrait}\iref{meta.rqmts} with a base characteristic of \tcode{true_type} if \tcode{T} is a POD type, and \tcode{false_type} otherwise. -\indextext{POD}% -A POD class is a class that is both a trivial class and a standard-layout class, -and has no non-static data members of type non-POD class (or array thereof). -A POD type is a scalar type, a POD class, an array of such a type, -or a cv-qualified version of one of these types. \pnum \begin{note} @@ -1832,7 +1819,8 @@ \begin{itemdescr} \pnum -\requires \tcode{p} shall not be null. +\expects +\tcode{p} is not null. \pnum \returns @@ -1850,7 +1838,8 @@ \begin{itemdescr} \pnum -\requires \tcode{p} shall not be null. +\expects +\tcode{p} is not null. \pnum \returns @@ -1868,10 +1857,9 @@ \begin{itemdescr} \pnum -\requires \tcode{p} shall not be null. - -\pnum -\requires \tcode{mo} shall not be \tcode{memory_order::release} or \tcode{memory_order::acq_rel}. +\expects +\tcode{p} is not null. +\tcode{mo} is neither \tcode{memory_order::release} nor \tcode{memory_order::acq_rel}. \pnum \returns @@ -1889,7 +1877,8 @@ \begin{itemdescr} \pnum -\requires \tcode{p} shall not be null. +\expects +\tcode{p} is not null. \pnum \effects @@ -1907,10 +1896,9 @@ \begin{itemdescr} \pnum -\requires \tcode{p} shall not be null. - -\pnum -\requires \tcode{mo} shall not be \tcode{memory_order::acquire} or \tcode{memory_order::acq_rel}. +\expects +\tcode{p} is not null. +\tcode{mo} is neither \tcode{memory_order::acquire} nor \tcode{memory_order::acq_rel}. \pnum \effects @@ -1928,7 +1916,8 @@ \begin{itemdescr} \pnum -\requires \tcode{p} shall not be null. +\expects +\tcode{p} is not null. \pnum \returns @@ -1947,7 +1936,8 @@ \begin{itemdescr} \pnum -\requires \tcode{p} shall not be null. +\expects +\tcode{p} is not null. \pnum \effects @@ -1970,7 +1960,8 @@ \begin{itemdescr} \pnum -\requires \tcode{p} shall not be null and \tcode{v} shall not be null. +\expects +\tcode{p} is not null and \tcode{v} is not null. \pnum \returns @@ -2013,8 +2004,9 @@ \begin{itemdescr} \pnum -\requires \tcode{p} shall not be null and \tcode{v} shall not be null. -The \tcode{failure} argument shall not be \tcode{memory_order::release} nor +\expects +\tcode{p} is not null and \tcode{v} is not null. +The \tcode{failure} argument is neither \tcode{memory_order::release} nor \tcode{memory_order::acq_rel}. \pnum @@ -2226,7 +2218,7 @@ multibyte sequence corresponding to a wide string, but you don't want to alter the locale for \tcode{cout}, you can write something like: \begin{codeblock} -wstring_convert> myconv; +std::wstring_convert> myconv; std::string mbstring = myconv.to_bytes(L"Hello\n"); std::cout << mbstring; \end{codeblock} @@ -2329,11 +2321,11 @@ \begin{itemdescr} \pnum \effects -The first member function shall convert the single-element sequence \tcode{byte} to a -wide string. The second member function shall convert the null-terminated +The first member function converts the single-element sequence \tcode{byte} to a +wide string. The second member function converts the null-terminated sequence beginning at \tcode{ptr} to a wide string. The third member function -shall convert the sequence stored in \tcode{str} to a wide string. The fourth member -function shall convert the sequence defined by the range \range{first}{last} to a +converts the sequence stored in \tcode{str} to a wide string. The fourth member +function converts the sequence defined by the range \range{first}{last} to a wide string. \pnum @@ -2341,17 +2333,17 @@ \begin{itemize} \item If the \tcode{cvtstate} object was not constructed with an explicit value, it -shall be set to its default value (the initial conversion state) before the -conversion begins. Otherwise it shall be left unchanged. +is set to its default value (the initial conversion state) before the +conversion begins. Otherwise it is left unchanged. -\item The number of input elements successfully converted shall be stored in \tcode{cvtcount}. +\item The number of input elements successfully converted is stored in \tcode{cvtcount}. \end{itemize} \pnum \returns -If no conversion error occurs, the member function shall return the converted wide string. +If no conversion error occurs, the member function returns the converted wide string. Otherwise, if the object was constructed with a wide-error string, the -member function shall return the wide-error string. +member function returns the wide-error string. Otherwise, the member function throws an object of class \tcode{range_error}. \end{itemdescr} @@ -2377,30 +2369,29 @@ \begin{itemdescr} \pnum \effects -The first member function shall convert the single-element sequence \tcode{wchar} to a byte string. -The second member function shall convert the null-terminated sequence beginning at \tcode{wptr} to -a byte string. The third member function shall convert the sequence stored in \tcode{wstr} to a -byte string. The fourth member function shall convert the sequence defined by the +The first member function converts the single-element sequence \tcode{wchar} to a byte string. +The second member function converts the null-terminated sequence beginning at \tcode{wptr} to +a byte string. The third member function converts the sequence stored in \tcode{wstr} to a +byte string. The fourth member function converts the sequence defined by the range \range{first}{last} to a byte string. \pnum In all cases: \begin{itemize} -\item If the \tcode{cvtstate} object was not constructed with an explicit value, it -shall be -set to its default value (the initial conversion state) before the -conversion begins. Otherwise it shall be left unchanged. -\item The number of input elements successfully converted shall be stored +\item If the \tcode{cvtstate} object was not constructed with an explicit value, +it is set to its default value (the initial conversion state) before the +conversion begins. Otherwise it is left unchanged. +\item The number of input elements successfully converted is stored in \tcode{cvtcount}. \end{itemize} \pnum \returns -If no conversion error occurs, the member function shall return the converted byte string. +If no conversion error occurs, the member function returns the converted byte string. Otherwise, if the object was constructed with a byte-error string, the -member function shall return the byte-error string. -Otherwise, the member function shall throw an object of class \tcode{range_error}. +member function returns the byte-error string. +Otherwise, the member function throws an object of class \tcode{range_error}. \end{itemdescr} \indexlibraryctor{wstring_convert}% @@ -2413,20 +2404,20 @@ \begin{itemdescr} \pnum -\requires -For the first and second constructors, \tcode{pcvt != nullptr}. +\expects +For the first and second constructors, \tcode{pcvt} is not null. \pnum \effects -The first constructor shall store \tcode{pcvt} in \tcode{cvtptr} and +The first constructor stores \tcode{pcvt} in \tcode{cvtptr} and default values in \tcode{cvtstate}, \tcode{byte_err_string}, and \tcode{wide_err_string}. -The second constructor shall store \tcode{pcvt} in \tcode{cvtptr}, +The second constructor stores \tcode{pcvt} in \tcode{cvtptr}, \tcode{state} in \tcode{cvtstate}, and default values in \tcode{byte_err_string} and \tcode{wide_err_string}; moreover the -stored state shall be retained between calls to \tcode{from_bytes} and +stored state is retained between calls to \tcode{from_bytes} and \tcode{to_bytes}. -The third constructor shall store \tcode{new Codecvt} in \tcode{cvtptr}, +The third constructor stores \tcode{new Codecvt} in \tcode{cvtptr}, \tcode{state_type()} in \tcode{cvtstate}, \tcode{byte_err} in \tcode{byte_err_string}, and \tcode{wide_err} in \tcode{wide_err_string}. @@ -2440,7 +2431,7 @@ \begin{itemdescr} \pnum \effects -The destructor shall delete \tcode{cvtptr}. +\tcode{delete cvtptr}. \end{itemdescr} \rSec2[depr.conversions.buffer]{Class template \tcode{wbuffer_convert}} @@ -2550,8 +2541,8 @@ \begin{itemdescr} \pnum -\requires -\tcode{pcvt != nullptr}. +\expects +\tcode{pcvt} is not null. \pnum \effects @@ -2568,7 +2559,7 @@ \begin{itemdescr} \pnum \effects -The destructor shall delete \tcode{cvtptr}. +\tcode{delete cvtptr}. \end{itemdescr} \rSec1[depr.locale.category]{Deprecated locale category facets} @@ -2606,6 +2597,9 @@ \rSec1[depr.fs.path.factory]{Deprecated filesystem path factory functions} +\pnum +The header \libheaderrefx{filesystem}{fs.filesystem.syn} has the following additions: + \indexlibraryglobal{u8path}% \begin{itemdecl} template @@ -2616,23 +2610,27 @@ \begin{itemdescr} \pnum -\requires The \tcode{source} and \range{first}{last} - sequences are UTF-8 encoded. The value type of \tcode{Source} - and \tcode{InputIterator} is \tcode{char} or \keyword{char8_t}. - \tcode{Source} meets the requirements specified in \ref{fs.path.req}. +\mandates +The value type of \tcode{Source} and \tcode{InputIterator} is +\tcode{char} or \keyword{char8_t}. + +\pnum +\expects +The \tcode{source} and \range{first}{last} sequences are UTF-8 encoded. +\tcode{Source} meets the requirements specified in \ref{fs.path.req}. \pnum \returns \begin{itemize} -\item If \tcode{value_type} is \tcode{char} and the current native +\item If \tcode{path::value_type} is \tcode{char} and the current native narrow encoding\iref{fs.path.type.cvt} is UTF-8, return \tcode{path(source)} or \tcode{path(first, last)}; otherwise, -\item if \tcode{value_type} is \keyword{wchar_t} and the +\item if \tcode{path::value_type} is \keyword{wchar_t} and the native wide encoding is UTF-16, or - if \tcode{value_type} is \keyword{char16_t} or \keyword{char32_t}, + if \tcode{path::value_type} is \keyword{char16_t} or \keyword{char32_t}, convert \tcode{source} or \range{first}{last} - to a temporary, \tcode{tmp}, of type \tcode{string_type} and + to a temporary, \tcode{tmp}, of type \tcode{path::string_type} and return \tcode{path(tmp)}; otherwise, \item convert \tcode{source} or \range{first}{last} diff --git a/source/xrefdelta.tex b/source/xrefdelta.tex index b124de5d68..e622e48e6c 100644 --- a/source/xrefdelta.tex +++ b/source/xrefdelta.tex @@ -114,5 +114,8 @@ \movedxref{denorm.style}{depr.numeric.limits.has.denorm} \removedxref{fp.style} +% P2874R2 Mandating Annex D +\removedxref{depr.res.on.required} + % Deprecated features. %\deprxref{old.label} (if moved to depr.old.label, otherwise use \movedxref) From 60f7296e5a4f3005fc528c49a2cf9b2313c32c00 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Fri, 23 Jun 2023 18:16:00 -0700 Subject: [PATCH 104/171] P2757R3 Type checking format args --- source/support.tex | 2 +- source/utilities.tex | 87 ++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 80 insertions(+), 9 deletions(-) diff --git a/source/support.tex b/source/support.tex index f446e54830..cac813cf90 100644 --- a/source/support.tex +++ b/source/support.tex @@ -628,7 +628,7 @@ #define @\defnlibxname{cpp_lib_filesystem}@ 201703L // also in \libheader{filesystem} #define @\defnlibxname{cpp_lib_flat_map}@ 202207L // also in \libheader{flat_map} #define @\defnlibxname{cpp_lib_flat_set}@ 202207L // also in \libheader{flat_set} -#define @\defnlibxname{cpp_lib_format}@ 202304L // also in \libheader{format} +#define @\defnlibxname{cpp_lib_format}@ 202305L // also in \libheader{format} #define @\defnlibxname{cpp_lib_format_ranges}@ 202207L // also in \libheader{format} #define @\defnlibxname{cpp_lib_formatters}@ 202302L // also in \libheader{stacktrace}, \libheader{thread} #define @\defnlibxname{cpp_lib_forward_like}@ 202207L // freestanding, also in \libheader{utility} diff --git a/source/utilities.tex b/source/utilities.tex index fdc9737574..55113474ef 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -15442,9 +15442,9 @@ If \tcode{\{ \opt{\fmtgrammarterm{arg-id}} \}} is used in a \fmtgrammarterm{width} or \fmtgrammarterm{precision} option, the value of the corresponding formatting argument is used as the value of the option. -If the corresponding formatting argument is -not of standard signed or unsigned integer type, or -its value is negative, +The option is valid only if the corresponding formatting argument is +of standard signed or unsigned integer type. +If its value is negative, an exception of type \tcode{format_error} is thrown. \pnum @@ -16555,8 +16555,7 @@ size_t num_args_; // \expos public: - constexpr explicit basic_format_parse_context(basic_string_view fmt, - size_t num_args = 0) noexcept; + constexpr explicit basic_format_parse_context(basic_string_view fmt) noexcept; basic_format_parse_context(const basic_format_parse_context&) = delete; basic_format_parse_context& operator=(const basic_format_parse_context&) = delete; @@ -16566,6 +16565,11 @@ constexpr size_t next_arg_id(); constexpr void check_arg_id(size_t id); + + template + constexpr void check_dynamic_spec(size_t id) noexcept; + constexpr void check_dynamic_spec_integral(size_t id) noexcept; + constexpr void check_dynamic_spec_string(size_t id) noexcept; }; } \end{codeblock} @@ -16578,8 +16582,7 @@ \indexlibraryctor{basic_format_parse_context}% \begin{itemdecl} -constexpr explicit basic_format_parse_context(basic_string_view fmt, - size_t num_args = 0) noexcept; +constexpr explicit basic_format_parse_context(basic_string_view fmt) noexcept; \end{itemdecl} \begin{itemdescr} @@ -16590,7 +16593,13 @@ \tcode{end_} with \tcode{fmt.end()}, \tcode{indexing_} with \tcode{unknown}, \tcode{next_arg_id_} with \tcode{0}, and -\tcode{num_args_} with \tcode{num_args}. +\tcode{num_args_} with \tcode{0}. +\begin{note} +Any call to +\tcode{next_arg_id}, \tcode{check_arg_id}, or \tcode{check_dynamic_spec} +on an instance of \tcode{basic_format_parse_context} +initialized using this constructor is not a core constant expression. +\end{note} \end{itemdescr} \indexlibrarymember{begin}{basic_format_parse_context}% @@ -16683,6 +16692,68 @@ core constant expressions\iref{expr.const}. \end{itemdescr} +\indexlibrarymember{check_dynamic_spec}{basic_format_parse_context}% +\begin{itemdecl} +template + constexpr void check_dynamic_spec(size_t id) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\mandates +The types in \tcode{Ts...} are unique. +Each type in \tcode{Ts...} is one of +\keyword{bool}, +\tcode{char_type}, +\keyword{int}, +\tcode{\keyword{unsigned} \keyword{int}}, +\tcode{\keyword{long} \keyword{long} \keyword{int}}, +\tcode{\keyword{unsigned} \keyword{long} \keyword{long} \keyword{int}}, +\keyword{float}, +\keyword{double}, +\tcode{\keyword{long} \keyword{double}}, +\tcode{\keyword{const} char_type*}, +\tcode{basic_string_view}, or +\tcode{\keyword{const} \keyword{void}*}. + +\pnum +\remarks +Call expressions where +\tcode{id >= num_args_} or +the type of the corresponding format argument +(after conversion to \tcode{basic_format_arg}) +is not one of the types in \tcode{Ts...} +are not core constant expressions\iref{expr.const}. +\end{itemdescr} + +\indexlibrarymember{check_dynamic_spec_integral}{basic_format_parse_context}% +\begin{itemdecl} +constexpr void check_dynamic_spec_integral(size_t id) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Equivalent to: +\begin{codeblock} +check_dynamic_spec(id); +\end{codeblock} +\end{itemdescr} + +\indexlibrarymember{check_dynamic_spec_string}{basic_format_parse_context}% +\begin{itemdecl} +constexpr void check_dynamic_spec_string(size_t id) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Equivalent to: +\begin{codeblock} +check_dynamic_spec>(id); +\end{codeblock} +\end{itemdescr} + \rSec3[format.context]{Class template \tcode{basic_format_context}} \indexlibraryglobal{basic_format_context}% From a9fe18ce1b6c746939d654ffd706aac410810a5d Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Fri, 23 Jun 2023 17:13:36 -0700 Subject: [PATCH 105/171] P2637R3 Member visit --- source/future.tex | 28 ++++++++++++++ source/support.tex | 4 +- source/utilities.tex | 92 ++++++++++++++++++++++++++++++++++++-------- 3 files changed, 105 insertions(+), 19 deletions(-) diff --git a/source/future.tex b/source/future.tex index b3bcafe236..3fad5ca3e3 100644 --- a/source/future.tex +++ b/source/future.tex @@ -2064,6 +2064,34 @@ \end{note} \end{itemdescr} +\rSec1[depr.format]{Deprecated formatting} + +\rSec2[depr.format.syn]{Header \tcode{} synopsis} + +\pnum +The header \libheaderref{format}{format.syn} has the following additions: + +\begin{codeblock} +namespace std { + template + decltype(auto) visit_format_arg(Visitor&& vis, basic_format_arg arg); +} +\end{codeblock} + +\rSec2[depr.format.arg]{Formatting arguments} + +\indexlibraryglobal{visit_format_arg}% +\begin{itemdecl} +template + decltype(auto) visit_format_arg(Visitor&& vis, basic_format_arg arg); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Equivalent to: \tcode{return visit(std::forward(vis), arg.value);} +\end{itemdescr} + \rSec1[depr.locale.stdcvt]{Deprecated standard code conversion facets} \rSec2[depr.locale.stdcvt.general]{General} diff --git a/source/support.tex b/source/support.tex index cac813cf90..47f4f97a0f 100644 --- a/source/support.tex +++ b/source/support.tex @@ -628,7 +628,7 @@ #define @\defnlibxname{cpp_lib_filesystem}@ 201703L // also in \libheader{filesystem} #define @\defnlibxname{cpp_lib_flat_map}@ 202207L // also in \libheader{flat_map} #define @\defnlibxname{cpp_lib_flat_set}@ 202207L // also in \libheader{flat_set} -#define @\defnlibxname{cpp_lib_format}@ 202305L // also in \libheader{format} +#define @\defnlibxname{cpp_lib_format}@ 202306L // also in \libheader{format} #define @\defnlibxname{cpp_lib_format_ranges}@ 202207L // also in \libheader{format} #define @\defnlibxname{cpp_lib_formatters}@ 202302L // also in \libheader{stacktrace}, \libheader{thread} #define @\defnlibxname{cpp_lib_forward_like}@ 202207L // freestanding, also in \libheader{utility} @@ -779,7 +779,7 @@ #define @\defnlibxname{cpp_lib_unordered_map_try_emplace}@ 201411L // also in \libheader{unordered_map} #define @\defnlibxname{cpp_lib_unreachable}@ 202202L // freestanding, also in \libheader{utility} #define @\defnlibxname{cpp_lib_unwrap_ref}@ 201811L // freestanding, also in \libheader{type_traits} -#define @\defnlibxname{cpp_lib_variant}@ 202106L // also in \libheader{variant} +#define @\defnlibxname{cpp_lib_variant}@ 202306L // also in \libheader{variant} #define @\defnlibxname{cpp_lib_void_t}@ 201411L // freestanding, also in \libheader{type_traits} \end{codeblock} diff --git a/source/utilities.tex b/source/utilities.tex index 55113474ef..2ffd9bdfca 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -5022,6 +5022,12 @@ // \ref{variant.swap}, swap constexpr void swap(variant&) noexcept(@\seebelow@); + + // \ref{variant.visit}, visitation + template + constexpr decltype(auto) visit(this Self&&, Visitor&&); + template + constexpr R visit(this Self&&, Visitor&&); }; } \end{codeblock} @@ -6140,6 +6146,44 @@ no complexity requirements. \end{itemdescr} +\indexlibrarymember{visit}{variant}% +\begin{itemdecl} +template + constexpr decltype(auto) visit(this Self&& self, Visitor&& vis); +\end{itemdecl} + +\begin{itemdescr} +\pnum +Let \tcode{V} be +\tcode{\exposid{OVERRIDE_REF}(Self\&\&, \exposid{COPY_CONST}(remove_reference_t, variant))}\iref{forward}. + +\pnum +\constraints +The call to \tcode{visit} does not use +an explicit \grammarterm{template-argument-list} that +begins with a type \grammarterm{template-argument}. + +\pnum +\effects +Equivalent to: \tcode{return std::visit(std::forward(vis), (V)self);} +\end{itemdescr} + +\indexlibrarymember{visit}{variant}% +\begin{itemdecl} +template + constexpr R visit(this Self&& self, Visitor&& vis); +\end{itemdecl} + +\begin{itemdescr} +\pnum +Let \tcode{V} be +\tcode{\exposid{OVERRIDE_REF}(Self\&\&, \exposid{COPY_CONST}(remove_reference_t, variant))}\iref{forward}. + +\pnum +\effects +Equivalent to: \tcode{return std::visit(std::forward(vis), (V)self);} +\end{itemdescr} + \rSec2[variant.monostate]{Class \tcode{monostate}}% \indexlibraryglobal{monostate}% @@ -15022,9 +15066,6 @@ // \ref{format.arg}, class template \tcode{basic_format_arg} template class basic_format_arg; - template - decltype(auto) visit_format_arg(Visitor&& vis, basic_format_arg arg); - // \ref{format.arg.store}, class template \exposid{format-arg-store} template class @\exposidnc{format-arg-store}@; // \expos @@ -16884,14 +16925,14 @@ // Formats an \tcode{S} with width given by the argument \tcode{width_arg_id}. auto format(S s, format_context& ctx) const { - int width = visit_format_arg([](auto value) -> int { + int width = ctx.arg(width_arg_id).visit([](auto value) -> int { if constexpr (!is_integral_v) throw format_error("width is not integral"); else if (value < 0 || value > numeric_limits::max()) throw format_error("invalid width"); else return value; - }, ctx.arg(width_arg_id)); + }); return format_to(ctx.out(), "{0:x<{1}}", s.value, width); } }; @@ -17513,6 +17554,11 @@ basic_format_arg() noexcept; explicit operator bool() const noexcept; + + template + decltype(auto) visit(this basic_format_arg arg, Visitor&& vis); + template + R visit(this basic_format_arg arg, Visitor&& vis); }; } \end{codeblock} @@ -17618,6 +17664,30 @@ \tcode{!holds_alternative(value)}. \end{itemdescr} +\indexlibrarymember{visit}{basic_format_arg}% +\begin{itemdecl} +template + decltype(auto) visit(this basic_format_arg arg, Visitor&& vis); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Equivalent to: \tcode{return arg.value.visit(std::forward(vis));} +\end{itemdescr} + +\indexlibrarymember{visit}{basic_format_arg}% +\begin{itemdecl} +template + R visit(this basic_format_arg arg, Visitor&& vis); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Equivalent to: \tcode{return arg.value.visit(std::forward(vis));} +\end{itemdescr} + \pnum The class \tcode{handle} allows formatting an object of a user-defined type. @@ -17689,18 +17759,6 @@ Equivalent to: \tcode{format_(parse_ctx, format_ctx, ptr_);} \end{itemdescr} -\indexlibraryglobal{visit_format_arg}% -\begin{itemdecl} -template - decltype(auto) visit_format_arg(Visitor&& vis, basic_format_arg arg); -\end{itemdecl} - -\begin{itemdescr} -\pnum -\effects -Equivalent to: \tcode{return visit(std::forward(vis), arg.value);} -\end{itemdescr} - \rSec3[format.arg.store]{Class template \exposid{format-arg-store}} \begin{codeblock} From 0facada4cadd97e1ba15bfaea76a804f1dc5c309 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Fri, 23 Jun 2023 14:28:46 -0700 Subject: [PATCH 106/171] P2641R4 Checking if a union alternative is active The feature test macro has been renamed from __cpp_lib_within_lifetime to __cpp_lib_is_within_lifetime, which seems more appropriate and follows existing practice. --- source/meta.tex | 57 ++++++++++++++++++++++++++++++++++++++++++++++ source/support.tex | 1 + 2 files changed, 58 insertions(+) diff --git a/source/meta.tex b/source/meta.tex index 7a31e4e60e..03a4545675 100644 --- a/source/meta.tex +++ b/source/meta.tex @@ -583,6 +583,8 @@ // \ref{meta.const.eval}, constant evaluation context constexpr bool is_constant_evaluated() noexcept; + template + consteval bool is_within_lifetime(const T*) noexcept; } \end{codeblock} @@ -2432,6 +2434,61 @@ \end{example} \end{itemdescr} +\indexlibraryglobal{is_within_lifetime}% +\begin{itemdecl} +template + consteval bool is_within_lifetime(const T* p) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\returns +\tcode{true} if \tcode{p} is a pointer to an object that is +within its lifetime\iref{basic.life}; otherwise, \tcode{false}. + +\pnum +\remarks +During the evaluation of an expression \tcode{E} as a core constant expression, +a call to this function is ill-formed +unless \tcode{p} points to an object that is usable +in constant expressions or +whose complete object's lifetime began within \tcode{E}. + +\pnum +\begin{example} +\begin{codeblock} +struct OptBool { + union { bool b; char c; }; + + // note: this assumes common implementation properties for \tcode{bool} and \tcode{char}: + // * \tcode{sizeof(bool) == sizeof(char)}, and + // * the value representations for \tcode{true} and \tcode{false} are distinct + // from the value representation for \tcode{2} + constexpr OptBool() : c(2) { } + constexpr OptBool(bool b) : b(b) { } + + constexpr auto has_value() const -> bool { + if consteval { + return std::is_within_lifetime(&b); // during constant evaluation, cannot read from \tcode{c} + } else { + return c != 2; // during runtime, must read from \tcode{c} + } + } + + constexpr auto operator*() -> bool& { + return b; + } +}; + +constexpr OptBool disengaged; +constexpr OptBool engaged(true); +static_assert(!disengaged.has_value()); +static_assert(engaged.has_value()); +static_assert(*engaged); +\end{codeblock} +\end{example} +\end{itemdescr} + \rSec1[ratio]{Compile-time rational arithmetic} \rSec2[ratio.general]{In general} diff --git a/source/support.tex b/source/support.tex index 47f4f97a0f..d4e2f65796 100644 --- a/source/support.tex +++ b/source/support.tex @@ -679,6 +679,7 @@ #define @\defnlibxname{cpp_lib_is_pointer_interconvertible}@ 201907L // freestanding, also in \libheader{type_traits} #define @\defnlibxname{cpp_lib_is_scoped_enum}@ 202011L // freestanding, also in \libheader{type_traits} #define @\defnlibxname{cpp_lib_is_swappable}@ 201603L // freestanding, also in \libheader{type_traits} +#define @\defnlibxname{cpp_lib_is_within_lifetime}@ 202306L // also in \libheader{type_traits} #define @\defnlibxname{cpp_lib_jthread}@ 201911L // also in \libheader{stop_token}, \libheader{thread} #define @\defnlibxname{cpp_lib_latch}@ 201907L // also in \libheader{latch} #define @\defnlibxname{cpp_lib_launder}@ 201606L // freestanding, also in \libheader{new} From 6a8b1555c4a43b8e8e41253f18f9b28398ba5aaf Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 27 Jun 2023 17:36:04 -0700 Subject: [PATCH 107/171] [meta.type.synop, meta.const.eval] Rewrite declarations using auto See #4822 for the general policy on when to use abbreviated function template syntax. --- source/meta.tex | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/source/meta.tex b/source/meta.tex index 03a4545675..7a7ec3a140 100644 --- a/source/meta.tex +++ b/source/meta.tex @@ -583,8 +583,7 @@ // \ref{meta.const.eval}, constant evaluation context constexpr bool is_constant_evaluated() noexcept; - template - consteval bool is_within_lifetime(const T*) noexcept; + consteval bool is_within_lifetime(const auto*) noexcept; } \end{codeblock} @@ -2436,8 +2435,7 @@ \indexlibraryglobal{is_within_lifetime}% \begin{itemdecl} -template - consteval bool is_within_lifetime(const T* p) noexcept; +consteval bool is_within_lifetime(const auto* p) noexcept; \end{itemdecl} \begin{itemdescr} From 05e617be48d950702fd7ec3f9a8ec99a621a3ef4 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Fri, 23 Jun 2023 13:58:13 -0700 Subject: [PATCH 108/171] P1759R6 Native handles and file streams --- source/iostreams.tex | 89 ++++++++++++++++++++++++++++++++++++++++++++ source/support.tex | 1 + 2 files changed, 90 insertions(+) diff --git a/source/iostreams.tex b/source/iostreams.tex index 2447cadecc..bba66ad08e 100644 --- a/source/iostreams.tex +++ b/source/iostreams.tex @@ -10837,6 +10837,26 @@ These functions enable class \tcode{path} support for systems with a wide native path character type, such as \keyword{wchar_t}. \end{note} +\rSec2[file.native]{Native handles} + +\indexlibraryglobal{native_handle_type}% + +\pnum +Several classes described in \ref{file.streams} +have a member \tcode{native_handle_type}. + +\pnum +The type \tcode{native_handle_type} represents a platform-specific +\defnadj{native}{handle} to a file. +It is trivially copyable and models \libconcept{semiregular}. + +\begin{note} +For operating systems based on POSIX, +\tcode{native_handle_type} is \keyword{int}. +For Windows-based operating systems, +\tcode{native_handle_type} is \tcode{HANDLE}. +\end{note} + \rSec2[filebuf]{Class template \tcode{basic_filebuf}} \rSec3[filebuf.general]{General} @@ -10852,6 +10872,7 @@ using pos_type = typename traits::pos_type; using off_type = typename traits::off_type; using traits_type = traits; + using native_handle_type = @\impdefx{type of \tcode{native_handle_type}}@; // see \ref{file.native} // \ref{filebuf.cons}, constructors/destructor basic_filebuf(); @@ -10874,6 +10895,7 @@ basic_filebuf* open(const filesystem::path& s, ios_base::openmode mode); basic_filebuf* close(); + native_handle_type native_handle() const noexcept; protected: // \ref{filebuf.virtuals}, overridden virtual functions @@ -10933,6 +10955,18 @@ \tcode{fpos}. Otherwise the behavior is undefined. +\pnum +The file associated with a \tcode{basic_filebuf} has +an associated value of type \tcode{native_handle_type}, +called the native handle\iref{file.native} of that file. +This native handle can be obtained by calling +the member function \tcode{native_handle}. + +\pnum +For any opened \tcode{basic_filebuf f}, +the native handle returned by \tcode{f.native_handle()} is +invalidated when \tcode{f.close()} is called, or \tcode{f} is destroyed. + \pnum In order to support file I/O and multibyte/wide character conversion, conversions are performed using members of a facet, referred to as @@ -11226,6 +11260,21 @@ on success, a null pointer otherwise. \end{itemdescr} +\indexlibrarymember{native_handle}{basic_filebuf}% +\begin{itemdecl} +native_handle_type native_handle() const noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\expects +\tcode{is_open()} is \tcode{true}. + +\pnum +\returns +The native handle associated with \tcode{*this}. +\end{itemdescr} + \rSec3[filebuf.virtuals]{Overridden virtual functions} \indexlibrarymember{showmanyc}{basic_filebuf}% @@ -11624,6 +11673,7 @@ using pos_type = typename traits::pos_type; using off_type = typename traits::off_type; using traits_type = traits; + using native_handle_type = typename basic_filebuf::native_handle_type; // \ref{ifstream.cons}, constructors basic_ifstream(); @@ -11646,6 +11696,7 @@ // \ref{ifstream.members}, members basic_filebuf* rdbuf() const; + native_handle_type native_handle() const noexcept; bool is_open() const; void open(const char* s, ios_base::openmode mode = ios_base::in); @@ -11794,6 +11845,17 @@ \tcode{const_cast*>(addressof(sb))}. \end{itemdescr} +\indexlibrarymember{native_handle}{basic_ifstream}% +\begin{itemdecl} +native_handle_type native_handle() const noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Equivalent to: \tcode{return rdbuf()->native_handle();} +\end{itemdescr} + \indexlibrarymember{is_open}{basic_ifstream}% \begin{itemdecl} bool is_open() const; @@ -11870,6 +11932,7 @@ using pos_type = typename traits::pos_type; using off_type = typename traits::off_type; using traits_type = traits; + using native_handle_type = typename basic_filebuf::native_handle_type; // \ref{ofstream.cons}, constructors basic_ofstream(); @@ -11892,6 +11955,7 @@ // \ref{ofstream.members}, members basic_filebuf* rdbuf() const; + native_handle_type native_handle() const noexcept; bool is_open() const; void open(const char* s, ios_base::openmode mode = ios_base::out); @@ -12040,6 +12104,17 @@ \tcode{const_cast*>(addressof(sb))}. \end{itemdescr} +\indexlibrarymember{native_handle}{basic_ofstream}% +\begin{itemdecl} +native_handle_type native_handle() const noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Equivalent to: \tcode{return rdbuf()->native_handle();} +\end{itemdescr} + \indexlibrarymember{is_open}{basic_ofstream}% \begin{itemdecl} bool is_open() const; @@ -12114,6 +12189,7 @@ using pos_type = typename traits::pos_type; using off_type = typename traits::off_type; using traits_type = traits; + using native_handle_type = typename basic_filebuf::native_handle_type; // \ref{fstream.cons}, constructors basic_fstream(); @@ -12139,6 +12215,8 @@ // \ref{fstream.members}, members basic_filebuf* rdbuf() const; + native_handle_type native_handle() const noexcept; + bool is_open() const; void open( const char* s, @@ -12297,6 +12375,17 @@ \tcode{const_cast*>(addressof(sb))}. \end{itemdescr} +\indexlibrarymember{native_handle}{basic_fstream}% +\begin{itemdecl} +native_handle_type native_handle() const noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Equivalent to: \tcode{return rdbuf()->native_handle();} +\end{itemdescr} + \indexlibrarymember{is_open}{basic_fstream}% \begin{itemdecl} bool is_open() const; diff --git a/source/support.tex b/source/support.tex index d4e2f65796..04072f868d 100644 --- a/source/support.tex +++ b/source/support.tex @@ -648,6 +648,7 @@ #define @\defnlibxname{cpp_lib_freestanding_ratio}@ 202306L // freestanding, also in \libheader{ratio} #define @\defnlibxname{cpp_lib_freestanding_tuple}@ 202306L // freestanding, also in \libheader{tuple} #define @\defnlibxname{cpp_lib_freestanding_utility}@ 202306L // freestanding, also in \libheader{utility} +#define @\defnlibxname{cpp_lib_fstream_native_handle}@ 202306L // also in \libheader{fstream} #define @\defnlibxname{cpp_lib_function_ref}@ 202306L // also in \libheader{functional} #define @\defnlibxname{cpp_lib_gcd_lcm}@ 201606L // also in \libheader{numeric} #define @\defnlibxname{cpp_lib_generator}@ 202207L // also in \libheader{generator} From af899687a996634d53ac19f1b48636f685e4fd4c Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Fri, 23 Jun 2023 12:56:43 -0700 Subject: [PATCH 109/171] P2697R1 Interfacing bitset with string_view --- source/support.tex | 1 + source/utilities.tex | 26 +++++++++++++++++++++----- 2 files changed, 22 insertions(+), 5 deletions(-) diff --git a/source/support.tex b/source/support.tex index 04072f868d..87b4bec74a 100644 --- a/source/support.tex +++ b/source/support.tex @@ -580,6 +580,7 @@ #define @\defnlibxname{cpp_lib_bind_front}@ 201907L // freestanding, also in \libheader{functional} #define @\defnlibxname{cpp_lib_bit_cast}@ 201806L // freestanding, also in \libheader{bit} #define @\defnlibxname{cpp_lib_bitops}@ 201907L // freestanding, also in \libheader{bit} +#define @\defnlibxname{cpp_lib_bitset}@ 202306L // also in \libheader{bitset} #define @\defnlibxname{cpp_lib_bool_constant}@ 201505L // freestanding, also in \libheader{type_traits} #define @\defnlibxname{cpp_lib_bounded_array_traits}@ 201902L // freestanding, also in \libheader{type_traits} #define @\defnlibxname{cpp_lib_boyer_moore_searcher}@ 201603L // also in \libheader{functional} diff --git a/source/utilities.tex b/source/utilities.tex index 2ffd9bdfca..9bc7a9a8a4 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -9687,10 +9687,18 @@ = basic_string::npos, charT zero = charT('0'), charT one = charT('1')); + template + constexpr explicit bitset( + basic_string_view str, + typename basic_string_view::size_type pos = 0, + typename basic_string_view::size_type n + = basic_string_view::npos, + charT zero = charT('0'), + charT one = charT('1')); template constexpr explicit bitset( const charT* str, - typename basic_string::size_type n = basic_string::npos, + typename basic_string_view::size_type n = basic_string_view::npos, charT zero = charT('0'), charT one = charT('1')); @@ -9823,6 +9831,14 @@ = basic_string::npos, charT zero = charT('0'), charT one = charT('1')); +template + constexpr explicit bitset( + basic_string_view str, + typename basic_string_view::size_type pos = 0, + typename basic_string_view::size_type n + = basic_string_view::npos, + charT zero = charT('0'), + charT one = charT('1')); \end{itemdecl} \begin{itemdescr} @@ -9869,7 +9885,7 @@ template constexpr explicit bitset( const charT* str, - typename basic_string::size_type n = basic_string::npos, + typename basic_string_view::size_type n = basic_string_view::npos, charT zero = charT('0'), charT one = charT('1')); \end{itemdecl} @@ -9879,9 +9895,9 @@ \effects As if by: \begin{codeblock} -bitset(n == basic_string::npos - ? basic_string(str) - : basic_string(str, n), +bitset(n == basic_string_view::npos + ? basic_string_view(str) + : basic_string_view(str, n), 0, n, zero, one) \end{codeblock} \end{itemdescr} From c1bcd5e034ab9000b1bd66dbdfcf822d59d1c1af Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Thu, 22 Jun 2023 16:56:52 -0700 Subject: [PATCH 110/171] P1383R2 More constexpr for cmath and complex --- source/numerics.tex | 282 ++++++++++++++++++++++---------------------- 1 file changed, 141 insertions(+), 141 deletions(-) diff --git a/source/numerics.tex b/source/numerics.tex index 680ca3dfe0..655ad07dd0 100644 --- a/source/numerics.tex +++ b/source/numerics.tex @@ -256,38 +256,38 @@ template constexpr T real(const complex&); template constexpr T imag(const complex&); - template T abs(const complex&); - template T arg(const complex&); + template constexpr T abs(const complex&); + template constexpr T arg(const complex&); template constexpr T norm(const complex&); template constexpr complex conj(const complex&); - template complex proj(const complex&); - template complex polar(const T&, const T& = T()); + template constexpr complex proj(const complex&); + template constexpr complex polar(const T&, const T& = T()); // \ref{complex.transcendentals}, transcendentals - template complex acos(const complex&); - template complex asin(const complex&); - template complex atan(const complex&); - - template complex acosh(const complex&); - template complex asinh(const complex&); - template complex atanh(const complex&); - - template complex cos (const complex&); - template complex cosh (const complex&); - template complex exp (const complex&); - template complex log (const complex&); - template complex log10(const complex&); - - template complex pow (const complex&, const T&); - template complex pow (const complex&, const complex&); - template complex pow (const T&, const complex&); - - template complex sin (const complex&); - template complex sinh (const complex&); - template complex sqrt (const complex&); - template complex tan (const complex&); - template complex tanh (const complex&); + template constexpr complex acos(const complex&); + template constexpr complex asin(const complex&); + template constexpr complex atan(const complex&); + + template constexpr complex acosh(const complex&); + template constexpr complex asinh(const complex&); + template constexpr complex atanh(const complex&); + + template constexpr complex cos (const complex&); + template constexpr complex cosh (const complex&); + template constexpr complex exp (const complex&); + template constexpr complex log (const complex&); + template constexpr complex log10(const complex&); + + template constexpr complex pow (const complex&, const T&); + template constexpr complex pow (const complex&, const complex&); + template constexpr complex pow (const T&, const complex&); + + template constexpr complex sin (const complex&); + template constexpr complex sinh (const complex&); + template constexpr complex sqrt (const complex&); + template constexpr complex tan (const complex&); + template constexpr complex tanh (const complex&); // \ref{complex.literals}, complex literals inline namespace literals { @@ -785,7 +785,7 @@ \indexlibrarymember{abs}{complex}% \begin{itemdecl} -template T abs(const complex& x); +template constexpr T abs(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -796,7 +796,7 @@ \indexlibrarymember{arg}{complex}% \begin{itemdecl} -template T arg(const complex& x); +template constexpr T arg(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -829,7 +829,7 @@ \indexlibrarymember{proj}{complex}% \begin{itemdecl} -template complex proj(const complex& x); +template constexpr complex proj(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -845,7 +845,7 @@ \indexlibrarymember{polar}{complex}% \begin{itemdecl} -template complex polar(const T& rho, const T& theta = T()); +template constexpr complex polar(const T& rho, const T& theta = T()); \end{itemdecl} \begin{itemdescr} @@ -867,7 +867,7 @@ \indexlibrarymember{acos}{complex}% \indexlibrarymember{cacos}{complex}% \begin{itemdecl} -template complex acos(const complex& x); +template constexpr complex acos(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -884,7 +884,7 @@ \indexlibrarymember{asin}{complex}% \indexlibrarymember{casin}{complex}% \begin{itemdecl} -template complex asin(const complex& x); +template constexpr complex asin(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -901,7 +901,7 @@ \indexlibrarymember{atan}{complex}% \indexlibrarymember{catan}{complex}% \begin{itemdecl} -template complex atan(const complex& x); +template constexpr complex atan(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -918,7 +918,7 @@ \indexlibrarymember{acosh}{complex}% \indexlibrarymember{cacosh}{complex}% \begin{itemdecl} -template complex acosh(const complex& x); +template constexpr complex acosh(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -935,7 +935,7 @@ \indexlibrarymember{asinh}{complex}% \indexlibrarymember{casinh}{complex}% \begin{itemdecl} -template complex asinh(const complex& x); +template constexpr complex asinh(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -952,7 +952,7 @@ \indexlibrarymember{atanh}{complex}% \indexlibrarymember{catanh}{complex}% \begin{itemdecl} -template complex atanh(const complex& x); +template constexpr complex atanh(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -968,7 +968,7 @@ \indexlibrarymember{cos}{complex}% \begin{itemdecl} -template complex cos(const complex& x); +template constexpr complex cos(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -979,7 +979,7 @@ \indexlibrarymember{cosh}{complex}% \begin{itemdecl} -template complex cosh(const complex& x); +template constexpr complex cosh(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -990,7 +990,7 @@ \indexlibrarymember{exp}{complex}% \begin{itemdecl} -template complex exp(const complex& x); +template constexpr complex exp(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -1001,7 +1001,7 @@ \indexlibrarymember{log}{complex}% \begin{itemdecl} -template complex log(const complex& x); +template constexpr complex log(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -1021,7 +1021,7 @@ \indexlibrarymember{log10}{complex}% \begin{itemdecl} -template complex log10(const complex& x); +template constexpr complex log10(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -1037,9 +1037,9 @@ \indexlibrarymember{pow}{complex}% \begin{itemdecl} -template complex pow(const complex& x, const complex& y); -template complex pow(const complex& x, const T& y); -template complex pow(const T& x, const complex& y); +template constexpr complex pow(const complex& x, const complex& y); +template constexpr complex pow(const complex& x, const T& y); +template constexpr complex pow(const T& x, const complex& y); \end{itemdecl} \begin{itemdescr} @@ -1059,7 +1059,7 @@ \indexlibrarymember{sin}{complex}% \begin{itemdecl} -template complex sin(const complex& x); +template constexpr complex sin(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -1070,7 +1070,7 @@ \indexlibrarymember{sinh}{complex}% \begin{itemdecl} -template complex sinh(const complex& x); +template constexpr complex sinh(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -1081,7 +1081,7 @@ \indexlibrarymember{sqrt}{complex}% \begin{itemdecl} -template complex sqrt(const complex& x); +template constexpr complex sqrt(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -1101,7 +1101,7 @@ \indexlibrarymember{tan}{complex}% \begin{itemdecl} -template complex tan(const complex& x); +template constexpr complex tan(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -1112,7 +1112,7 @@ \indexlibrarymember{tanh}{complex}% \begin{itemdecl} -template complex tanh(const complex& x); +template constexpr complex tanh(const complex& x); \end{itemdecl} \begin{itemdescr} @@ -1129,17 +1129,16 @@ \indexlibraryglobal{imag}% \indexlibraryglobal{norm}% \indexlibraryglobal{real}% -The following function templates shall have additional overloads: +The following function templates have additional constexpr overloads: \begin{codeblock} arg norm conj proj imag real \end{codeblock} -where \tcode{norm}, \tcode{conj}, \tcode{imag}, and \tcode{real} are \keyword{constexpr} overloads. \pnum \indextext{overloads!floating-point}% -The additional overloads shall be sufficient to ensure: +The additional constexpr overloads are sufficient to ensure: \begin{itemize} \item If the argument has a floating-point type \tcode{T}, @@ -1151,7 +1150,7 @@ \pnum \indexlibraryglobal{pow}% -Function template \tcode{pow} has additional overloads sufficient to ensure, +Function template \tcode{pow} has additional constexpr overloads sufficient to ensure, for a call with one argument of type \tcode{complex} and the other argument of type \tcode{T2} or \tcode{complex}, both arguments are effectively cast to \tcode{complex>}. @@ -8959,69 +8958,69 @@ #define math_errhandling @\seebelow@ namespace std { - @\placeholder{floating-point-type}@ acos(@\placeholder{floating-point-type}@ x); - float acosf(float x); - long double acosl(long double x); + constexpr @\placeholder{floating-point-type}@ acos(@\placeholder{floating-point-type}@ x); + constexpr float acosf(float x); + constexpr long double acosl(long double x); - @\placeholder{floating-point-type}@ asin(@\placeholder{floating-point-type}@ x); - float asinf(float x); - long double asinl(long double x); + constexpr @\placeholder{floating-point-type}@ asin(@\placeholder{floating-point-type}@ x); + constexpr float asinf(float x); + constexpr long double asinl(long double x); - @\placeholder{floating-point-type}@ atan(@\placeholder{floating-point-type}@ x); - float atanf(float x); - long double atanl(long double x); + constexpr @\placeholder{floating-point-type}@ atan(@\placeholder{floating-point-type}@ x); + constexpr float atanf(float x); + constexpr long double atanl(long double x); - @\placeholder{floating-point-type}@ atan2(@\placeholder{floating-point-type}@ y, @\placeholder{floating-point-type}@ x); - float atan2f(float y, float x); - long double atan2l(long double y, long double x); + constexpr @\placeholder{floating-point-type}@ atan2(@\placeholder{floating-point-type}@ y, @\placeholder{floating-point-type}@ x); + constexpr float atan2f(float y, float x); + constexpr long double atan2l(long double y, long double x); - @\placeholder{floating-point-type}@ cos(@\placeholder{floating-point-type}@ x); - float cosf(float x); - long double cosl(long double x); + constexpr @\placeholder{floating-point-type}@ cos(@\placeholder{floating-point-type}@ x); + constexpr float cosf(float x); + constexpr long double cosl(long double x); - @\placeholder{floating-point-type}@ sin(@\placeholder{floating-point-type}@ x); - float sinf(float x); - long double sinl(long double x); + constexpr @\placeholder{floating-point-type}@ sin(@\placeholder{floating-point-type}@ x); + constexpr float sinf(float x); + constexpr long double sinl(long double x); - @\placeholder{floating-point-type}@ tan(@\placeholder{floating-point-type}@ x); - float tanf(float x); - long double tanl(long double x); + constexpr @\placeholder{floating-point-type}@ tan(@\placeholder{floating-point-type}@ x); + constexpr float tanf(float x); + constexpr long double tanl(long double x); - @\placeholder{floating-point-type}@ acosh(@\placeholder{floating-point-type}@ x); - float acoshf(float x); - long double acoshl(long double x); + constexpr @\placeholder{floating-point-type}@ acosh(@\placeholder{floating-point-type}@ x); + constexpr float acoshf(float x); + constexpr long double acoshl(long double x); - @\placeholder{floating-point-type}@ asinh(@\placeholder{floating-point-type}@ x); - float asinhf(float x); - long double asinhl(long double x); + constexpr @\placeholder{floating-point-type}@ asinh(@\placeholder{floating-point-type}@ x); + constexpr float asinhf(float x); + constexpr long double asinhl(long double x); - @\placeholder{floating-point-type}@ atanh(@\placeholder{floating-point-type}@ x); - float atanhf(float x); - long double atanhl(long double x); + constexpr @\placeholder{floating-point-type}@ atanh(@\placeholder{floating-point-type}@ x); + constexpr float atanhf(float x); + constexpr long double atanhl(long double x); - @\placeholder{floating-point-type}@ cosh(@\placeholder{floating-point-type}@ x); - float coshf(float x); - long double coshl(long double x); + constexpr @\placeholder{floating-point-type}@ cosh(@\placeholder{floating-point-type}@ x); + constexpr float coshf(float x); + constexpr long double coshl(long double x); - @\placeholder{floating-point-type}@ sinh(@\placeholder{floating-point-type}@ x); - float sinhf(float x); - long double sinhl(long double x); + constexpr @\placeholder{floating-point-type}@ sinh(@\placeholder{floating-point-type}@ x); + constexpr float sinhf(float x); + constexpr long double sinhl(long double x); - @\placeholder{floating-point-type}@ tanh(@\placeholder{floating-point-type}@ x); - float tanhf(float x); - long double tanhl(long double x); + constexpr @\placeholder{floating-point-type}@ tanh(@\placeholder{floating-point-type}@ x); + constexpr float tanhf(float x); + constexpr long double tanhl(long double x); - @\placeholder{floating-point-type}@ exp(@\placeholder{floating-point-type}@ x); - float expf(float x); - long double expl(long double x); + constexpr @\placeholder{floating-point-type}@ exp(@\placeholder{floating-point-type}@ x); + constexpr float expf(float x); + constexpr long double expl(long double x); - @\placeholder{floating-point-type}@ exp2(@\placeholder{floating-point-type}@ x); - float exp2f(float x); - long double exp2l(long double x); + constexpr @\placeholder{floating-point-type}@ exp2(@\placeholder{floating-point-type}@ x); + constexpr float exp2f(float x); + constexpr long double exp2l(long double x); - @\placeholder{floating-point-type}@ expm1(@\placeholder{floating-point-type}@ x); - float expm1f(float x); - long double expm1l(long double x); + constexpr @\placeholder{floating-point-type}@ expm1(@\placeholder{floating-point-type}@ x); + constexpr float expm1f(float x); + constexpr long double expm1l(long double x); constexpr @\placeholder{floating-point-type}@ frexp(@\placeholder{floating-point-type}@ value, int* exp); constexpr float frexpf(float value, int* exp); @@ -9035,21 +9034,21 @@ constexpr float ldexpf(float x, int exp); constexpr long double ldexpl(long double x, int exp); - @\placeholder{floating-point-type}@ log(@\placeholder{floating-point-type}@ x); - float logf(float x); - long double logl(long double x); + constexpr @\placeholder{floating-point-type}@ log(@\placeholder{floating-point-type}@ x); + constexpr float logf(float x); + constexpr long double logl(long double x); - @\placeholder{floating-point-type}@ log10(@\placeholder{floating-point-type}@ x); - float log10f(float x); - long double log10l(long double x); + constexpr @\placeholder{floating-point-type}@ log10(@\placeholder{floating-point-type}@ x); + constexpr float log10f(float x); + constexpr long double log10l(long double x); - @\placeholder{floating-point-type}@ log1p(@\placeholder{floating-point-type}@ x); - float log1pf(float x); - long double log1pl(long double x); + constexpr @\placeholder{floating-point-type}@ log1p(@\placeholder{floating-point-type}@ x); + constexpr float log1pf(float x); + constexpr long double log1pl(long double x); - @\placeholder{floating-point-type}@ log2(@\placeholder{floating-point-type}@ x); - float log2f(float x); - long double log2l(long double x); + constexpr @\placeholder{floating-point-type}@ log2(@\placeholder{floating-point-type}@ x); + constexpr float log2f(float x); + constexpr long double log2l(long double x); constexpr @\placeholder{floating-point-type}@ logb(@\placeholder{floating-point-type}@ x); constexpr float logbf(float x); @@ -9067,9 +9066,9 @@ constexpr float scalblnf(float x, long int n); constexpr long double scalblnl(long double x, long int n); - @\placeholder{floating-point-type}@ cbrt(@\placeholder{floating-point-type}@ x); - float cbrtf(float x); - long double cbrtl(long double x); + constexpr @\placeholder{floating-point-type}@ cbrt(@\placeholder{floating-point-type}@ x); + constexpr float cbrtf(float x); + constexpr long double cbrtl(long double x); // \ref{c.math.abs}, absolute values constexpr int abs(int j); // freestanding @@ -9081,37 +9080,37 @@ constexpr float fabsf(float x); constexpr long double fabsl(long double x); - @\placeholder{floating-point-type}@ hypot(@\placeholder{floating-point-type}@ x, @\placeholder{floating-point-type}@ y); - float hypotf(float x, float y); - long double hypotl(long double x, long double y); + constexpr @\placeholder{floating-point-type}@ hypot(@\placeholder{floating-point-type}@ x, @\placeholder{floating-point-type}@ y); + constexpr float hypotf(float x, float y); + constexpr long double hypotl(long double x, long double y); // \ref{c.math.hypot3}, three-dimensional hypotenuse - @\placeholder{floating-point-type}@ hypot(@\placeholder{floating-point-type}@ x, @\placeholder{floating-point-type}@ y, - @\placeholder{floating-point-type}@ z); + constexpr @\placeholder{floating-point-type}@ hypot(@\placeholder{floating-point-type}@ x, @\placeholder{floating-point-type}@ y, + @\placeholder{floating-point-type}@ z); - @\placeholder{floating-point-type}@ pow(@\placeholder{floating-point-type}@ x, @\placeholder{floating-point-type}@ y); - float powf(float x, float y); - long double powl(long double x, long double y); + constexpr @\placeholder{floating-point-type}@ pow(@\placeholder{floating-point-type}@ x, @\placeholder{floating-point-type}@ y); + constexpr float powf(float x, float y); + constexpr long double powl(long double x, long double y); - @\placeholder{floating-point-type}@ sqrt(@\placeholder{floating-point-type}@ x); - float sqrtf(float x); - long double sqrtl(long double x); + constexpr @\placeholder{floating-point-type}@ sqrt(@\placeholder{floating-point-type}@ x); + constexpr float sqrtf(float x); + constexpr long double sqrtl(long double x); - @\placeholder{floating-point-type}@ erf(@\placeholder{floating-point-type}@ x); - float erff(float x); - long double erfl(long double x); + constexpr @\placeholder{floating-point-type}@ erf(@\placeholder{floating-point-type}@ x); + constexpr float erff(float x); + constexpr long double erfl(long double x); - @\placeholder{floating-point-type}@ erfc(@\placeholder{floating-point-type}@ x); - float erfcf(float x); - long double erfcl(long double x); + constexpr @\placeholder{floating-point-type}@ erfc(@\placeholder{floating-point-type}@ x); + constexpr float erfcf(float x); + constexpr long double erfcl(long double x); - @\placeholder{floating-point-type}@ lgamma(@\placeholder{floating-point-type}@ x); - float lgammaf(float x); - long double lgammal(long double x); + constexpr @\placeholder{floating-point-type}@ lgamma(@\placeholder{floating-point-type}@ x); + constexpr float lgammaf(float x); + constexpr long double lgammal(long double x); - @\placeholder{floating-point-type}@ tgamma(@\placeholder{floating-point-type}@ x); - float tgammaf(float x); - long double tgammal(long double x); + constexpr @\placeholder{floating-point-type}@ tgamma(@\placeholder{floating-point-type}@ x); + constexpr float tgammaf(float x); + constexpr long double tgammal(long double x); constexpr @\placeholder{floating-point-type}@ ceil(@\placeholder{floating-point-type}@ x); constexpr float ceilf(float x); @@ -9423,7 +9422,8 @@ \indexlibrary{\idxcode{hypot}!3-argument form}% \begin{itemdecl} -@\placeholder{floating-point-type}@ hypot(@\placeholder{floating-point-type}@ x, @\placeholder{floating-point-type}@ y, @\placeholder{floating-point-type}@ z); +constexpr @\placeholder{floating-point-type}@ hypot(@\placeholder{floating-point-type}@ x, @\placeholder{floating-point-type}@ y, + @\placeholder{floating-point-type}@ z); \end{itemdecl} \begin{itemdescr} From 8571e9454c7651995d72df8c3002bd97137304c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Fri, 21 Jul 2023 21:30:35 +0100 Subject: [PATCH 111/171] [version.syn] Bump value of __cpp_lib_constexpr_cmath --- source/support.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/support.tex b/source/support.tex index 87b4bec74a..7bf343e136 100644 --- a/source/support.tex +++ b/source/support.tex @@ -600,7 +600,7 @@ #define @\defnlibxname{cpp_lib_constexpr_algorithms}@ 202306L // also in \libheader{algorithm}, \libheader{utility} #define @\defnlibxname{cpp_lib_constexpr_bitset}@ 202207L // also in \libheader{bitset} #define @\defnlibxname{cpp_lib_constexpr_charconv}@ 202207L // also in \libheader{charconv} -#define @\defnlibxname{cpp_lib_constexpr_cmath}@ 202202L // also in \libheader{cmath}, \libheader{cstdlib} +#define @\defnlibxname{cpp_lib_constexpr_cmath}@ 202306L // also in \libheader{cmath}, \libheader{cstdlib} #define @\defnlibxname{cpp_lib_constexpr_complex}@ 201711L // also in \libheader{complex} #define @\defnlibxname{cpp_lib_constexpr_dynamic_alloc}@ 201907L // also in \libheader{memory} #define @\defnlibxname{cpp_lib_constexpr_functional}@ 201907L // freestanding, also in \libheader{functional} From a8be58be83e33870544ea7b756c18461418b2544 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Thu, 22 Jun 2023 12:52:11 -0700 Subject: [PATCH 112/171] P2734R0 Adding the new 2022 SI prefixes --- source/meta.tex | 56 ++++++++++++++++++++++++++++------------------ source/support.tex | 1 + 2 files changed, 35 insertions(+), 22 deletions(-) diff --git a/source/meta.tex b/source/meta.tex index 7a7ec3a140..1d9353add7 100644 --- a/source/meta.tex +++ b/source/meta.tex @@ -2541,26 +2541,30 @@ constexpr bool @\libglobal{ratio_greater_equal_v}@ = ratio_greater_equal::value; // \ref{ratio.si}, convenience SI typedefs - using @\libglobal{yocto}@ = ratio<1, 1'000'000'000'000'000'000'000'000>; // see below - using @\libglobal{zepto}@ = ratio<1, 1'000'000'000'000'000'000'000>; // see below - using @\libglobal{atto}@ = ratio<1, 1'000'000'000'000'000'000>; - using @\libglobal{femto}@ = ratio<1, 1'000'000'000'000'000>; - using @\libglobal{pico}@ = ratio<1, 1'000'000'000'000>; - using @\libglobal{nano}@ = ratio<1, 1'000'000'000>; - using @\libglobal{micro}@ = ratio<1, 1'000'000>; - using @\libglobal{milli}@ = ratio<1, 1'000>; - using @\libglobal{centi}@ = ratio<1, 100>; - using @\libglobal{deci}@ = ratio<1, 10>; - using @\libglobal{deca}@ = ratio< 10, 1>; - using @\libglobal{hecto}@ = ratio< 100, 1>; - using @\libglobal{kilo}@ = ratio< 1'000, 1>; - using @\libglobal{mega}@ = ratio< 1'000'000, 1>; - using @\libglobal{giga}@ = ratio< 1'000'000'000, 1>; - using @\libglobal{tera}@ = ratio< 1'000'000'000'000, 1>; - using @\libglobal{peta}@ = ratio< 1'000'000'000'000'000, 1>; - using @\libglobal{exa}@ = ratio< 1'000'000'000'000'000'000, 1>; - using @\libglobal{zetta}@ = ratio< 1'000'000'000'000'000'000'000, 1>; // see below - using @\libglobal{yotta}@ = ratio<1'000'000'000'000'000'000'000'000, 1>; // see below + using @\libglobal{quecto}@ = ratio<1, 1'000'000'000'000'000'000'000'000'000'000>; // see below + using @\libglobal{ronto}@ = ratio<1, 1'000'000'000'000'000'000'000'000'000>; // see below + using @\libglobal{yocto}@ = ratio<1, 1'000'000'000'000'000'000'000'000>; // see below + using @\libglobal{zepto}@ = ratio<1, 1'000'000'000'000'000'000'000>; // see below + using @\libglobal{atto}@ = ratio<1, 1'000'000'000'000'000'000>; + using @\libglobal{femto}@ = ratio<1, 1'000'000'000'000'000>; + using @\libglobal{pico}@ = ratio<1, 1'000'000'000'000>; + using @\libglobal{nano}@ = ratio<1, 1'000'000'000>; + using @\libglobal{micro}@ = ratio<1, 1'000'000>; + using @\libglobal{milli}@ = ratio<1, 1'000>; + using @\libglobal{centi}@ = ratio<1, 100>; + using @\libglobal{deci}@ = ratio<1, 10>; + using @\libglobal{deca}@ = ratio< 10, 1>; + using @\libglobal{hecto}@ = ratio< 100, 1>; + using @\libglobal{kilo}@ = ratio< 1'000, 1>; + using @\libglobal{mega}@ = ratio< 1'000'000, 1>; + using @\libglobal{giga}@ = ratio< 1'000'000'000, 1>; + using @\libglobal{tera}@ = ratio< 1'000'000'000'000, 1>; + using @\libglobal{peta}@ = ratio< 1'000'000'000'000'000, 1>; + using @\libglobal{exa}@ = ratio< 1'000'000'000'000'000'000, 1>; + using @\libglobal{zetta}@ = ratio< 1'000'000'000'000'000'000'000, 1>; // see below + using @\libglobal{yotta}@ = ratio< 1'000'000'000'000'000'000'000'000, 1>; // see below + using @\libglobal{ronna}@ = ratio< 1'000'000'000'000'000'000'000'000'000, 1>; // see below + using @\libglobal{quetta}@ = ratio<1'000'000'000'000'000'000'000'000'000'000, 1>; // see below } \end{codeblockdigitsep} @@ -2722,12 +2726,20 @@ \rSec2[ratio.si]{SI types for \tcode{ratio}} \pnum +\indexlibraryglobal{quecto}% +\indexlibraryglobal{ronto}% \indexlibraryglobal{yocto}% \indexlibraryglobal{zepto}% \indexlibraryglobal{zetta}% \indexlibraryglobal{yotta}% -For each of the \grammarterm{typedef-name}{s} \tcode{yocto}, \tcode{zepto}, -\tcode{zetta}, and \tcode{yotta}, if both of the constants used in its +\indexlibraryglobal{ronna}% +\indexlibraryglobal{quetta}% +For each of the \grammarterm{typedef-name}{s} +\tcode{quecto}, \tcode{ronto}, +\tcode{yocto}, \tcode{zepto}, +\tcode{zetta}, \tcode{yotta}, +\tcode{ronna}, and \tcode{quetta}, +if both of the constants used in its specification are representable by \tcode{intmax_t}, the typedef is defined; if either of the constants is not representable by \tcode{intmax_t}, the typedef is not defined. diff --git a/source/support.tex b/source/support.tex index 7bf343e136..9e4df0075a 100644 --- a/source/support.tex +++ b/source/support.tex @@ -731,6 +731,7 @@ #define @\defnlibxname{cpp_lib_ranges_to_container}@ 202202L // freestanding, also in \libheader{ranges} #define @\defnlibxname{cpp_lib_ranges_zip}@ 202110L // freestanding, also in \libheader{ranges}, \libheader{tuple}, \libheader{utility} +#define @\defnlibxname{cpp_lib_ratio}@ 202306L // also in \libheader{ratio} #define @\defnlibxname{cpp_lib_raw_memory_algorithms}@ 201606L // also in \libheader{memory} #define @\defnlibxname{cpp_lib_rcu}@ 202306L // also in \libheader{rcu} #define @\defnlibxname{cpp_lib_reference_from_temporary}@ 202202L // freestanding, also in \libheader{type_traits} From 86d15b67369711ae83600cdd381f5b8f02a8890e Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Thu, 22 Jun 2023 12:53:06 -0700 Subject: [PATCH 113/171] [ratio.syn] Use the \seebelow macro. --- source/meta.tex | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/source/meta.tex b/source/meta.tex index 1d9353add7..82c1f374c9 100644 --- a/source/meta.tex +++ b/source/meta.tex @@ -2541,10 +2541,10 @@ constexpr bool @\libglobal{ratio_greater_equal_v}@ = ratio_greater_equal::value; // \ref{ratio.si}, convenience SI typedefs - using @\libglobal{quecto}@ = ratio<1, 1'000'000'000'000'000'000'000'000'000'000>; // see below - using @\libglobal{ronto}@ = ratio<1, 1'000'000'000'000'000'000'000'000'000>; // see below - using @\libglobal{yocto}@ = ratio<1, 1'000'000'000'000'000'000'000'000>; // see below - using @\libglobal{zepto}@ = ratio<1, 1'000'000'000'000'000'000'000>; // see below + using @\libglobal{quecto}@ = ratio<1, 1'000'000'000'000'000'000'000'000'000'000>; // \seebelow + using @\libglobal{ronto}@ = ratio<1, 1'000'000'000'000'000'000'000'000'000>; // \seebelow + using @\libglobal{yocto}@ = ratio<1, 1'000'000'000'000'000'000'000'000>; // \seebelow + using @\libglobal{zepto}@ = ratio<1, 1'000'000'000'000'000'000'000>; // \seebelow using @\libglobal{atto}@ = ratio<1, 1'000'000'000'000'000'000>; using @\libglobal{femto}@ = ratio<1, 1'000'000'000'000'000>; using @\libglobal{pico}@ = ratio<1, 1'000'000'000'000>; @@ -2561,10 +2561,10 @@ using @\libglobal{tera}@ = ratio< 1'000'000'000'000, 1>; using @\libglobal{peta}@ = ratio< 1'000'000'000'000'000, 1>; using @\libglobal{exa}@ = ratio< 1'000'000'000'000'000'000, 1>; - using @\libglobal{zetta}@ = ratio< 1'000'000'000'000'000'000'000, 1>; // see below - using @\libglobal{yotta}@ = ratio< 1'000'000'000'000'000'000'000'000, 1>; // see below - using @\libglobal{ronna}@ = ratio< 1'000'000'000'000'000'000'000'000'000, 1>; // see below - using @\libglobal{quetta}@ = ratio<1'000'000'000'000'000'000'000'000'000'000, 1>; // see below + using @\libglobal{zetta}@ = ratio< 1'000'000'000'000'000'000'000, 1>; // \seebelow + using @\libglobal{yotta}@ = ratio< 1'000'000'000'000'000'000'000'000, 1>; // \seebelow + using @\libglobal{ronna}@ = ratio< 1'000'000'000'000'000'000'000'000'000, 1>; // \seebelow + using @\libglobal{quetta}@ = ratio<1'000'000'000'000'000'000'000'000'000'000, 1>; // \seebelow } \end{codeblockdigitsep} From 46eba7d25fcc07d596b2f1769d861c56f55c2cca Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Thu, 22 Jun 2023 15:43:07 -0700 Subject: [PATCH 114/171] P2548R6 copyable_function --- source/support.tex | 1 + source/utilities.tex | 471 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 472 insertions(+) diff --git a/source/support.tex b/source/support.tex index 9e4df0075a..51c24ba8ec 100644 --- a/source/support.tex +++ b/source/support.tex @@ -616,6 +616,7 @@ #define @\defnlibxname{cpp_lib_containers_ranges}@ 202202L // also in \libheader{vector}, \libheader{list}, \libheader{forward_list}, \libheader{map}, \libheader{set}, \libheader{unordered_map}, \libheader{unordered_set}, // \libheader{deque}, \libheader{queue}, \libheader{stack}, \libheader{string} +#define @\defnlibxname{cpp_lib_copyable_function}@ 202306L // also in \libheader{functional} #define @\defnlibxname{cpp_lib_coroutine}@ 201902L // also in \libheader{coroutine} #define @\defnlibxname{cpp_lib_destroying_delete}@ 201806L // freestanding, also in \libheader{new} #define @\defnlibxname{cpp_lib_enable_shared_from_this}@ 201603L // also in \libheader{memory} diff --git a/source/utilities.tex b/source/utilities.tex index 9bc7a9a8a4..f6a028ff5e 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -10649,6 +10649,11 @@ template class move_only_function; // \seebelow + // \ref{func.wrap.copy}, copyable wrapper + template class copyable_function; // \notdef + template + class copyable_function; // \seebelow + // \ref{func.wrap.ref}, non-owning wrapper template class function_ref; // freestanding, \notdef template @@ -12639,6 +12644,30 @@ Subclause \ref{func.wrap} describes polymorphic wrapper classes that encapsulate arbitrary callable objects. +\pnum +Let \tcode{t} be an object of a type that is a specialization of +\tcode{function}, \tcode{copyable_function}, or \tcode{move_only_function}, +such that the target object \tcode{x} of \tcode{t} has a type that +is a specialization of +\tcode{function}, \tcode{copyable_function}, or \tcode{move_only_function}. +Each argument of the +invocation of \tcode{x} evaluated as part of the invocation of \tcode{t} +may alias an argument in the same position in the invocation of \tcode{t} that +has the same type, even if the corresponding parameter is not of reference type. +\begin{example} +\begin{codeblock} +move_only_function + f{copyable_function{[](T) {}}}; +T t; +f(t); // it is unspecified how many copies of \tcode{T} are made +\end{codeblock} +\end{example} + +\pnum +\recommended +Implementations should avoid double wrapping when +constructing polymorphic wrappers from one another. + \rSec3[func.wrap.badcall]{Class \tcode{bad_function_call}}% \indexlibraryglobal{bad_function_call}% @@ -13513,6 +13542,448 @@ \tcode{true} if \tcode{f} has no target object, otherwise \tcode{false}. \end{itemdescr} +\rSec3[func.wrap.copy]{Copyable wrapper} + +\rSec4[func.wrap.copy.general]{General} + +\pnum +The header provides partial specializations of \tcode{copyable_function} +for each combination of the possible replacements +of the placeholders \cv{}, \placeholder{ref}, and \placeholder{noex} where +\begin{itemize} +\item +\cv{} is either const or empty, +\item +\placeholder{ref} is either \tcode{\&}, \tcode{\&\&}, or empty, and +\item +\placeholder{noex} is either \tcode{true} or \tcode{false}. +\end{itemize} + +\pnum +For each of the possible combinations of the placeholders mentioned above, +there is a placeholder \placeholder{inv-quals} defined as follows: +\begin{itemize} +\item +If \placeholder{ref} is empty, let \placeholder{inv-quals} be \cv{}\tcode{\&}, +\item +otherwise, let \placeholder{inv-quals} be \cv{} \placeholder{ref}. +\end{itemize} + +\rSec4[func.wrap.copy.class]{Class template \tcode{copyable_function}} + +\indexlibraryglobal{copyable_function}% +\begin{codeblock} +namespace std { + template + class copyable_function { + public: + using result_type = R; + + // \ref{func.wrap.copy.ctor}, constructors, assignments, and destructors + copyable_function() noexcept; + copyable_function(nullptr_t) noexcept; + copyable_function(const copyable_function&); + copyable_function(copyable_function&&) noexcept; + template copyable_function(F&&); + template + explicit copyable_function(in_place_type_t, Args&&...); + template + explicit copyable_function(in_place_type_t, initializer_list, Args&&...); + + copyable_function& operator=(const copyable_function&); + copyable_function& operator=(copyable_function&&); + copyable_function& operator=(nullptr_t) noexcept; + template copyable_function& operator=(F&&); + + ~copyable_function(); + + // \ref{func.wrap.copy.inv}, invocation + explicit operator bool() const noexcept; + R operator()(ArgTypes...) @\cv{}@ @\placeholder{ref}@ noexcept(@\placeholder{noex}@); + + // \ref{func.wrap.copy.util}, utility + void swap(copyable_function&) noexcept; + friend void swap(copyable_function&, copyable_function&) noexcept; + friend bool operator==(const copyable_function&, nullptr_t) noexcept; + + private: + template + static constexpr bool @\exposid{is-callable-from}@ = @\seebelow@; // \expos + }; +} +\end{codeblock} + +\pnum +The \tcode{copyable_function} class template provides polymorphic wrappers +that generalize the notion of a callable object\iref{func.def}. +These wrappers can store, copy, move, and call arbitrary callable objects, +given a call signature. +Within this subclause, \exposid{call-args} is an argument pack +with elements that have types \tcode{ArgTypes\&\&...} respectively. + +\pnum +\recommended +Implementations should avoid the use of dynamically allocated memory +for a small contained value. +\begin{note} +Such small-object optimization can only be applied to a type \tcode{T} +for which \tcode{is_nothrow_move_constructible_v} is \tcode{true}. +\end{note} + +\rSec4[func.wrap.copy.ctor]{Constructors, assignments, and destructors} + +\indextext{copyable_function::is-callable-from@\tcode{copyable_function::\exposid{is-callable-from}}}% +\begin{itemdecl} +template + static constexpr bool @\exposid{is-callable-from}@ = @\seebelow@; +\end{itemdecl} + +\begin{itemdescr} +\pnum +If \placeholder{noex} is \tcode{true}, +\tcode{\exposid{is-callable-from}} is equal to: +\begin{codeblock} +is_nothrow_invocable_r_v && +is_nothrow_invocable_r_v +\end{codeblock} +Otherwise, \tcode{\exposid{is-callable-from}} is equal to: +\begin{codeblock} +is_invocable_r_v && +is_invocable_r_v +\end{codeblock} +\end{itemdescr} + +\indexlibraryctor{copyable_function}% +\begin{itemdecl} +copyable_function() noexcept; +copyable_function(nullptr_t) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\ensures +\tcode{*this} has no target object. +\end{itemdescr} + +\indexlibraryctor{copyable_function}% +\begin{itemdecl} +copyable_function(const copyable_function& f); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\ensures +\tcode{*this} has no target object if \tcode{f} had no target object. +Otherwise, the target object of \tcode{*this} +is a copy of the target object of \tcode{f}. + +\pnum +\throws +Any exception thrown by the initialization of the target object. +May throw \tcode{bad_alloc}. +\end{itemdescr} + +\indexlibraryctor{copyable_function}% +\begin{itemdecl} +copyable_function(copyable_function&& f) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\ensures +The target object of \tcode{*this} is +the target object \tcode{f} had before construction, and +\tcode{f} is in a valid state with an unspecified value. +\end{itemdescr} + +\indexlibraryctor{copyable_function}% +\begin{itemdecl} +template copyable_function(F&& f); +\end{itemdecl} + +\begin{itemdescr} +\pnum +Let \tcode{VT} be \tcode{decay_t}. + +\pnum +\constraints +\begin{itemize} +\item +\tcode{remove_cvref_t} is not the same type as \tcode{copyable_function}, and +\item +\tcode{remove_cvref_t} is not a specialization of \tcode{in_place_type_t}, and +\item +\tcode{\exposid{is-callable-from}} is \tcode{true}. +\end{itemize} + +\pnum +\mandates +\begin{itemize} +\item +\tcode{is_constructible_v} is \tcode{true}, and +\item +\tcode{is_copy_constructible_v} is \tcode{true}. +\end{itemize} + +\pnum +\expects +\tcode{VT} meets the \oldconcept{Destructible} and +\oldconcept{CopyConstructible} requirements. + +\pnum +\ensures +\tcode{*this} has no target object if any of the following hold: +\begin{itemize} +\item +\tcode{f} is a null function pointer value, or +\item +\tcode{f} is a null member pointer value, or +\item +\tcode{remove_cvref_t} is a specialization of +the \tcode{copyable_function} class template, +and \tcode{f} has no target object. +\end{itemize} +Otherwise, \tcode{*this} has a target object of type \tcode{VT} +direct-non-list-initialized with \tcode{std::forward(f)}. + +\pnum +\throws +Any exception thrown by the initialization of the target object. +May throw \tcode{bad_alloc} unless \tcode{VT} is +a function pointer or a specialization of \tcode{reference_wrapper}. +\end{itemdescr} + +\indexlibraryctor{copyable_function}% +\begin{itemdecl} +template + explicit copyable_function(in_place_type_t, Args&&... args); +\end{itemdecl} + +\begin{itemdescr} +\pnum +Let \tcode{VT} be \tcode{decay_t}. + +\pnum +\constraints +\begin{itemize} +\item +\tcode{is_constructible_v} is \tcode{true}, and +\item +\tcode{\exposid{is-callable-from}} is \tcode{true}. +\end{itemize} + +\pnum +\mandates +\begin{itemize} +\item +\tcode{VT} is the same type as \tcode{T}, and +\item +\tcode{is_copy_constructible_v} is \tcode{true}. +\end{itemize} + +\pnum +\expects +\tcode{VT} meets the \oldconcept{Destructible} and +\oldconcept{CopyConstructible} requirements. + +\pnum +\ensures +\tcode{*this} has a target object of type \tcode{VT} +direct-non-list-initialized with \tcode{std::forward\brk{}(args)...}. + +\pnum +\throws +Any exception thrown by the initialization of the target object. +May throw \tcode{bad_alloc} unless \tcode{VT} is +a pointer or a specialization of \tcode{reference_wrapper}. +\end{itemdescr} + +\indexlibraryctor{copyable_function}% +\begin{itemdecl} +template + explicit copyable_function(in_place_type_t, initializer_list ilist, Args&&... args); +\end{itemdecl} + +\begin{itemdescr} +\pnum +Let \tcode{VT} be \tcode{decay_t}. + +\pnum +\constraints +\begin{itemize} +\item +\tcode{is_constructible_v\&, Args...>} is +\tcode{true}, and +\item +\tcode{\exposid{is-callable-from}} is \tcode{true}. +\end{itemize} + +\pnum +\mandates +\begin{itemize} +\item +\tcode{VT} is the same type as \tcode{T}, and +\item +\tcode{is_copy_constructible_v} is \tcode{true}. +\end{itemize} + +\pnum +\expects +\tcode{VT} meets the \oldconcept{Destructible} and +\oldconcept{CopyConstructible} requirements. + +\pnum +\ensures +\tcode{*this} has a target object of type \tcode{VT} +direct-non-list-initialized with +\tcode{ilist, std::for\-ward(args)...}. + +\pnum +\throws +Any exception thrown by the initialization of the target object. +May throw \tcode{bad_alloc} unless \tcode{VT} is +a pointer or a specialization of \tcode{reference_wrapper}. +\end{itemdescr} + +\indexlibrarymember{operator=}{copyable_function}% +\begin{itemdecl} +copyable_function& operator=(const copyable_function& f); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Equivalent to: \tcode{copyable_function(f).swap(*this);} + +\pnum +\returns +\tcode{*this}. +\end{itemdescr} + +\indexlibrarymember{operator=}{copyable_function}% +\begin{itemdecl} +copyable_function& operator=(copyable_function&& f); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Equivalent to: \tcode{copyable_function(std::move(f)).swap(*this);} + +\pnum +\returns +\tcode{*this}. +\end{itemdescr} + +\indexlibrarymember{operator=}{copyable_function}% +\begin{itemdecl} +copyable_function& operator=(nullptr_t) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Destroys the target object of \tcode{*this}, if any. + +\pnum +\returns +\tcode{*this}. +\end{itemdescr} + +\indexlibrarymember{operator=}{copyable_function}% +\begin{itemdecl} +template copyable_function& operator=(F&& f); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Equivalent to: \tcode{copyable_function(std::forward(f)).swap(*this);} + +\pnum +\returns +\tcode{*this}. +\end{itemdescr} + +\indexlibrarydtor{copyable_function}% +\begin{itemdecl} +~copyable_function(); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Destroys the target object of \tcode{*this}, if any. +\end{itemdescr} + +\rSec4[func.wrap.copy.inv]{Invocation} + +\indexlibrarymember{operator bool}{copyable_function}% +\begin{itemdecl} +explicit operator bool() const noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\returns +\tcode{true} if \tcode{*this} has a target object, otherwise \tcode{false}. +\end{itemdescr} + +\indexlibrarymember{operator()}{copyable_function}% +\begin{itemdecl} +R operator()(ArgTypes... args) @\cv{}@ @\placeholder{ref}@ noexcept(@\placeholder{noex}@); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\expects +\tcode{*this} has a target object. + +\pnum +\effects +Equivalent to: +\begin{codeblock} +return @\placeholder{INVOKE}@(static_cast(f), std::forward(args)...); +\end{codeblock} +where \tcode{f} is an lvalue designating the target object of \tcode{*this} and +\tcode{F} is the type of \tcode{f}. +\end{itemdescr} + +\rSec4[func.wrap.copy.util]{Utility} + +\indexlibrarymember{swap}{copyable_function}% +\begin{itemdecl} +void swap(copyable_function& other) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Exchanges the target objects of \tcode{*this} and \tcode{other}. +\end{itemdescr} + +\indexlibrarymember{swap}{copyable_function}% +\begin{itemdecl} +friend void swap(copyable_function& f1, copyable_function& f2) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\effects +Equivalent to \tcode{f1.swap(f2)}. +\end{itemdescr} + +\indexlibrarymember{operator==}{copyable_function}% +\begin{itemdecl} +friend bool operator==(const copyable_function& f, nullptr_t) noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\returns +\tcode{true} if \tcode{f} has no target object, otherwise \tcode{false}. +\end{itemdescr} + \rSec3[func.wrap.ref]{Non-owning wrapper} \rSec4[func.wrap.ref.general]{General} From 8f14cc450327c775e8b69e19024a85a79f931b9e Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Tue, 27 Jun 2023 23:15:01 -0700 Subject: [PATCH 115/171] [func.wrap.copy.class] Remove statement about unused /call-args/ added in P2548R6. --- source/utilities.tex | 2 -- 1 file changed, 2 deletions(-) diff --git a/source/utilities.tex b/source/utilities.tex index f6a028ff5e..6c81969930 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -13618,8 +13618,6 @@ that generalize the notion of a callable object\iref{func.def}. These wrappers can store, copy, move, and call arbitrary callable objects, given a call signature. -Within this subclause, \exposid{call-args} is an argument pack -with elements that have types \tcode{ArgTypes\&\&...} respectively. \pnum \recommended From de75ee6130ce65ee60794155c716efb803facb99 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Thu, 22 Jun 2023 12:01:11 -0700 Subject: [PATCH 116/171] P2714R1 Bind front and back to NTTP callables --- source/support.tex | 6 +-- source/utilities.tex | 100 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 103 insertions(+), 3 deletions(-) diff --git a/source/support.tex b/source/support.tex index 51c24ba8ec..01c4f4649c 100644 --- a/source/support.tex +++ b/source/support.tex @@ -576,8 +576,8 @@ #define @\defnlibxname{cpp_lib_atomic_value_initialization}@ 201911L // freestanding, also in \libheader{atomic}, \libheader{memory} #define @\defnlibxname{cpp_lib_atomic_wait}@ 201907L // freestanding, also in \libheader{atomic} #define @\defnlibxname{cpp_lib_barrier}@ 202302L // also in \libheader{barrier} -#define @\defnlibxname{cpp_lib_bind_back}@ 202202L // freestanding, also in \libheader{functional} -#define @\defnlibxname{cpp_lib_bind_front}@ 201907L // freestanding, also in \libheader{functional} +#define @\defnlibxname{cpp_lib_bind_back}@ 202306L // freestanding, also in \libheader{functional} +#define @\defnlibxname{cpp_lib_bind_front}@ 202306L // freestanding, also in \libheader{functional} #define @\defnlibxname{cpp_lib_bit_cast}@ 201806L // freestanding, also in \libheader{bit} #define @\defnlibxname{cpp_lib_bitops}@ 201907L // freestanding, also in \libheader{bit} #define @\defnlibxname{cpp_lib_bitset}@ 202306L // also in \libheader{bitset} @@ -704,7 +704,7 @@ #define @\defnlibxname{cpp_lib_nonmember_container_access}@ 201411L // freestanding, also in \libheader{array}, \libheader{deque}, \libheader{forward_list}, \libheader{iterator}, \libheader{list}, \libheader{map}, \libheader{regex}, \libheader{set}, // \libheader{string}, \libheader{unordered_map}, \libheader{unordered_set}, \libheader{vector} -#define @\defnlibxname{cpp_lib_not_fn}@ 201603L // freestanding, also in \libheader{functional} +#define @\defnlibxname{cpp_lib_not_fn}@ 202306L // freestanding, also in \libheader{functional} #define @\defnlibxname{cpp_lib_null_iterators}@ 201304L // freestanding, also in \libheader{iterator} #define @\defnlibxname{cpp_lib_optional}@ 202110L // also in \libheader{optional} #define @\defnlibxname{cpp_lib_out_ptr}@ 202106L // also in \libheader{memory} diff --git a/source/utilities.tex b/source/utilities.tex index 6c81969930..663575d18a 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -10594,12 +10594,17 @@ // \ref{func.not.fn}, function template \tcode{not_fn} template constexpr @\unspec@ not_fn(F&& f); // freestanding + template constexpr @\unspec@ not_fn() noexcept; // freestanding // \ref{func.bind.partial}, function templates \tcode{bind_front} and \tcode{bind_back} template constexpr @\unspec@ bind_front(F&&, Args&&...); // freestanding + template + constexpr @\unspec@ bind_front(Args&&...); // freestanding template constexpr @\unspec@ bind_back(F&&, Args&&...); // freestanding + template + constexpr @\unspec@ bind_back(Args&&...); // freestanding // \ref{func.bind}, bind template struct is_bind_expression; // freestanding @@ -12303,6 +12308,36 @@ Any exception thrown by the initialization of \tcode{fd}. \end{itemdescr} +\indexlibraryglobal{not_fn}% +\begin{itemdecl} +template constexpr @\unspec@ not_fn() noexcept; +\end{itemdecl} + +\begin{itemdescr} +\pnum +In the text that follows: +\begin{itemize} +\item +\tcode{F} is the type of \tcode{f}, +\item +\tcode{g} is a value of the result of a \tcode{not_fn} invocation, +\item +\tcode{call_args} is an argument pack +used in a function call expression\iref{expr.call} of \tcode{g}. +\end{itemize} + +\pnum +\mandates +If \tcode{is_pointer_v || is_member_pointer_v} is \tcode{true}, +then \tcode{f != nullptr} is \tcode{true}. + +\pnum +\returns +A perfect forwarding call wrapper\iref{func.require} \tcode{g} that +does not have state entities, and +has the call pattern \tcode{!invoke(f, call_args...)}. +\end{itemdescr} + \rSec2[func.bind.partial]{Function templates \tcode{bind_front} and \tcode{bind_back}} \indexlibraryglobal{bind_front}% @@ -12371,6 +12406,71 @@ the initialization of the state entities of \tcode{g}\iref{func.def}. \end{itemdescr} +\indexlibraryglobal{bind_front}% +\indexlibraryglobal{bind_back}% +\begin{itemdecl} +template + constexpr @\unspec@ bind_front(Args&&... args); +template + constexpr @\unspec@ bind_back(Args&&... args); +\end{itemdecl} + +\begin{itemdescr} +\pnum +Within this subclause: +\begin{itemize} +\item +\tcode{F} is the type of \tcode{f}, +\item +\tcode{g} is a value of the result of +a \tcode{bind_front} or \tcode{bind_back} invocation, +\item +\tcode{BoundArgs} is a pack that denotes \tcode{decay_t...}, +\item +\tcode{bound_args} is a pack of bound argument entities of +\tcode{g}\iref{func.def} of types \tcode{BoundArgs...}, +direct-non-list-initialized with \tcode{std::forward(args)...}, +respectively, and +\item +\tcode{call_args} is an argument pack used in +a function call expression\iref{expr.call} of \tcode{g}. +\end{itemize} + +\pnum +\mandates +\begin{itemize} +\item +\tcode{(is_constructible_v \&\& ...)} is \tcode{true}, and +\item +\tcode{(is_move_constructible_v \&\& ...)} is \tcode{true}, and +\item +if \tcode{is_pointer_v || is_member_pointer_v} is \tcode{true}, +then \tcode{f != nullptr} is \tcode{true}. +\end{itemize} + +\pnum +\expects +For each $\tcode{T}_i$ in \tcode{BoundArgs}, +$\tcode{T}_i$ meets the \oldconcept{MoveConstructible} requirements. + +\pnum +\returns +A perfect forwarding call wrapper\iref{func.require} \tcode{g} that +does not have a target object, and has the call pattern: +\begin{itemize} +\item +\tcode{invoke(f, bound_args..., call_args...)} +for a \tcode{bind_front} invocation, or +\item +\tcode{invoke(f, call_args..., bound_args...)} +for a \tcode{bind_back} invocation. +\end{itemize} + +\pnum +throws +Any exception thrown by the initialization of \tcode{bound_args}. +\end{itemdescr} + \rSec2[func.bind]{Function object binders}% \rSec3[func.bind.general]{General}% From 008addc3fae41e46c301589b93f0c908cc7f4e0d Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Thu, 22 Jun 2023 10:00:35 -0700 Subject: [PATCH 117/171] P2630R4 submdspan Editorial notes: - [mdspan.submdspan.submdspan] Fix typo: "args" should say "slices". - [mdspan.submdspan.overview] Change "subsection" to "subclause". - [mdspan.submdspan.extents] Fix comma placement. - [mdspan.submdspan.extents] "for each" instead of "for all". - [mdspan.submdspan.submdspan, mdspan.syn] Fix cross-reference. - [mdspan.submdspan.submdspan] Fix punctuation in itemized list. --- source/containers.tex | 683 ++++++++++++++++++++++++++++++++++++++++++ source/lib-intro.tex | 7 +- source/support.tex | 1 + 3 files changed, 689 insertions(+), 2 deletions(-) diff --git a/source/containers.tex b/source/containers.tex index 327193c7e9..729ea0d19d 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -18995,6 +18995,38 @@ template> class mdspan; + + // \ref{mdspan.submdspan}, \tcode{submdspan} creation + template + struct strided_slice; + + template + struct submdspan_mapping_result; + + template + constexpr auto submdspan_extents(const extents&, SliceSpecifiers...); + + // \ref{mdspan.submdspan.submdspan}, \tcode{submdspan} function + template + constexpr auto submdspan( + const mdspan& src, + SliceSpecifiers... slices) -> @\seebelow@; + + template + concept @\defexposconcept{integral-constant-like}@ = // \expos + is_integral_v && + !is_same_v> && + @\libconcept{convertible_to}@ && + @\libconcept{equality_comparable_with}@ && + bool_constant::value && + bool_constant(T()) == T::value>::value; + + template + concept @\defexposconcept{index-pair-like}@ = // \expos + @\exposconcept{pair-like}@ && + @\libconcept{convertible_to}@, IndexType> && + @\libconcept{convertible_to}@, IndexType>; } \end{codeblock} @@ -19808,6 +19840,17 @@ private: extents_type @\exposid{extents_}@{}; // \expos + + // \ref{mdspan.submdspan.mapping}, \tcode{submdspan} mapping specialization + template + constexpr auto @\exposid{submdspan-mapping-impl}@( // \expos + SliceSpecifiers... slices) const -> @\seebelow@; + + template + friend constexpr auto submdspan_mapping( + const mapping& src, SliceSpecifiers... slices) { + return src.@\exposid{submdspan-mapping-impl}@(slices...); + } }; } \end{codeblock} @@ -20066,6 +20109,17 @@ private: extents_type @\exposid{extents_}@{}; // \expos + + // \ref{mdspan.submdspan.mapping}, \tcode{submdspan} mapping specialization + template + constexpr auto @\exposid{submdspan-mapping-impl}@( // \expos + SliceSpecifiers... slices) const -> @\seebelow@; + + template + friend constexpr auto submdspan_mapping( + const mapping& src, SliceSpecifiers... slices) { + return src.@\exposid{submdspan-mapping-impl}@(slices...); + } }; } \end{codeblock} @@ -20326,6 +20380,17 @@ private: extents_type @\exposid{extents_}@{}; // \expos array @\exposid{strides_}@{}; // \expos + + // \ref{mdspan.submdspan.mapping}, \tcode{submdspan} mapping specialization + template + constexpr auto @\exposid{submdspan-mapping-impl}@( // \expos + SliceSpecifiers... slices) const -> @\seebelow@; + + template + friend constexpr auto submdspan_mapping( + const mapping& src, SliceSpecifiers... slices) { + return src.@\exposid{submdspan-mapping-impl}@(slices...); + } }; } \end{codeblock} @@ -21425,3 +21490,621 @@ swap(x.@\exposid{acc_}@, y.@\exposid{acc_}@); \end{codeblock} \end{itemdescr} + +\rSec3[mdspan.submdspan]{\tcode{submdspan}} + +\rSec4[mdspan.submdspan.overview]{Overview} + +\pnum +The \tcode{submdspan} facilities create a new \tcode{mdspan} +viewing a subset of elements of an existing input \tcode{mdspan}. +The subset viewed by the created \tcode{mdspan} is determined by +the \tcode{SliceSpecifier} arguments. + +\pnum +For each function defined in subclause \ref{mdspan.submdspan} that +takes a parameter pack named \tcode{slices} as an argument: + +\begin{itemize} +\item let \tcode{index_type} be + \begin{itemize} + \item + \tcode{M::index_type} + if the function is a member of a class \tcode{M}, otherwise + \item + \tcode{remove_reference_t::index_type} + if the function has a parameter named \tcode{src}, otherwise + \item + the same type as the function's template argument \tcode{IndexType}; + \end{itemize} +\item let \tcode{rank} be the number of elements in \tcode{slices}; +\item let $s_k$ be the $k^\text{th}$ element of \tcode{slices}; +\item let $S_k$ be the type of $s_k$; and +\item let \tcode{\placeholder{map-rank}} be an \tcode{array} such that +for each $k$ in the range \range{0}{rank}, +\tcode{\placeholder{map-rank}[$k$]} equals: + \begin{itemize} + \item + \tcode{dynamic_extent} + if $S_k$ models \tcode{\libconcept{convertible_to}}, otherwise + \item + the number of types $S_j$ with $j < k$ that + do not model \tcode{\libconcept{convertible_to}}. + \end{itemize} +\end{itemize} + +\rSec4[mdspan.submdspan.strided.slice]{\tcode{strided_slice}} + +\pnum +\tcode{strided_slice} represents a set of +\tcode{extent} regularly spaced integer indices. +The indices start at \tcode{offset}, and +increase by increments of \tcode{stride}. + +\indexlibraryglobal{strided_slice}% +\begin{itemdecl} +template +struct strided_slice { + using offset_type = OffsetType; + using extent_type = ExtentType; + using stride_type = StrideType; + + [[no_unique_address]] OffsetType offset{}; + [[no_unique_address]] ExtentType extent{}; + [[no_unique_address]] StrideType stride{}; +}; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\tcode{strided_slice} has the data members and special members specified above. +It has no base classes or members other than those specified. + +\pnum +\mandates +\tcode{OffsetType}, \tcode{ExtentType}, and \tcode{StrideType} +are signed or unsigned integer types, or +model \exposconcept{integral-constant-like}. +\begin{note} +\tcode{strided_slice\{.offset=1, .extent=10, .stride=3\}} +indicates the indices \tcode{1}, \tcode{4}, \tcode{7}, and \tcode{10}. +Indices are selected from the half-open interval \range{1}{1 + 10}. +\end{note} +\end{itemdescr} + +\rSec4[mdspan.submdspan.submdspan.mapping.result]{\tcode{submdspan_mapping_result}} + +\pnum +Specializations of \tcode{submdspan_mapping_result} +are returned by overloads of \tcode{submdspan_mapping}. + +\indexlibraryglobal{submdspan_mapping_result}% +\begin{itemdecl} +template +struct submdspan_mapping_result { + [[no_unique_address]] LayoutMapping mapping = LayoutMapping(); + size_t offset{}; +}; +\end{itemdecl} + +\begin{itemdescr} +\pnum +\tcode{submdspan_mapping_result} has +the data members and special members specified above. +It has no base classes or members other than those specified. + +\pnum +\tcode{LayoutMapping} shall meet +the layout mapping requirements\iref{mdspan.layout.policy.reqmts}. +\end{itemdescr} + +\rSec4[mdspan.submdspan.helpers]{Exposition-only helpers} + +\indexlibraryglobal{\exposid{de-ice}}% +\indexlibraryglobal{\exposid{first_}}% +\begin{itemdecl} +template + constexpr T @\exposid{de-ice}@(T val) { return val; } +template<@\exposconcept{integral-constant-like}@ T> + constexpr auto @\exposid{de-ice}@(T) { return T::value; } + +template + constexpr IndexType @\exposid{first_}@(SliceSpecifiers... slices); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\mandates +\tcode{IndexType} is a signed or unsigned integer type. + +%FIXME: What is $k$ in this itemdescr? Did we mean the \tcode{k} passed to first_? If so, what do we do for de-ice? +\pnum +Let $\phi{}_k$ denote the following value: +\begin{itemize} +\item +$s_k$ if $S_k$ models \tcode{\libconcept{convertible_to}}; otherwise +\item +\tcode{get<0>($s_k$)} +if $S_k$ models \tcode{\exposconcept{index-pair-like}}; otherwise +\item +\tcode{\exposid{de-ice}($s_k$.offset)} +if $S_k$ is a specialization of \tcode{strided_slice}; otherwise +\item +\tcode{0}. +\end{itemize} + +\pnum +\expects +$\phi{}_k$ is representable as a value of type \tcode{IndexType}. + +\pnum +\returns +\tcode{extents::\exposid{index-cast}($\phi{}_k$)}. +\end{itemdescr} + +\indexlibraryglobal{\exposid{last_}}% +\begin{itemdecl} +template + constexpr auto @\exposid{last_}@(const Extents& src, SliceSpecifiers... slices); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\mandates +\tcode{Extents} is a specialization of \tcode{extents}. + +\pnum +Let \tcode{index_type} name the type \tcode{typename Extents::index_type}. + +%FIXME: What is $k$ in this itemdescr? Don't we want \tcode{k} and not $k$? +\pnum +Let $\lambda{}_k$ denote the following value: +\begin{itemize} +\item +\tcode{\exposid{de-ice}($s_k$) + 1} +if $S_k$ models \tcode{\libconcept{convertible_to}}; otherwise +\item +\tcode{get<1>($s_k$)} +if $S_k$ models \tcode{\exposconcept{index-pair-like}}; otherwise +\item +\tcode{\exposid{de-ice}($s_k$.offset)} \tcode{+} +\tcode{\exposid{de-ice}($s_k$.extent)} +if $S_k$ is a specialization of \tcode{strided_slice}; otherwise +\item +%FIXME: Note that the paper uses \tcode{k} here. +\tcode{src.extent(k)}. +\end{itemize} + +\pnum +\expects +$\lambda{}_k$ is representable as a value of type \tcode{index_type}. + +\pnum +\returns +\tcode{Extents::\exposid{index-cast}($\lambda{}_k$)}. +\end{itemdescr} + +\indexlibraryglobal{\exposid{src-indices}}% +\begin{itemdecl} +template + constexpr array + @\exposid{src-indices}@(const array& indices, SliceSpecifiers... slices); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\mandates +\tcode{IndexType} is a signed or unsigned integer type. + +\pnum +\returns +An \tcode{array src_idx} such that +for each $k$ in the range \range{0}{sizeof...(SliceSpecifiers)}, +\tcode{src_idx[$k$]} equals + +\begin{itemize} +\item +%FIXME: We're redefining what $k$ is here. +%FIXME: Also, calling first_ on each $k$ below gives us a set of indeces - how do we assign a set to the src_idx[$k$] above? +\tcode{\exposid{first_}(slices...)} for each $k$ +where \tcode{\placeholder{map-rank}[$k$]} equals +\tcode{dynamic_extent}, otherwise + +\item +\tcode{\exposid{first_}(slices...)} \tcode{+} +\tcode{indices[\placeholder{map-rank}[$k$]]}. +\end{itemize} +\end{itemdescr} + +\rSec4[mdspan.submdspan.extents]{\tcode{submdspan_extents} function} + +\indexlibraryglobal{submdspan_extents}% +\begin{itemdecl} +template + constexpr auto submdspan_extents(const extents& src, + SliceSpecifiers... slices); +\end{itemdecl} + +\begin{itemdescr} +\pnum +\constraints +\tcode{sizeof...(slices)} equals \tcode{Extents::rank()}. + +\pnum +\mandates +For each rank index $k$ of \tcode{src.extents()}, +exactly one of the following is true: +\begin{itemize} +\item $S_k$ models \tcode{\libconcept{convertible_to}} +\item $S_k$ models \tcode{\exposconcept{index-pair-like}} +\item \tcode{is_convertible_v<$S_k$, full_extent_t>} is \tcode{true} +\item $S_k$ is a specialization of \tcode{strided_slice} +\end{itemize} + +\pnum +\expects +For each rank index $k$ of \tcode{src.extents()}, +all of the following are \tcode{true}: +\begin{itemize} +\item +if $S_k$ is a specialization of \tcode{strided_slice} + \begin{itemize} + \item $\tcode{$s_k$.extent = 0}$, or + \item $\tcode{$s_k$.stride > 0}$ + \end{itemize} +\item +$0 \le \tcode{\exposid{first_}(slices...)}$ +$\le \tcode{\exposid{last_}<$k$>(src, slices...)}$ +$\le \tcode{src.extent($k$)}$ +\end{itemize} + +\pnum +Let \tcode{SubExtents} be a specialization of \tcode{extents} such that: + +\begin{itemize} +\item +%FIXME: I think we want the count here, "number" is ambiguous. +\tcode{SubExtents::rank()} equals the number of $k$ such that +$S_k$ does not model \tcode{\libconcept{convertible_to}}; and + +\item +for each rank index $k$ of \tcode{Extents} such that +\tcode{\placeholder{map-rank}[$k$] != dynamic_extent} is \tcode{true}, +\tcode{SubExt\-ents::static_extent(\placeholder{map-rank}[$k$])} equals: + + \begin{itemize} + \item + \tcode{Extents::static_extent($k$)} + if \tcode{is_convertible_v<$S_k$, full_extent_t>} is \tcode{true}; + otherwise + + \item + \tcode{\exposid{de-ice}(tuple_element_t<1, $S_k$>()) -} + \tcode{\exposid{de-ice}(tuple_element_t<0, $S_k$>())} + if $S_k$ models \tcode{\exposconcept{index-pair-like}}, and + both \tcode{tuple_element_t<0, $S_k$>} and + \tcode{tuple_elem\-ent_t<1, $S_k$>} + model \exposconcept{integral-constant-like}; otherwise + + \item + \tcode{0}, + if $S_k$ is a specialization of \tcode{strided_slice}, whose + \tcode{extent_type} models \exposconceptx{integral-cons\-tant-like}{integral-constant-like}, + for which \tcode{extent_type()} equals zero; otherwise + + \item + \tcode{1 + (\exposid{de-ice}($S_k$::extent_type()) - 1) /} + \tcode{\exposid{de-ice}($S_k$::stride_type())}, + if $S_k$ is a specialization of \tcode{strided_slice} whose + \tcode{extent_type} and \tcode{stride_type} + model \exposconceptx{integral-cons\-tant-like}{integral-constant-like}; otherwise + + \item + \tcode{dynamic_extent}. + \end{itemize} +\end{itemize} + +\pnum +\returns +A value \tcode{ext} of type \tcode{SubExtents} such that +for each $k$ +for which \tcode{\placeholder{map-rank}[$k$] != dynamic_extent} is \tcode{true}: + +\begin{itemize} +\item +\tcode{ext.extent(\placeholder{map-rank}[$k$])} equals +\tcode{$s_k$.extent == 0 ? 0 : 1 + (\exposid{de-ice}($s_k$.extent) - 1) /}\linebreak{} +\tcode{\exposid{de-ice}($s_k$.stride)} +if $S_k$ is a specialization of \tcode{strided_slice}, otherwise + +\item +\tcode{ext.extent(\placeholder{map-rank}[$k$])} equals +\tcode{\exposid{last_}<$k$>(src, slices...) -} +\tcode{\exposid{first_}(\linebreak{}slices...)}. +\end{itemize} +\end{itemdescr} + +\rSec4[mdspan.submdspan.mapping]{Layout specializations of \tcode{submdspan_mapping}} + +\indexlibrarymemberexpos{layout_stride::mapping}{submdspan-mapping-impl}% +\indexlibrarymemberexpos{layout_left::mapping}{submdspan-mapping-impl}% +\indexlibrarymemberexpos{layout_right::mapping}{submdspan-mapping-impl}% +\begin{itemdecl} +template + template + constexpr auto layout_left::mapping::@\exposid{submdspan-mapping-impl}@( // \expos + SliceSpecifiers... slices) const -> @\seebelow@; + +template + template + constexpr auto layout_right::mapping::@\exposid{submdspan-mapping-impl}@( // \expos + SliceSpecifiers... slices) const -> @\seebelow@; + +template + template + constexpr auto layout_stride::mapping::@\exposid{submdspan-mapping-impl}@( // \expos + SliceSpecifiers... slices) const -> @\seebelow@; +\end{itemdecl} + +\begin{itemdescr} +\pnum +Let \tcode{index_type} name the type \tcode{typename Extents::index_type}. + +\pnum +\constraints +\tcode{sizeof...(slices)} equals \tcode{Extents::rank()}. + +\pnum +\mandates +For each rank index $k$ of \tcode{extents()}, +exactly one of the following is true: +\begin{itemize} +\item $S_k$ models \tcode{\libconcept{convertible_to}} +\item $S_k$ models \tcode{\exposconcept{index-pair-like}} +\item \tcode{is_convertible_v<$S_k$, full_extent_t>} is \tcode{true} +\item $S_k$ is a specialization of \tcode{strided_slice} +\end{itemize} + +\pnum +\expects +For each rank index $k$ of \tcode{extents()}, +all of the following are \tcode{true}: +\begin{itemize} +\item +if $S_k$ is a specialization of \tcode{strided_slice} + \begin{itemize} + \item $\tcode{$s_k$.extent} = 0$, or + \item $\tcode{$s_k$.stride} > 0$ + \end{itemize} +\item +$0 \le \tcode{\exposid{first_}(slices...)} \\ +\hphantom{0 } \le \tcode{\exposid{last_}<$k$>(extents(), slices...)} \\ +\hphantom{0 } \le \tcode{extents().extent($k$)}$ +\end{itemize} + +\pnum +Let \tcode{sub_ext} be the result of +\tcode{submdspan_extents(extents(), slices...)} and +let \tcode{SubExtents} be \tcode{decltype(sub_ext)}. + +\pnum +Let \tcode{sub_strides} be +an \tcode{array} such that +for each rank index $k$ of \tcode{extents()} +for which \tcode{\placeholder{map-rank}[$k$]} is not \tcode{dynamic_extent}, +\tcode{sub_strides[\placeholder{map-rank}[\linebreak{}$k$]]} equals: + +\begin{itemize} +\item +\tcode{stride($k$) * \exposid{de-ice}($s_k$.stride)} +if $S_k$ is a specialization of \tcode{strided_slice} and +\tcode{$s_k$.stride < $s_k$.extent}; otherwise + +\item +\tcode{stride($k$)}. +\end{itemize} + +\pnum +Let \tcode{P} be a parameter pack such that +\tcode{is_same_v, index_sequence<\linebreak{}P...>>} +is \tcode{true}. + +\pnum +Let \tcode{offset} be a value of type \tcode{size_t} +equal to \tcode{(*this)(\exposid{first_}(slices...)...)}. + +\pnum +\returns +\begin{itemize} +\item +\tcode{submdspan_mapping_result\{*this, 0\}}, +if \tcode{Extents::rank() == 0} is \tcode{true}; otherwise + +\item +\tcode{submdspan_mapping_result\{layout_left::mapping(sub_ext), offset\}}, +if + \begin{itemize} + \item + \tcode{layout_type} is \tcode{layout_left}; and + \item + for each $k$ in the range \range{0}{SubExtents::rank() - 1)}, + \tcode{is_convertible_v<$S_k$, full_ext\-ent_t>} is \tcode{true}; and + \item + for $k$ equal to \tcode{SubExtents::rank() - 1}, + $S_k$ models \tcode{\exposconcept{index-pair-like}} or +%FIXME: Dangling "otherwise" in nested itemized list is lost, reword to move "otherwise" to start of alternate items + \tcode{is_convertible_v<$S_k$, full_extent_t>} is \tcode{true}; + otherwise + \end{itemize} +\begin{note} +If the above conditions are true, +all $S_k$ with $k$ larger than \tcode{SubExtents::rank() - 1} +are convertible to \tcode{index_type}. +\end{note} + +\item +\tcode{submdspan_mapping_result\{layout_right::mapping(sub_ext), offset\}}, +if + \begin{itemize} + \item + \tcode{layout_type} is \tcode{layout_right}; and + \item + for each $k$ in the range + \range{Extents::rank() - SubExtents::rank() + 1}{Extents::rank()}, + \tcode{is_convertible_v<$S_k$, full_extent_t>} is \tcode{true}; and + \item + for $k$ equal to \tcode{Extents::rank() - SubExtents::rank()}, + $S_k$ models \tcode{\exposconcept{index-pair-like}} or +%FIXME: Dangling "otherwise" in nested itemized list is lost + \tcode{is_convertible_v<$S_k$, full_extent_t>} is \tcode{true}; otherwise + \end{itemize} +\begin{note} +If the above conditions are true, +all $S_k$ with $k < \tcode{Extents::rank() - SubExtents::rank()}$ +are convertible to \tcode{index_type}. +\end{note} + +\item +\tcode{submdspan_mapping_result\{layout_stride::mapping(sub_ext, sub_strides), offset\}}. +\end{itemize} +\end{itemdescr} + +\rSec4[mdspan.submdspan.submdspan]{\tcode{submdspan} function} + +\indexlibraryglobal{submdspan}% +\begin{itemdecl} +template + constexpr auto submdspan( + const mdspan& src, + SliceSpecifiers... slices) -> @\seebelow@; +\end{itemdecl} + +\begin{itemdescr} +\pnum +Let \tcode{index_type} name the type \tcode{typename Extents::index_type}. + +\pnum +Let \tcode{sub_map_offset} be the result of +\tcode{submdspan_mapping(src.mapping(), slices...)}. +\begin{note} +This invocation of \tcode{submdspan_mapping} +selects a function call via overload resolution +on a candidate set that includes the lookup set +found by argument-dependent lookup\iref{basic.lookup.argdep}. +\end{note} + +\pnum +\constraints +\begin{itemize} +\item +\tcode{sizeof...(slices)} equals \tcode{Extents::rank()}, and +\item +the expression \tcode{submdspan_mapping(src.mapping(), slices...)} +is well-formed when treated as an unevaluated operand. +\end{itemize} + +\pnum +\mandates +\begin{itemize} +\item +\tcode{decltype(submdspan_mapping(src.mapping(), slices...))} +is a specialization of \tcode{submd-\linebreak{}span_mapping_result}. + +\item +\tcode{is_same_v,} +\tcode{decltype(\linebreak{}submdspan_extents(src.mapping(), slices...))>} +is \tcode{true}. + +\item +For each rank index $k$ of \tcode{src.extents()}, +exactly one of the following is true: + \begin{itemize} + \item $S_k$ models \tcode{\libconcept{convertible_to}} + \item $S_k$ models \tcode{\exposconcept{index-pair-like}} + \item \tcode{is_convertible_v<$S_k$, full_extent_t>} is \tcode{true} + \item $S_k$ is a specialization of \tcode{strided_slice} + \end{itemize} +\end{itemize} + +\pnum +\expects +\begin{itemize} +\item +For each rank index $k$ of \tcode{src.extents()}, +all of the following are \tcode{true}: + \begin{itemize} + \item + if $S_k$ is a specialization of \tcode{strided_slice} + \begin{itemize} + \item $\tcode{$s_k$.extent} = 0$, or + \item $\tcode{$s_k$.stride} > 0$ + \end{itemize} + \item + $0 \le \tcode{\exposid{first_}(slices...)}$ + $\le \tcode{\exposid{last_}<$k$>(src.extents(), slices...)}$ + $\le \tcode{\linebreak{}src.extent($k$)}$ + \end{itemize} + +\item +\tcode{sub_map_offset.mapping.extents() == submdspan_extents(src.mapping(), slices...)}\linebreak +is \tcode{true}; and + +\item +for each integer pack \tcode{I} which is a multidimensional index +in \tcode{sub_map_offset.mapping.extents()}, +\begin{codeblock} +sub_map_offset.mapping(I...) + sub_map_offset.offset == + src.mapping()(@\exposid{src-indices}@(array{I...}, slices...)) +\end{codeblock} +is \tcode{true}. +\end{itemize} + +\begin{note} +These conditions ensure that the mapping returned by \tcode{submdspan_mapping} +matches the algorithmically expected index-mapping given the slice specifiers. +\end{note} + +\pnum +\effects +Equivalent to: +\begin{codeblock} +auto sub_map_offset = submdspan_mapping(src.mapping(), slices...); +return mdspan(src.accessor().offset(src.data(), sub_map_offset.offset), + sub_map_offset.mapping, + AccessorPolicy::offset_policy(src.accessor())); +\end{codeblock} +\end{itemdescr} + +\pnum +\begin{example} +Given a rank-3 \tcode{mdspan grid3d} representing a three-dimensional grid +of regularly spaced points in a rectangular prism, +the function \tcode{zero_surface} sets all elements on +the surface of the 3-dimensional shape to zero. +It does so by reusing a function \tcode{zero_2d} +that takes a rank-2 \tcode{mdspan}. + +\begin{codeblock} +// zero out all elements in an \tcode{mdspan} +template +void zero_2d(mdspan a) { + static_assert(a.rank() == 2); + for (int i = 0; i < a.extent(0); i++) + for (int j = 0; j < a.extent(1); j++) + a[i, j] = 0; +} + +// zero out just the surface +template +void zero_surface(mdspan grid3d) { + static_assert(grid3d.rank() == 3); + zero_2d(submdspan(grid3d, 0, full_extent, full_extent)); + zero_2d(submdspan(grid3d, full_extent, 0, full_extent)); + zero_2d(submdspan(grid3d, full_extent, full_extent, 0)); + zero_2d(submdspan(grid3d, grid3d.extent(0) - 1, full_extent, full_extent)); + zero_2d(submdspan(grid3d, full_extent, grid3d.extent(1) - 1, full_extent)); + zero_2d(submdspan(grid3d, full_extent, full_extent, grid3d.extent(2) - 1)); +} +\end{codeblock} +\end{example} diff --git a/source/lib-intro.tex b/source/lib-intro.tex index 4b9e59445a..07501c7096 100644 --- a/source/lib-intro.tex +++ b/source/lib-intro.tex @@ -1027,7 +1027,8 @@ \pnum Whenever an unqualified name other than -\tcode{swap}, \tcode{make_error_code}, or \tcode{make_error_condition} +\tcode{swap}, \tcode{make_error_code}, \tcode{make_error_condition}, or +\tcode{submdspan_mapping} is used in the specification of a declaration \tcode{D} in \ref{\firstlibchapter} through \ref{\lastlibchapter} or \ref{depr}, its meaning is established @@ -1050,7 +1051,9 @@ in an overload resolution context for swappable values\iref{swappable.requirements}. The meanings of the unqualified names -\tcode{make_error_code} and \tcode{make_error_condition} are established +\tcode{make_error_code}, \tcode{make_error_condition}, and +\tcode{submdspan_mapping} +are established as-if by performing argument-dependent lookup\iref{basic.lookup.argdep}. diff --git a/source/support.tex b/source/support.tex index 01c4f4649c..8ca7d174b0 100644 --- a/source/support.tex +++ b/source/support.tex @@ -763,6 +763,7 @@ #define @\defnlibxname{cpp_lib_string_resize_and_overwrite}@ 202110L // also in \libheader{string} #define @\defnlibxname{cpp_lib_string_udls}@ 201304L // also in \libheader{string} #define @\defnlibxname{cpp_lib_string_view}@ 201803L // also in \libheader{string}, \libheader{string_view} +#define @\defnlibxname{cpp_lib_submdspan}@ 202306L // also in \libheader{mdspan} #define @\defnlibxname{cpp_lib_syncbuf}@ 201803L // also in \libheader{syncstream} #define @\defnlibxname{cpp_lib_text_encoding}@ 202306L // also in \libheader{text_encoding} #define @\defnlibxname{cpp_lib_three_way_comparison}@ 201907L // freestanding, also in \libheader{compare} From 4e4795ee11e88436e4a195175c9dc6734a3a6078 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 28 Jun 2023 16:09:04 -0700 Subject: [PATCH 118/171] [mdspan.submdspan.*] Fix punctuation in itemized lists; use ", or". --- source/containers.tex | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/source/containers.tex b/source/containers.tex index 729ea0d19d..e94313a5cb 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -21735,10 +21735,10 @@ For each rank index $k$ of \tcode{src.extents()}, exactly one of the following is true: \begin{itemize} -\item $S_k$ models \tcode{\libconcept{convertible_to}} -\item $S_k$ models \tcode{\exposconcept{index-pair-like}} -\item \tcode{is_convertible_v<$S_k$, full_extent_t>} is \tcode{true} -\item $S_k$ is a specialization of \tcode{strided_slice} +\item $S_k$ models \tcode{\libconcept{convertible_to}}, +\item $S_k$ models \tcode{\exposconcept{index-pair-like}}, +\item \tcode{is_convertible_v<$S_k$, full_extent_t>} is \tcode{true}, or +\item $S_k$ is a specialization of \tcode{strided_slice}. \end{itemize} \pnum @@ -21859,10 +21859,10 @@ For each rank index $k$ of \tcode{extents()}, exactly one of the following is true: \begin{itemize} -\item $S_k$ models \tcode{\libconcept{convertible_to}} -\item $S_k$ models \tcode{\exposconcept{index-pair-like}} -\item \tcode{is_convertible_v<$S_k$, full_extent_t>} is \tcode{true} -\item $S_k$ is a specialization of \tcode{strided_slice} +\item $S_k$ models \tcode{\libconcept{convertible_to}}, +\item $S_k$ models \tcode{\exposconcept{index-pair-like}}, +\item \tcode{is_convertible_v<$S_k$, full_extent_t>} is \tcode{true}, or +\item $S_k$ is a specialization of \tcode{strided_slice}. \end{itemize} \pnum @@ -22020,10 +22020,10 @@ For each rank index $k$ of \tcode{src.extents()}, exactly one of the following is true: \begin{itemize} - \item $S_k$ models \tcode{\libconcept{convertible_to}} - \item $S_k$ models \tcode{\exposconcept{index-pair-like}} - \item \tcode{is_convertible_v<$S_k$, full_extent_t>} is \tcode{true} - \item $S_k$ is a specialization of \tcode{strided_slice} + \item $S_k$ models \tcode{\libconcept{convertible_to}}, + \item $S_k$ models \tcode{\exposconcept{index-pair-like}}, + \item \tcode{is_convertible_v<$S_k$, full_extent_t>} is \tcode{true}, or + \item $S_k$ is a specialization of \tcode{strided_slice}. \end{itemize} \end{itemize} From 272a009514f297ee13c6a09425caf0e99c6becbf Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 28 Jun 2023 19:04:17 -0700 Subject: [PATCH 119/171] [mdspan.submdspan.submdspan] Rename section to "submdspan template function" --- source/containers.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/containers.tex b/source/containers.tex index e94313a5cb..90434f88f6 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -19006,7 +19006,7 @@ template constexpr auto submdspan_extents(const extents&, SliceSpecifiers...); - // \ref{mdspan.submdspan.submdspan}, \tcode{submdspan} function + // \ref{mdspan.submdspan.submdspan}, \tcode{submdspan} template function template constexpr auto submdspan( @@ -21969,7 +21969,7 @@ \end{itemize} \end{itemdescr} -\rSec4[mdspan.submdspan.submdspan]{\tcode{submdspan} function} +\rSec4[mdspan.submdspan.submdspan]{\tcode{submdspan} template function} \indexlibraryglobal{submdspan}% \begin{itemdecl} From 08803e9bd50766cfb01b81141114fd0cd2ddc9d4 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 28 Jun 2023 19:11:12 -0700 Subject: [PATCH 120/171] [mdspan.submdspan.*] Change "Let .. name the type" to "Let ... be" for consistency --- source/containers.tex | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/containers.tex b/source/containers.tex index 90434f88f6..f7864bc50a 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -21654,7 +21654,7 @@ \tcode{Extents} is a specialization of \tcode{extents}. \pnum -Let \tcode{index_type} name the type \tcode{typename Extents::index_type}. +Let \tcode{index_type} be \tcode{typename Extents::index_type}. %FIXME: What is $k$ in this itemdescr? Don't we want \tcode{k} and not $k$? \pnum @@ -21848,7 +21848,7 @@ \begin{itemdescr} \pnum -Let \tcode{index_type} name the type \tcode{typename Extents::index_type}. +Let \tcode{index_type} be \tcode{typename Extents::index_type}. \pnum \constraints @@ -21982,7 +21982,7 @@ \begin{itemdescr} \pnum -Let \tcode{index_type} name the type \tcode{typename Extents::index_type}. +Let \tcode{index_type} be \tcode{typename Extents::index_type}. \pnum Let \tcode{sub_map_offset} be the result of From 1051ee4dd2dbe9eff01c8b14f7eb5f70d682a4be Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 28 Jun 2023 20:30:47 -0700 Subject: [PATCH 121/171] [mdspan.submdspan.*] Use \codeblocks instead of \itemdecl/descrs for definitions of structs strided_slice and submdspan_mapping_result --- source/containers.tex | 46 +++++++++++++++++++++---------------------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/source/containers.tex b/source/containers.tex index f7864bc50a..4ca41a9324 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -21542,20 +21542,21 @@ increase by increments of \tcode{stride}. \indexlibraryglobal{strided_slice}% -\begin{itemdecl} -template -struct strided_slice { - using offset_type = OffsetType; - using extent_type = ExtentType; - using stride_type = StrideType; - - [[no_unique_address]] OffsetType offset{}; - [[no_unique_address]] ExtentType extent{}; - [[no_unique_address]] StrideType stride{}; -}; -\end{itemdecl} +\begin{codeblock} +namespace std { + template + struct strided_slice { + using offset_type = OffsetType; + using extent_type = ExtentType; + using stride_type = StrideType; + + [[no_unique_address]] OffsetType offset{}; + [[no_unique_address]] ExtentType extent{}; + [[no_unique_address]] StrideType stride{}; + }; +} +\end{codeblock} -\begin{itemdescr} \pnum \tcode{strided_slice} has the data members and special members specified above. It has no base classes or members other than those specified. @@ -21570,7 +21571,6 @@ indicates the indices \tcode{1}, \tcode{4}, \tcode{7}, and \tcode{10}. Indices are selected from the half-open interval \range{1}{1 + 10}. \end{note} -\end{itemdescr} \rSec4[mdspan.submdspan.submdspan.mapping.result]{\tcode{submdspan_mapping_result}} @@ -21579,15 +21579,16 @@ are returned by overloads of \tcode{submdspan_mapping}. \indexlibraryglobal{submdspan_mapping_result}% -\begin{itemdecl} -template -struct submdspan_mapping_result { - [[no_unique_address]] LayoutMapping mapping = LayoutMapping(); - size_t offset{}; -}; -\end{itemdecl} +\begin{codeblock} +namespace std { + template + struct submdspan_mapping_result { + [[no_unique_address]] LayoutMapping mapping = LayoutMapping(); + size_t offset{}; + }; +} +\end{codeblock} -\begin{itemdescr} \pnum \tcode{submdspan_mapping_result} has the data members and special members specified above. @@ -21596,7 +21597,6 @@ \pnum \tcode{LayoutMapping} shall meet the layout mapping requirements\iref{mdspan.layout.policy.reqmts}. -\end{itemdescr} \rSec4[mdspan.submdspan.helpers]{Exposition-only helpers} From 8e224040aa5a5e35778dad420b2e3c688e0fba34 Mon Sep 17 00:00:00 2001 From: Dawn Perchik Date: Wed, 28 Jun 2023 21:03:23 -0700 Subject: [PATCH 122/171] [mdspan.submdspan.*] Move "otherwise" to front of itemized lists. --- source/containers.tex | 45 +++++++++++++++++++++++++++---------------- 1 file changed, 28 insertions(+), 17 deletions(-) diff --git a/source/containers.tex b/source/containers.tex index 4ca41a9324..d55f7d383b 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -21510,11 +21510,13 @@ \begin{itemize} \item \tcode{M::index_type} - if the function is a member of a class \tcode{M}, otherwise + if the function is a member of a class \tcode{M}, \item + otherwise, \tcode{remove_reference_t::index_type} - if the function has a parameter named \tcode{src}, otherwise + if the function has a parameter named \tcode{src}, \item + otherwise, the same type as the function's template argument \tcode{IndexType}; \end{itemize} \item let \tcode{rank} be the number of elements in \tcode{slices}; @@ -21526,8 +21528,9 @@ \begin{itemize} \item \tcode{dynamic_extent} - if $S_k$ models \tcode{\libconcept{convertible_to}}, otherwise + if $S_k$ models \tcode{\libconcept{convertible_to}}, \item + otherwise, the number of types $S_j$ with $j < k$ that do not model \tcode{\libconcept{convertible_to}}. \end{itemize} @@ -21622,14 +21625,17 @@ Let $\phi{}_k$ denote the following value: \begin{itemize} \item -$s_k$ if $S_k$ models \tcode{\libconcept{convertible_to}}; otherwise +$s_k$ if $S_k$ models \tcode{\libconcept{convertible_to}}; \item +otherwise, \tcode{get<0>($s_k$)} -if $S_k$ models \tcode{\exposconcept{index-pair-like}}; otherwise +if $S_k$ models \tcode{\exposconcept{index-pair-like}}; \item +otherwise, \tcode{\exposid{de-ice}($s_k$.offset)} -if $S_k$ is a specialization of \tcode{strided_slice}; otherwise +if $S_k$ is a specialization of \tcode{strided_slice}; \item +otherwise, \tcode{0}. \end{itemize} @@ -21708,9 +21714,11 @@ %FIXME: Also, calling first_ on each $k$ below gives us a set of indeces - how do we assign a set to the src_idx[$k$] above? \tcode{\exposid{first_}(slices...)} for each $k$ where \tcode{\placeholder{map-rank}[$k$]} equals -\tcode{dynamic_extent}, otherwise +\tcode{dynamic_extent}, \item +%FIXME: How do we fail the previous \item to get here? There's no "if" test to fail. +otherwise, \tcode{\exposid{first_}(slices...)} \tcode{+} \tcode{indices[\placeholder{map-rank}[$k$]]}. \end{itemize} @@ -21797,9 +21805,10 @@ \tcode{\exposid{de-ice}($S_k$::stride_type())}, if $S_k$ is a specialization of \tcode{strided_slice} whose \tcode{extent_type} and \tcode{stride_type} - model \exposconceptx{integral-cons\-tant-like}{integral-constant-like}; otherwise + model \exposconceptx{integral-cons\-tant-like}{integral-constant-like}; \item + otherwise, \tcode{dynamic_extent}. \end{itemize} \end{itemize} @@ -21815,12 +21824,13 @@ \tcode{ext.extent(\placeholder{map-rank}[$k$])} equals \tcode{$s_k$.extent == 0 ? 0 : 1 + (\exposid{de-ice}($s_k$.extent) - 1) /}\linebreak{} \tcode{\exposid{de-ice}($s_k$.stride)} -if $S_k$ is a specialization of \tcode{strided_slice}, otherwise +if $S_k$ is a specialization of \tcode{strided_slice}, \item +otherwise, \tcode{ext.extent(\placeholder{map-rank}[$k$])} equals \tcode{\exposid{last_}<$k$>(src, slices...) -} -\tcode{\exposid{first_}(\linebreak{}slices...)}. +\tcode{\exposid{first_}(slices...)}. \end{itemize} \end{itemdescr} @@ -21898,9 +21908,10 @@ \item \tcode{stride($k$) * \exposid{de-ice}($s_k$.stride)} if $S_k$ is a specialization of \tcode{strided_slice} and -\tcode{$s_k$.stride < $s_k$.extent}; otherwise +\tcode{$s_k$.stride < $s_k$.extent}; \item +otherwise, \tcode{stride($k$)}. \end{itemize} @@ -21918,9 +21929,10 @@ \begin{itemize} \item \tcode{submdspan_mapping_result\{*this, 0\}}, -if \tcode{Extents::rank() == 0} is \tcode{true}; otherwise +if \tcode{Extents::rank() == 0} is \tcode{true}; \item +otherwise, \tcode{submdspan_mapping_result\{layout_left::mapping(sub_ext), offset\}}, if \begin{itemize} @@ -21932,9 +21944,7 @@ \item for $k$ equal to \tcode{SubExtents::rank() - 1}, $S_k$ models \tcode{\exposconcept{index-pair-like}} or -%FIXME: Dangling "otherwise" in nested itemized list is lost, reword to move "otherwise" to start of alternate items \tcode{is_convertible_v<$S_k$, full_extent_t>} is \tcode{true}; - otherwise \end{itemize} \begin{note} If the above conditions are true, @@ -21943,6 +21953,7 @@ \end{note} \item +otherwise, \tcode{submdspan_mapping_result\{layout_right::mapping(sub_ext), offset\}}, if \begin{itemize} @@ -21955,8 +21966,7 @@ \item for $k$ equal to \tcode{Extents::rank() - SubExtents::rank()}, $S_k$ models \tcode{\exposconcept{index-pair-like}} or -%FIXME: Dangling "otherwise" in nested itemized list is lost - \tcode{is_convertible_v<$S_k$, full_extent_t>} is \tcode{true}; otherwise + \tcode{is_convertible_v<$S_k$, full_extent_t>} is \tcode{true}; \end{itemize} \begin{note} If the above conditions are true, @@ -21965,7 +21975,8 @@ \end{note} \item -\tcode{submdspan_mapping_result\{layout_stride::mapping(sub_ext, sub_strides), offset\}}. +otherwise, +\tcode{submdspan_mapping_result\{layout_stride::mapping(sub_ext, sub_strides),\linebreak{}offset\}}. \end{itemize} \end{itemdescr} From cd1eb0634d1ad7abdbfde3abdfce94da78484b2f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Sat, 22 Jul 2023 22:14:06 +0100 Subject: [PATCH 123/171] [mdspan.syn, mdspan.submdspan.submdspan] Rename "template function" to "function template" --- source/containers.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/containers.tex b/source/containers.tex index d55f7d383b..9a55f14222 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -19006,7 +19006,7 @@ template constexpr auto submdspan_extents(const extents&, SliceSpecifiers...); - // \ref{mdspan.submdspan.submdspan}, \tcode{submdspan} template function + // \ref{mdspan.submdspan.submdspan}, \tcode{submdspan} function template template constexpr auto submdspan( @@ -21980,7 +21980,7 @@ \end{itemize} \end{itemdescr} -\rSec4[mdspan.submdspan.submdspan]{\tcode{submdspan} template function} +\rSec4[mdspan.submdspan.submdspan]{\tcode{submdspan} function template} \indexlibraryglobal{submdspan}% \begin{itemdecl} From 75ed240b96d967fa66949a2d995aa3636fd4694f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Sat, 22 Jul 2023 22:18:04 +0100 Subject: [PATCH 124/171] [mdspan.submdspan.strided.slice] Use member typedefs instead of template arguments --- source/containers.tex | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/source/containers.tex b/source/containers.tex index 9a55f14222..17c000f74c 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -21553,9 +21553,9 @@ using extent_type = ExtentType; using stride_type = StrideType; - [[no_unique_address]] OffsetType offset{}; - [[no_unique_address]] ExtentType extent{}; - [[no_unique_address]] StrideType stride{}; + [[no_unique_address]] offset_type offset{}; + [[no_unique_address]] extent_type extent{}; + [[no_unique_address]] stride_type stride{}; }; } \end{codeblock} @@ -21570,7 +21570,7 @@ are signed or unsigned integer types, or model \exposconcept{integral-constant-like}. \begin{note} -\tcode{strided_slice\{.offset=1, .extent=10, .stride=3\}} +\tcode{strided_slice\{.offset = 1, .extent = 10, .stride = 3\}} indicates the indices \tcode{1}, \tcode{4}, \tcode{7}, and \tcode{10}. Indices are selected from the half-open interval \range{1}{1 + 10}. \end{note} From cf8cfe0fa2129781e17a38344f889bc34732b702 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Fri, 21 Jul 2023 22:27:24 +0100 Subject: [PATCH 125/171] [check.yml] Update macOS runner to "macos-13", up from "macos-12" --- .github/workflows/check.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml index a2dcca1077..925ac7e8fe 100644 --- a/.github/workflows/check.yml +++ b/.github/workflows/check.yml @@ -18,14 +18,14 @@ jobs: matrix: cfg: - { name: 'Linux', os: 'ubuntu-22.04' } - - { name: 'MacOS', os: 'macos-12' } + - { name: 'MacOS', os: 'macos-13' } steps: - name: checkout uses: actions/checkout@v3 - name: install GNU tools - if: matrix.cfg.os == 'macos-12' + if: matrix.cfg.os == 'macos-13' run: | brew install gnu-sed echo "/usr/local/opt/gnu-sed/libexec/gnubin" >> ${GITHUB_PATH} @@ -34,7 +34,7 @@ jobs: run: ../tools/check-source.sh - name: update brew - if: matrix.cfg.os == 'macos-12' + if: matrix.cfg.os == 'macos-13' run: | brew update @@ -47,7 +47,7 @@ jobs: run: sudo apt-get install latexmk texlive-latex-recommended texlive-latex-extra texlive-fonts-recommended lmodern - name: install (MacOS) - if: matrix.cfg.os == 'macos-12' + if: matrix.cfg.os == 'macos-13' run: | brew install basictex eval "$(/usr/libexec/path_helper)" @@ -60,7 +60,7 @@ jobs: run: make quiet - name: make (MacOS) - if: matrix.cfg.os == 'macos-12' + if: matrix.cfg.os == 'macos-13' run: make full - name: check-output.sh From 6850b45b22e94ff0ecce7a591bd29f71401c1181 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Fri, 21 Jul 2023 18:15:40 +0100 Subject: [PATCH 126/171] Replace cross-references from C++20 with cross-references from C++23. --- source/back.tex | 4 +- source/macros.tex | 1 + source/xrefdelta.tex | 119 +- source/xrefprev | 5840 ++++++++++++++++++++++------------------- tools/check-output.sh | 1 + 5 files changed, 3097 insertions(+), 2868 deletions(-) diff --git a/source/back.tex b/source/back.tex index f0b43a6430..1107b0c2b4 100644 --- a/source/back.tex +++ b/source/back.tex @@ -65,9 +65,9 @@ \chapter{Bibliography} \clearpage \input{xrefdelta} -\renewcommand{\glossaryname}{Cross-references from ISO \CppXX{}} +\renewcommand{\glossaryname}{Cross-references from ISO \CppXXIII{}} \renewcommand{\preglossaryhook}{All clause and subclause labels from -ISO \CppXX{} (ISO/IEC 14882:2020, \doccite{Programming Languages --- \Cpp{}}) +ISO \CppXXIII{} (ISO/IEC 14882:2023, \doccite{Programming Languages --- \Cpp{}}) are present in this document, with the exceptions described below.\\} \renewcommand{\leftmark}{\glossaryname} { diff --git a/source/macros.tex b/source/macros.tex index 3d6541e5aa..b6ad3ceed5 100644 --- a/source/macros.tex +++ b/source/macros.tex @@ -275,6 +275,7 @@ \newcommand{\CppXVII}{\Cpp{} 2017} \newcommand{\CppXX}{\Cpp{} 2020} \newcommand{\CppXXIII}{\Cpp{} 2023} +\newcommand{\CppXXVI}{\Cpp{} 2026} \newcommand{\opt}[1]{#1\ensuremath{_\mathit{\color{black}opt}}} \newcommand{\bigoh}[1]{\ensuremath{\mathscr{O}(#1)}} diff --git a/source/xrefdelta.tex b/source/xrefdelta.tex index e622e48e6c..cce5770ba8 100644 --- a/source/xrefdelta.tex +++ b/source/xrefdelta.tex @@ -2,7 +2,7 @@ \newcommand{\secref}[1]{\hyperref[\indexescape{#1}]{\indexescape{#1}}} -% Turn off page numbers for this glossary, they're not useful. +%%% Turn off page numbers for this glossary, they're not useful. \newcommand{\swallow}[1]{} \changeglossnumformat[xrefdelta]{|swallow} @@ -14,108 +14,23 @@ \newcommand{\movedxrefiii}[4]{\movedxrefs{#1}{\secref{#2}, \secref{#3}, \secref{#4}}} \newcommand{\deprxref}[1]{\oldxref{#1}{\textit{see} \secref{depr.#1}}} -% Removed features. -%\removedxref{removed.label} - -% Renamed sections. -%\movedxref{old.label}{new.label} -%\movedxrefii{old.label}{new.label.1}{new.label.2} -%\movedxrefiii{old.label}{new.label.1}{new.label.2}{new.label.3} -%\movedxrefs{old.label}{new place (eg \tref{blah})} - -\movedxref{re.def}{intro.refs} -\movedxref{basic.scope.declarative}{basic.scope.scope} -\movedxref{basic.funscope}{stmt.label} -\movedxref{basic.scope.hiding}{basic.lookup} -\movedxref{basic.lookup.classref}{basic.lookup.qual} -\movedxref{namespace.memdef}{namespace.def} -\movedxref{class.this}{expr.prim.this} -\movedxref{class.mfct.non-static.general}{class.mfct.non.static} -\movedxref{class.nested.type}{diff.basic} -\movedxref{over.load}{basic.scope.scope} -\movedxref{over.dcl}{basic.link} -\movedxref{temp.nondep}{temp.res} -\movedxref{temp.inject}{temp.friend} - -% P2096R2 Generalized wording for partial specializations -\movedxref{temp.class.spec}{temp.spec.partial} -\movedxref{temp.class.spec.general}{temp.spec.partial.general} -\movedxref{temp.class.spec.match}{temp.spec.partial.match} -\movedxref{temp.class.order}{temp.spec.partial.order} -\movedxref{temp.class.spec.mfunc}{temp.spec.partial.member} - -\movedxref{forwardlist}{forward.list} -\movedxref{forwardlist.overview}{forward.list.overview} -\movedxref{forwardlist.cons}{forward.list.cons} -\movedxref{forwardlist.iter}{forward.list.iter} -\movedxref{forwardlist.access}{forward.list.access} -\movedxref{forwardlist.modifiers}{forward.list.modifiers} -\movedxref{forwardlist.ops}{forward.list.ops} - -% P2186R2 Removing Garbage Collection Support -\removedxref{basic.stc.dynamic.safety} -\removedxref{util.dynamic.safety} -\removedxref{res.on.pointer.storage} - -% LWG2818 "::std::" everywhere rule needs tweaking -\removedxref{fs.req.namespace} -\movedxref{fs.req.general}{fs.req} - -% P2325R3 Views should not be required to be default constructible -% P2494R2 Relaxing range adaptors to allow for move only types -% range.semi.wrap => range.copy.wrap => range.move.wrap -\movedxref{range.semi.wrap}{range.move.wrap} - -% P2210R2 Superior String Splitting -\movedxref{range.split.outer}{range.lazy.split.outer} -\movedxref{range.split.outer.value}{range.lazy.split.outer.value} -\movedxref{range.split.inner}{range.lazy.split.inner} - -% P2128R6 Multidimensional subscript operator -\removedxref{depr.comma.subscript} - -% P2340R1 Clarifying the status of the "C headers" -\movedxref{depr.c.headers}{support.c.headers} -\movedxref{depr.c.headers.general}{support.c.headers.general} -\movedxref{depr.c.headers.other}{support.c.headers.other} -\movedxref{depr.complex.h.syn}{complex.h.syn} -\movedxref{depr.iso646.h.syn}{iso646.h.syn} -\movedxref{depr.stdalign.h.syn}{stdalign.h.syn} -\movedxref{depr.stdbool.h.syn}{stdbool.h.syn} -\movedxref{depr.tgmath.h.syn}{tgmath.h.syn} - -\movedxref{istringstream.assign}{istringstream.swap} -\movedxref{ostringstream.assign}{ostringstream.swap} -\movedxref{stringstream.assign}{stringstream.swap} -\movedxref{ifstream.assign}{ifstream.swap} -\movedxref{ofstream.assign}{ofstream.swap} -\movedxref{fstream.assign}{fstream.swap} - -% P2387R3 Pipe support for user-defined range adaptors -\movedxref{func.bind.front}{func.bind.partial} - -\movedxref{class.mfct.non-static}{class.mfct.non.static} -\movedxref{defns.direct-non-list-init}{defns.direct.non.list.init} -\movedxref{defns.expression-equivalent}{defns.expression.equivalent} - -% P1467R9 Extended floating-point types and standard names -\movedxref{complex.special}{complex.members} -\movedxref{cstdint}{support.arith.types} -\removedxref{cstdint.general} - -% LWG3659 Consider ATOMIC_FLAG_INIT undeprecation -\removedxref{depr.atomics.flag} - -% LWG3818 Exposition-only concepts are not described in library intro -\movedxref{expos.only.func}{expos.only.entity} -\removedxref{expos.only.types} - -% P2614R2 Deprecate numeric_limits::has_denorm -\movedxref{denorm.style}{depr.numeric.limits.has.denorm} -\removedxref{fp.style} +%%% Removed features. +%%% Example: +% +% \removedxref{removed.label} % P2874R2 Mandating Annex D \removedxref{depr.res.on.required} -% Deprecated features. -%\deprxref{old.label} (if moved to depr.old.label, otherwise use \movedxref) +%%% Renamed sections. +%%% Examples: +% +% \movedxref{old.label}{new.label} +% \movedxrefii{old.label}{new.label.1}{new.label.2} +% \movedxrefiii{old.label}{new.label.1}{new.label.2}{new.label.3} +% \movedxrefs{old.label}{new place (e.g., \tref{blah})} + +%%% Deprecated features. +%%% Example: +% +% \deprxref{old.label} (if moved to depr.old.label, otherwise use \movedxref) diff --git a/source/xrefprev b/source/xrefprev index bfc3b4452f..f7332158d2 100644 --- a/source/xrefprev +++ b/source/xrefprev @@ -1,2764 +1,3076 @@ -\glossaryentry{intro.scope@ {\memgloterm{intro.scope}}{\memglodesc{(\ref {intro.scope})}} {\memgloref{}}|memjustarg}{1} -\glossaryentry{intro.refs@ {\memgloterm{intro.refs}}{\memglodesc{(\ref {intro.refs})}} {\memgloref{}}|memjustarg}{2} -\glossaryentry{intro.defs@ {\memgloterm{intro.defs}}{\memglodesc{(\ref {intro.defs})}} {\memgloref{}}|memjustarg}{3} -\glossaryentry{defns.access@ {\memgloterm{defns.access}}{\memglodesc{(\ref {defns.access})}} {\memgloref{}}|memjustarg}{3} -\glossaryentry{defns.arbitrary.stream@ {\memgloterm{defns.arbitrary.stream}}{\memglodesc{(\ref {defns.arbitrary.stream})}} {\memgloref{}}|memjustarg}{3} -\glossaryentry{defns.argument@ {\memgloterm{defns.argument}}{\memglodesc{(\ref {defns.argument})}} {\memgloref{}}|memjustarg}{3} -\glossaryentry{defns.argument.macro@ {\memgloterm{defns.argument.macro}}{\memglodesc{(\ref {defns.argument.macro})}} {\memgloref{}}|memjustarg}{3} -\glossaryentry{defns.argument.throw@ {\memgloterm{defns.argument.throw}}{\memglodesc{(\ref {defns.argument.throw})}} {\memgloref{}}|memjustarg}{3} -\glossaryentry{defns.argument.templ@ {\memgloterm{defns.argument.templ}}{\memglodesc{(\ref {defns.argument.templ})}} {\memgloref{}}|memjustarg}{3} -\glossaryentry{defns.block@ {\memgloterm{defns.block}}{\memglodesc{(\ref {defns.block})}} {\memgloref{}}|memjustarg}{3} -\glossaryentry{defns.block.stmt@ {\memgloterm{defns.block.stmt}}{\memglodesc{(\ref {defns.block.stmt})}} {\memgloref{}}|memjustarg}{3} -\glossaryentry{defns.character@ {\memgloterm{defns.character}}{\memglodesc{(\ref {defns.character})}} {\memgloref{}}|memjustarg}{3} -\glossaryentry{defns.character.container@ {\memgloterm{defns.character.container}}{\memglodesc{(\ref {defns.character.container})}} {\memgloref{}}|memjustarg}{3} -\glossaryentry{defns.component@ {\memgloterm{defns.component}}{\memglodesc{(\ref {defns.component})}} {\memgloref{}}|memjustarg}{4} -\glossaryentry{defns.cond.supp@ {\memgloterm{defns.cond.supp}}{\memglodesc{(\ref {defns.cond.supp})}} {\memgloref{}}|memjustarg}{4} -\glossaryentry{defns.const.subexpr@ {\memgloterm{defns.const.subexpr}}{\memglodesc{(\ref {defns.const.subexpr})}} {\memgloref{}}|memjustarg}{4} -\glossaryentry{defns.deadlock@ {\memgloterm{defns.deadlock}}{\memglodesc{(\ref {defns.deadlock})}} {\memgloref{}}|memjustarg}{4} -\glossaryentry{defns.default.behavior.impl@ {\memgloterm{defns.default.behavior.impl}}{\memglodesc{(\ref {defns.default.behavior.impl})}} {\memgloref{}}|memjustarg}{4} -\glossaryentry{defns.diagnostic@ {\memgloterm{defns.diagnostic}}{\memglodesc{(\ref {defns.diagnostic})}} {\memgloref{}}|memjustarg}{4} -\glossaryentry{defns.direct-non-list-init@ {\memgloterm{defns.direct-non-list-init}}{\memglodesc{(\ref {defns.direct-non-list-init})}} {\memgloref{}}|memjustarg}{4} -\glossaryentry{defns.dynamic.type@ {\memgloterm{defns.dynamic.type}}{\memglodesc{(\ref {defns.dynamic.type})}} {\memgloref{}}|memjustarg}{4} -\glossaryentry{defns.dynamic.type.prvalue@ {\memgloterm{defns.dynamic.type.prvalue}}{\memglodesc{(\ref {defns.dynamic.type.prvalue})}} {\memgloref{}}|memjustarg}{4} -\glossaryentry{defns.expression-equivalent@ {\memgloterm{defns.expression-equivalent}}{\memglodesc{(\ref {defns.expression-equivalent})}} {\memgloref{}}|memjustarg}{4} -\glossaryentry{defns.handler@ {\memgloterm{defns.handler}}{\memglodesc{(\ref {defns.handler})}} {\memgloref{}}|memjustarg}{4} -\glossaryentry{defns.ill.formed@ {\memgloterm{defns.ill.formed}}{\memglodesc{(\ref {defns.ill.formed})}} {\memgloref{}}|memjustarg}{5} -\glossaryentry{defns.impl.defined@ {\memgloterm{defns.impl.defined}}{\memglodesc{(\ref {defns.impl.defined})}} {\memgloref{}}|memjustarg}{5} -\glossaryentry{defns.order.ptr@ {\memgloterm{defns.order.ptr}}{\memglodesc{(\ref {defns.order.ptr})}} {\memgloref{}}|memjustarg}{5} -\glossaryentry{defns.impl.limits@ {\memgloterm{defns.impl.limits}}{\memglodesc{(\ref {defns.impl.limits})}} {\memgloref{}}|memjustarg}{5} -\glossaryentry{defns.iostream.templates@ {\memgloterm{defns.iostream.templates}}{\memglodesc{(\ref {defns.iostream.templates})}} {\memgloref{}}|memjustarg}{5} -\glossaryentry{defns.locale.specific@ {\memgloterm{defns.locale.specific}}{\memglodesc{(\ref {defns.locale.specific})}} {\memgloref{}}|memjustarg}{5} -\glossaryentry{defns.modifier@ {\memgloterm{defns.modifier}}{\memglodesc{(\ref {defns.modifier})}} {\memgloref{}}|memjustarg}{5} -\glossaryentry{defns.move.assign@ {\memgloterm{defns.move.assign}}{\memglodesc{(\ref {defns.move.assign})}} {\memgloref{}}|memjustarg}{5} -\glossaryentry{defns.move.constr@ {\memgloterm{defns.move.constr}}{\memglodesc{(\ref {defns.move.constr})}} {\memgloref{}}|memjustarg}{5} -\glossaryentry{defns.ntcts@ {\memgloterm{defns.ntcts}}{\memglodesc{(\ref {defns.ntcts})}} {\memgloref{}}|memjustarg}{5} -\glossaryentry{defns.observer@ {\memgloterm{defns.observer}}{\memglodesc{(\ref {defns.observer})}} {\memgloref{}}|memjustarg}{5} -\glossaryentry{defns.parameter@ {\memgloterm{defns.parameter}}{\memglodesc{(\ref {defns.parameter})}} {\memgloref{}}|memjustarg}{6} -\glossaryentry{defns.parameter.macro@ {\memgloterm{defns.parameter.macro}}{\memglodesc{(\ref {defns.parameter.macro})}} {\memgloref{}}|memjustarg}{6} -\glossaryentry{defns.parameter.templ@ {\memgloterm{defns.parameter.templ}}{\memglodesc{(\ref {defns.parameter.templ})}} {\memgloref{}}|memjustarg}{6} -\glossaryentry{defns.prog.def.spec@ {\memgloterm{defns.prog.def.spec}}{\memglodesc{(\ref {defns.prog.def.spec})}} {\memgloref{}}|memjustarg}{6} -\glossaryentry{defns.prog.def.type@ {\memgloterm{defns.prog.def.type}}{\memglodesc{(\ref {defns.prog.def.type})}} {\memgloref{}}|memjustarg}{6} -\glossaryentry{defns.projection@ {\memgloterm{defns.projection}}{\memglodesc{(\ref {defns.projection})}} {\memgloref{}}|memjustarg}{6} -\glossaryentry{defns.referenceable@ {\memgloterm{defns.referenceable}}{\memglodesc{(\ref {defns.referenceable})}} {\memgloref{}}|memjustarg}{6} -\glossaryentry{defns.replacement@ {\memgloterm{defns.replacement}}{\memglodesc{(\ref {defns.replacement})}} {\memgloref{}}|memjustarg}{6} -\glossaryentry{defns.repositional.stream@ {\memgloterm{defns.repositional.stream}}{\memglodesc{(\ref {defns.repositional.stream})}} {\memgloref{}}|memjustarg}{6} -\glossaryentry{defns.required.behavior@ {\memgloterm{defns.required.behavior}}{\memglodesc{(\ref {defns.required.behavior})}} {\memgloref{}}|memjustarg}{6} -\glossaryentry{defns.reserved.function@ {\memgloterm{defns.reserved.function}}{\memglodesc{(\ref {defns.reserved.function})}} {\memgloref{}}|memjustarg}{7} -\glossaryentry{defns.signature@ {\memgloterm{defns.signature}}{\memglodesc{(\ref {defns.signature})}} {\memgloref{}}|memjustarg}{7} -\glossaryentry{defns.signature.friend@ {\memgloterm{defns.signature.friend}}{\memglodesc{(\ref {defns.signature.friend})}} {\memgloref{}}|memjustarg}{7} -\glossaryentry{defns.signature.templ@ {\memgloterm{defns.signature.templ}}{\memglodesc{(\ref {defns.signature.templ})}} {\memgloref{}}|memjustarg}{7} -\glossaryentry{defns.signature.templ.friend@ {\memgloterm{defns.signature.templ.friend}}{\memglodesc{(\ref {defns.signature.templ.friend})}} {\memgloref{}}|memjustarg}{7} -\glossaryentry{defns.signature.spec@ {\memgloterm{defns.signature.spec}}{\memglodesc{(\ref {defns.signature.spec})}} {\memgloref{}}|memjustarg}{7} -\glossaryentry{defns.signature.member@ {\memgloterm{defns.signature.member}}{\memglodesc{(\ref {defns.signature.member})}} {\memgloref{}}|memjustarg}{7} -\glossaryentry{defns.signature.member.templ@ {\memgloterm{defns.signature.member.templ}}{\memglodesc{(\ref {defns.signature.member.templ})}} {\memgloref{}}|memjustarg}{7} -\glossaryentry{defns.signature.member.spec@ {\memgloterm{defns.signature.member.spec}}{\memglodesc{(\ref {defns.signature.member.spec})}} {\memgloref{}}|memjustarg}{7} -\glossaryentry{defns.stable@ {\memgloterm{defns.stable}}{\memglodesc{(\ref {defns.stable})}} {\memgloref{}}|memjustarg}{7} -\glossaryentry{defns.static.type@ {\memgloterm{defns.static.type}}{\memglodesc{(\ref {defns.static.type})}} {\memgloref{}}|memjustarg}{7} -\glossaryentry{defns.traits@ {\memgloterm{defns.traits}}{\memglodesc{(\ref {defns.traits})}} {\memgloref{}}|memjustarg}{8} -\glossaryentry{defns.unblock@ {\memgloterm{defns.unblock}}{\memglodesc{(\ref {defns.unblock})}} {\memgloref{}}|memjustarg}{8} -\glossaryentry{defns.undefined@ {\memgloterm{defns.undefined}}{\memglodesc{(\ref {defns.undefined})}} {\memgloref{}}|memjustarg}{8} -\glossaryentry{defns.unspecified@ {\memgloterm{defns.unspecified}}{\memglodesc{(\ref {defns.unspecified})}} {\memgloref{}}|memjustarg}{8} -\glossaryentry{defns.valid@ {\memgloterm{defns.valid}}{\memglodesc{(\ref {defns.valid})}} {\memgloref{}}|memjustarg}{8} -\glossaryentry{defns.well.formed@ {\memgloterm{defns.well.formed}}{\memglodesc{(\ref {defns.well.formed})}} {\memgloref{}}|memjustarg}{8} -\glossaryentry{intro@ {\memgloterm{intro}}{\memglodesc{(\ref {intro})}} {\memgloref{}}|memjustarg}{9} -\glossaryentry{intro.compliance@ {\memgloterm{intro.compliance}}{\memglodesc{(\ref {intro.compliance})}} {\memgloref{}}|memjustarg}{9} -\glossaryentry{intro.compliance.general@ {\memgloterm{intro.compliance.general}}{\memglodesc{(\ref {intro.compliance.general})}} {\memgloref{}}|memjustarg}{9} -\glossaryentry{intro.abstract@ {\memgloterm{intro.abstract}}{\memglodesc{(\ref {intro.abstract})}} {\memgloref{}}|memjustarg}{9} -\glossaryentry{intro.structure@ {\memgloterm{intro.structure}}{\memglodesc{(\ref {intro.structure})}} {\memgloref{}}|memjustarg}{10} -\glossaryentry{syntax@ {\memgloterm{syntax}}{\memglodesc{(\ref {syntax})}} {\memgloref{}}|memjustarg}{10} -\glossaryentry{lex@ {\memgloterm{lex}}{\memglodesc{(\ref {lex})}} {\memgloref{}}|memjustarg}{12} -\glossaryentry{lex.separate@ {\memgloterm{lex.separate}}{\memglodesc{(\ref {lex.separate})}} {\memgloref{}}|memjustarg}{12} -\glossaryentry{lex.phases@ {\memgloterm{lex.phases}}{\memglodesc{(\ref {lex.phases})}} {\memgloref{}}|memjustarg}{12} -\glossaryentry{lex.charset@ {\memgloterm{lex.charset}}{\memglodesc{(\ref {lex.charset})}} {\memgloref{}}|memjustarg}{13} -\glossaryentry{lex.pptoken@ {\memgloterm{lex.pptoken}}{\memglodesc{(\ref {lex.pptoken})}} {\memgloref{}}|memjustarg}{14} -\glossaryentry{lex.digraph@ {\memgloterm{lex.digraph}}{\memglodesc{(\ref {lex.digraph})}} {\memgloref{}}|memjustarg}{15} -\glossaryentry{lex.token@ {\memgloterm{lex.token}}{\memglodesc{(\ref {lex.token})}} {\memgloref{}}|memjustarg}{15} -\glossaryentry{lex.comment@ {\memgloterm{lex.comment}}{\memglodesc{(\ref {lex.comment})}} {\memgloref{}}|memjustarg}{15} -\glossaryentry{lex.header@ {\memgloterm{lex.header}}{\memglodesc{(\ref {lex.header})}} {\memgloref{}}|memjustarg}{16} -\glossaryentry{lex.ppnumber@ {\memgloterm{lex.ppnumber}}{\memglodesc{(\ref {lex.ppnumber})}} {\memgloref{}}|memjustarg}{16} -\glossaryentry{lex.name@ {\memgloterm{lex.name}}{\memglodesc{(\ref {lex.name})}} {\memgloref{}}|memjustarg}{16} -\glossaryentry{lex.key@ {\memgloterm{lex.key}}{\memglodesc{(\ref {lex.key})}} {\memgloref{}}|memjustarg}{17} -\glossaryentry{lex.operators@ {\memgloterm{lex.operators}}{\memglodesc{(\ref {lex.operators})}} {\memgloref{}}|memjustarg}{18} -\glossaryentry{lex.literal@ {\memgloterm{lex.literal}}{\memglodesc{(\ref {lex.literal})}} {\memgloref{}}|memjustarg}{18} -\glossaryentry{lex.literal.kinds@ {\memgloterm{lex.literal.kinds}}{\memglodesc{(\ref {lex.literal.kinds})}} {\memgloref{}}|memjustarg}{18} -\glossaryentry{lex.icon@ {\memgloterm{lex.icon}}{\memglodesc{(\ref {lex.icon})}} {\memgloref{}}|memjustarg}{19} -\glossaryentry{lex.ccon@ {\memgloterm{lex.ccon}}{\memglodesc{(\ref {lex.ccon})}} {\memgloref{}}|memjustarg}{20} -\glossaryentry{lex.fcon@ {\memgloterm{lex.fcon}}{\memglodesc{(\ref {lex.fcon})}} {\memgloref{}}|memjustarg}{22} -\glossaryentry{lex.string@ {\memgloterm{lex.string}}{\memglodesc{(\ref {lex.string})}} {\memgloref{}}|memjustarg}{23} -\glossaryentry{lex.bool@ {\memgloterm{lex.bool}}{\memglodesc{(\ref {lex.bool})}} {\memgloref{}}|memjustarg}{25} -\glossaryentry{lex.nullptr@ {\memgloterm{lex.nullptr}}{\memglodesc{(\ref {lex.nullptr})}} {\memgloref{}}|memjustarg}{25} -\glossaryentry{lex.ext@ {\memgloterm{lex.ext}}{\memglodesc{(\ref {lex.ext})}} {\memgloref{}}|memjustarg}{25} -\glossaryentry{basic@ {\memgloterm{basic}}{\memglodesc{(\ref {basic})}} {\memgloref{}}|memjustarg}{28} -\glossaryentry{basic.pre@ {\memgloterm{basic.pre}}{\memglodesc{(\ref {basic.pre})}} {\memgloref{}}|memjustarg}{28} -\glossaryentry{basic.def@ {\memgloterm{basic.def}}{\memglodesc{(\ref {basic.def})}} {\memgloref{}}|memjustarg}{28} -\glossaryentry{basic.def.odr@ {\memgloterm{basic.def.odr}}{\memglodesc{(\ref {basic.def.odr})}} {\memgloref{}}|memjustarg}{30} -\glossaryentry{basic.scope@ {\memgloterm{basic.scope}}{\memglodesc{(\ref {basic.scope})}} {\memgloref{}}|memjustarg}{34} -\glossaryentry{basic.scope.declarative@ {\memgloterm{basic.scope.declarative}}{\memglodesc{(\ref {basic.scope.declarative})}} {\memgloref{}}|memjustarg}{34} -\glossaryentry{basic.scope.pdecl@ {\memgloterm{basic.scope.pdecl}}{\memglodesc{(\ref {basic.scope.pdecl})}} {\memgloref{}}|memjustarg}{35} -\glossaryentry{basic.scope.block@ {\memgloterm{basic.scope.block}}{\memglodesc{(\ref {basic.scope.block})}} {\memgloref{}}|memjustarg}{36} -\glossaryentry{basic.scope.param@ {\memgloterm{basic.scope.param}}{\memglodesc{(\ref {basic.scope.param})}} {\memgloref{}}|memjustarg}{37} -\glossaryentry{basic.funscope@ {\memgloterm{basic.funscope}}{\memglodesc{(\ref {basic.funscope})}} {\memgloref{}}|memjustarg}{37} -\glossaryentry{basic.scope.namespace@ {\memgloterm{basic.scope.namespace}}{\memglodesc{(\ref {basic.scope.namespace})}} {\memgloref{}}|memjustarg}{37} -\glossaryentry{basic.scope.class@ {\memgloterm{basic.scope.class}}{\memglodesc{(\ref {basic.scope.class})}} {\memgloref{}}|memjustarg}{38} -\glossaryentry{basic.scope.enum@ {\memgloterm{basic.scope.enum}}{\memglodesc{(\ref {basic.scope.enum})}} {\memgloref{}}|memjustarg}{39} -\glossaryentry{basic.scope.temp@ {\memgloterm{basic.scope.temp}}{\memglodesc{(\ref {basic.scope.temp})}} {\memgloref{}}|memjustarg}{39} -\glossaryentry{basic.scope.hiding@ {\memgloterm{basic.scope.hiding}}{\memglodesc{(\ref {basic.scope.hiding})}} {\memgloref{}}|memjustarg}{40} -\glossaryentry{basic.lookup@ {\memgloterm{basic.lookup}}{\memglodesc{(\ref {basic.lookup})}} {\memgloref{}}|memjustarg}{40} -\glossaryentry{basic.lookup.general@ {\memgloterm{basic.lookup.general}}{\memglodesc{(\ref {basic.lookup.general})}} {\memgloref{}}|memjustarg}{40} -\glossaryentry{basic.lookup.unqual@ {\memgloterm{basic.lookup.unqual}}{\memglodesc{(\ref {basic.lookup.unqual})}} {\memgloref{}}|memjustarg}{40} -\glossaryentry{basic.lookup.argdep@ {\memgloterm{basic.lookup.argdep}}{\memglodesc{(\ref {basic.lookup.argdep})}} {\memgloref{}}|memjustarg}{44} -\glossaryentry{basic.lookup.qual@ {\memgloterm{basic.lookup.qual}}{\memglodesc{(\ref {basic.lookup.qual})}} {\memgloref{}}|memjustarg}{46} -\glossaryentry{basic.lookup.qual.general@ {\memgloterm{basic.lookup.qual.general}}{\memglodesc{(\ref {basic.lookup.qual.general})}} {\memgloref{}}|memjustarg}{46} -\glossaryentry{class.qual@ {\memgloterm{class.qual}}{\memglodesc{(\ref {class.qual})}} {\memgloref{}}|memjustarg}{47} -\glossaryentry{namespace.qual@ {\memgloterm{namespace.qual}}{\memglodesc{(\ref {namespace.qual})}} {\memgloref{}}|memjustarg}{48} -\glossaryentry{basic.lookup.elab@ {\memgloterm{basic.lookup.elab}}{\memglodesc{(\ref {basic.lookup.elab})}} {\memgloref{}}|memjustarg}{51} -\glossaryentry{basic.lookup.classref@ {\memgloterm{basic.lookup.classref}}{\memglodesc{(\ref {basic.lookup.classref})}} {\memgloref{}}|memjustarg}{52} -\glossaryentry{basic.lookup.udir@ {\memgloterm{basic.lookup.udir}}{\memglodesc{(\ref {basic.lookup.udir})}} {\memgloref{}}|memjustarg}{53} -\glossaryentry{basic.link@ {\memgloterm{basic.link}}{\memglodesc{(\ref {basic.link})}} {\memgloref{}}|memjustarg}{53} -\glossaryentry{basic.memobj@ {\memgloterm{basic.memobj}}{\memglodesc{(\ref {basic.memobj})}} {\memgloref{}}|memjustarg}{57} -\glossaryentry{intro.memory@ {\memgloterm{intro.memory}}{\memglodesc{(\ref {intro.memory})}} {\memgloref{}}|memjustarg}{57} -\glossaryentry{intro.object@ {\memgloterm{intro.object}}{\memglodesc{(\ref {intro.object})}} {\memgloref{}}|memjustarg}{58} -\glossaryentry{basic.life@ {\memgloterm{basic.life}}{\memglodesc{(\ref {basic.life})}} {\memgloref{}}|memjustarg}{60} -\glossaryentry{basic.indet@ {\memgloterm{basic.indet}}{\memglodesc{(\ref {basic.indet})}} {\memgloref{}}|memjustarg}{63} -\glossaryentry{basic.stc@ {\memgloterm{basic.stc}}{\memglodesc{(\ref {basic.stc})}} {\memgloref{}}|memjustarg}{64} -\glossaryentry{basic.stc.general@ {\memgloterm{basic.stc.general}}{\memglodesc{(\ref {basic.stc.general})}} {\memgloref{}}|memjustarg}{64} -\glossaryentry{basic.stc.static@ {\memgloterm{basic.stc.static}}{\memglodesc{(\ref {basic.stc.static})}} {\memgloref{}}|memjustarg}{64} -\glossaryentry{basic.stc.thread@ {\memgloterm{basic.stc.thread}}{\memglodesc{(\ref {basic.stc.thread})}} {\memgloref{}}|memjustarg}{64} -\glossaryentry{basic.stc.auto@ {\memgloterm{basic.stc.auto}}{\memglodesc{(\ref {basic.stc.auto})}} {\memgloref{}}|memjustarg}{64} -\glossaryentry{basic.stc.dynamic@ {\memgloterm{basic.stc.dynamic}}{\memglodesc{(\ref {basic.stc.dynamic})}} {\memgloref{}}|memjustarg}{65} -\glossaryentry{basic.stc.dynamic.general@ {\memgloterm{basic.stc.dynamic.general}}{\memglodesc{(\ref {basic.stc.dynamic.general})}} {\memgloref{}}|memjustarg}{65} -\glossaryentry{basic.stc.dynamic.allocation@ {\memgloterm{basic.stc.dynamic.allocation}}{\memglodesc{(\ref {basic.stc.dynamic.allocation})}} {\memgloref{}}|memjustarg}{65} -\glossaryentry{basic.stc.dynamic.deallocation@ {\memgloterm{basic.stc.dynamic.deallocation}}{\memglodesc{(\ref {basic.stc.dynamic.deallocation})}} {\memgloref{}}|memjustarg}{66} -\glossaryentry{basic.stc.dynamic.safety@ {\memgloterm{basic.stc.dynamic.safety}}{\memglodesc{(\ref {basic.stc.dynamic.safety})}} {\memgloref{}}|memjustarg}{67} -\glossaryentry{basic.stc.inherit@ {\memgloterm{basic.stc.inherit}}{\memglodesc{(\ref {basic.stc.inherit})}} {\memgloref{}}|memjustarg}{67} -\glossaryentry{basic.align@ {\memgloterm{basic.align}}{\memglodesc{(\ref {basic.align})}} {\memgloref{}}|memjustarg}{67} -\glossaryentry{class.temporary@ {\memgloterm{class.temporary}}{\memglodesc{(\ref {class.temporary})}} {\memgloref{}}|memjustarg}{68} -\glossaryentry{basic.types@ {\memgloterm{basic.types}}{\memglodesc{(\ref {basic.types})}} {\memgloref{}}|memjustarg}{71} -\glossaryentry{basic.types.general@ {\memgloterm{basic.types.general}}{\memglodesc{(\ref {basic.types.general})}} {\memgloref{}}|memjustarg}{71} -\glossaryentry{basic.fundamental@ {\memgloterm{basic.fundamental}}{\memglodesc{(\ref {basic.fundamental})}} {\memgloref{}}|memjustarg}{73} -\glossaryentry{basic.compound@ {\memgloterm{basic.compound}}{\memglodesc{(\ref {basic.compound})}} {\memgloref{}}|memjustarg}{75} -\glossaryentry{basic.type.qualifier@ {\memgloterm{basic.type.qualifier}}{\memglodesc{(\ref {basic.type.qualifier})}} {\memgloref{}}|memjustarg}{76} -\glossaryentry{conv.rank@ {\memgloterm{conv.rank}}{\memglodesc{(\ref {conv.rank})}} {\memgloref{}}|memjustarg}{77} -\glossaryentry{basic.exec@ {\memgloterm{basic.exec}}{\memglodesc{(\ref {basic.exec})}} {\memgloref{}}|memjustarg}{78} -\glossaryentry{intro.execution@ {\memgloterm{intro.execution}}{\memglodesc{(\ref {intro.execution})}} {\memgloref{}}|memjustarg}{78} -\glossaryentry{intro.multithread@ {\memgloterm{intro.multithread}}{\memglodesc{(\ref {intro.multithread})}} {\memgloref{}}|memjustarg}{80} -\glossaryentry{intro.multithread.general@ {\memgloterm{intro.multithread.general}}{\memglodesc{(\ref {intro.multithread.general})}} {\memgloref{}}|memjustarg}{80} -\glossaryentry{intro.races@ {\memgloterm{intro.races}}{\memglodesc{(\ref {intro.races})}} {\memgloref{}}|memjustarg}{81} -\glossaryentry{intro.progress@ {\memgloterm{intro.progress}}{\memglodesc{(\ref {intro.progress})}} {\memgloref{}}|memjustarg}{84} -\glossaryentry{basic.start@ {\memgloterm{basic.start}}{\memglodesc{(\ref {basic.start})}} {\memgloref{}}|memjustarg}{85} -\glossaryentry{basic.start.main@ {\memgloterm{basic.start.main}}{\memglodesc{(\ref {basic.start.main})}} {\memgloref{}}|memjustarg}{85} -\glossaryentry{basic.start.static@ {\memgloterm{basic.start.static}}{\memglodesc{(\ref {basic.start.static})}} {\memgloref{}}|memjustarg}{86} -\glossaryentry{basic.start.dynamic@ {\memgloterm{basic.start.dynamic}}{\memglodesc{(\ref {basic.start.dynamic})}} {\memgloref{}}|memjustarg}{87} -\glossaryentry{basic.start.term@ {\memgloterm{basic.start.term}}{\memglodesc{(\ref {basic.start.term})}} {\memgloref{}}|memjustarg}{88} -\glossaryentry{expr@ {\memgloterm{expr}}{\memglodesc{(\ref {expr})}} {\memgloref{}}|memjustarg}{90} -\glossaryentry{expr.pre@ {\memgloterm{expr.pre}}{\memglodesc{(\ref {expr.pre})}} {\memgloref{}}|memjustarg}{90} -\glossaryentry{expr.prop@ {\memgloterm{expr.prop}}{\memglodesc{(\ref {expr.prop})}} {\memgloref{}}|memjustarg}{91} -\glossaryentry{basic.lval@ {\memgloterm{basic.lval}}{\memglodesc{(\ref {basic.lval})}} {\memgloref{}}|memjustarg}{91} -\glossaryentry{expr.type@ {\memgloterm{expr.type}}{\memglodesc{(\ref {expr.type})}} {\memgloref{}}|memjustarg}{92} -\glossaryentry{expr.context@ {\memgloterm{expr.context}}{\memglodesc{(\ref {expr.context})}} {\memgloref{}}|memjustarg}{93} -\glossaryentry{conv@ {\memgloterm{conv}}{\memglodesc{(\ref {conv})}} {\memgloref{}}|memjustarg}{94} -\glossaryentry{conv.general@ {\memgloterm{conv.general}}{\memglodesc{(\ref {conv.general})}} {\memgloref{}}|memjustarg}{94} -\glossaryentry{conv.lval@ {\memgloterm{conv.lval}}{\memglodesc{(\ref {conv.lval})}} {\memgloref{}}|memjustarg}{94} -\glossaryentry{conv.array@ {\memgloterm{conv.array}}{\memglodesc{(\ref {conv.array})}} {\memgloref{}}|memjustarg}{95} -\glossaryentry{conv.func@ {\memgloterm{conv.func}}{\memglodesc{(\ref {conv.func})}} {\memgloref{}}|memjustarg}{95} -\glossaryentry{conv.rval@ {\memgloterm{conv.rval}}{\memglodesc{(\ref {conv.rval})}} {\memgloref{}}|memjustarg}{95} -\glossaryentry{conv.qual@ {\memgloterm{conv.qual}}{\memglodesc{(\ref {conv.qual})}} {\memgloref{}}|memjustarg}{96} -\glossaryentry{conv.prom@ {\memgloterm{conv.prom}}{\memglodesc{(\ref {conv.prom})}} {\memgloref{}}|memjustarg}{96} -\glossaryentry{conv.fpprom@ {\memgloterm{conv.fpprom}}{\memglodesc{(\ref {conv.fpprom})}} {\memgloref{}}|memjustarg}{97} -\glossaryentry{conv.integral@ {\memgloterm{conv.integral}}{\memglodesc{(\ref {conv.integral})}} {\memgloref{}}|memjustarg}{97} -\glossaryentry{conv.double@ {\memgloterm{conv.double}}{\memglodesc{(\ref {conv.double})}} {\memgloref{}}|memjustarg}{97} -\glossaryentry{conv.fpint@ {\memgloterm{conv.fpint}}{\memglodesc{(\ref {conv.fpint})}} {\memgloref{}}|memjustarg}{97} -\glossaryentry{conv.ptr@ {\memgloterm{conv.ptr}}{\memglodesc{(\ref {conv.ptr})}} {\memgloref{}}|memjustarg}{97} -\glossaryentry{conv.mem@ {\memgloterm{conv.mem}}{\memglodesc{(\ref {conv.mem})}} {\memgloref{}}|memjustarg}{98} -\glossaryentry{conv.fctptr@ {\memgloterm{conv.fctptr}}{\memglodesc{(\ref {conv.fctptr})}} {\memgloref{}}|memjustarg}{98} -\glossaryentry{conv.bool@ {\memgloterm{conv.bool}}{\memglodesc{(\ref {conv.bool})}} {\memgloref{}}|memjustarg}{98} -\glossaryentry{expr.arith.conv@ {\memgloterm{expr.arith.conv}}{\memglodesc{(\ref {expr.arith.conv})}} {\memgloref{}}|memjustarg}{98} -\glossaryentry{expr.prim@ {\memgloterm{expr.prim}}{\memglodesc{(\ref {expr.prim})}} {\memgloref{}}|memjustarg}{99} -\glossaryentry{expr.prim.literal@ {\memgloterm{expr.prim.literal}}{\memglodesc{(\ref {expr.prim.literal})}} {\memgloref{}}|memjustarg}{99} -\glossaryentry{expr.prim.this@ {\memgloterm{expr.prim.this}}{\memglodesc{(\ref {expr.prim.this})}} {\memgloref{}}|memjustarg}{99} -\glossaryentry{expr.prim.paren@ {\memgloterm{expr.prim.paren}}{\memglodesc{(\ref {expr.prim.paren})}} {\memgloref{}}|memjustarg}{100} -\glossaryentry{expr.prim.id@ {\memgloterm{expr.prim.id}}{\memglodesc{(\ref {expr.prim.id})}} {\memgloref{}}|memjustarg}{100} -\glossaryentry{expr.prim.id.general@ {\memgloterm{expr.prim.id.general}}{\memglodesc{(\ref {expr.prim.id.general})}} {\memgloref{}}|memjustarg}{100} -\glossaryentry{expr.prim.id.unqual@ {\memgloterm{expr.prim.id.unqual}}{\memglodesc{(\ref {expr.prim.id.unqual})}} {\memgloref{}}|memjustarg}{101} -\glossaryentry{expr.prim.id.qual@ {\memgloterm{expr.prim.id.qual}}{\memglodesc{(\ref {expr.prim.id.qual})}} {\memgloref{}}|memjustarg}{102} -\glossaryentry{expr.prim.id.dtor@ {\memgloterm{expr.prim.id.dtor}}{\memglodesc{(\ref {expr.prim.id.dtor})}} {\memgloref{}}|memjustarg}{102} -\glossaryentry{expr.prim.lambda@ {\memgloterm{expr.prim.lambda}}{\memglodesc{(\ref {expr.prim.lambda})}} {\memgloref{}}|memjustarg}{103} -\glossaryentry{expr.prim.lambda.general@ {\memgloterm{expr.prim.lambda.general}}{\memglodesc{(\ref {expr.prim.lambda.general})}} {\memgloref{}}|memjustarg}{103} -\glossaryentry{expr.prim.lambda.closure@ {\memgloterm{expr.prim.lambda.closure}}{\memglodesc{(\ref {expr.prim.lambda.closure})}} {\memgloref{}}|memjustarg}{103} -\glossaryentry{expr.prim.lambda.capture@ {\memgloterm{expr.prim.lambda.capture}}{\memglodesc{(\ref {expr.prim.lambda.capture})}} {\memgloref{}}|memjustarg}{107} -\glossaryentry{expr.prim.fold@ {\memgloterm{expr.prim.fold}}{\memglodesc{(\ref {expr.prim.fold})}} {\memgloref{}}|memjustarg}{112} -\glossaryentry{expr.prim.req@ {\memgloterm{expr.prim.req}}{\memglodesc{(\ref {expr.prim.req})}} {\memgloref{}}|memjustarg}{112} -\glossaryentry{expr.prim.req.general@ {\memgloterm{expr.prim.req.general}}{\memglodesc{(\ref {expr.prim.req.general})}} {\memgloref{}}|memjustarg}{112} -\glossaryentry{expr.prim.req.simple@ {\memgloterm{expr.prim.req.simple}}{\memglodesc{(\ref {expr.prim.req.simple})}} {\memgloref{}}|memjustarg}{114} -\glossaryentry{expr.prim.req.type@ {\memgloterm{expr.prim.req.type}}{\memglodesc{(\ref {expr.prim.req.type})}} {\memgloref{}}|memjustarg}{114} -\glossaryentry{expr.prim.req.compound@ {\memgloterm{expr.prim.req.compound}}{\memglodesc{(\ref {expr.prim.req.compound})}} {\memgloref{}}|memjustarg}{114} -\glossaryentry{expr.prim.req.nested@ {\memgloterm{expr.prim.req.nested}}{\memglodesc{(\ref {expr.prim.req.nested})}} {\memgloref{}}|memjustarg}{115} -\glossaryentry{expr.compound@ {\memgloterm{expr.compound}}{\memglodesc{(\ref {expr.compound})}} {\memgloref{}}|memjustarg}{115} -\glossaryentry{expr.post@ {\memgloterm{expr.post}}{\memglodesc{(\ref {expr.post})}} {\memgloref{}}|memjustarg}{115} -\glossaryentry{expr.post.general@ {\memgloterm{expr.post.general}}{\memglodesc{(\ref {expr.post.general})}} {\memgloref{}}|memjustarg}{115} -\glossaryentry{expr.sub@ {\memgloterm{expr.sub}}{\memglodesc{(\ref {expr.sub})}} {\memgloref{}}|memjustarg}{116} -\glossaryentry{expr.call@ {\memgloterm{expr.call}}{\memglodesc{(\ref {expr.call})}} {\memgloref{}}|memjustarg}{116} -\glossaryentry{expr.type.conv@ {\memgloterm{expr.type.conv}}{\memglodesc{(\ref {expr.type.conv})}} {\memgloref{}}|memjustarg}{118} -\glossaryentry{expr.ref@ {\memgloterm{expr.ref}}{\memglodesc{(\ref {expr.ref})}} {\memgloref{}}|memjustarg}{118} -\glossaryentry{expr.post.incr@ {\memgloterm{expr.post.incr}}{\memglodesc{(\ref {expr.post.incr})}} {\memgloref{}}|memjustarg}{119} -\glossaryentry{expr.dynamic.cast@ {\memgloterm{expr.dynamic.cast}}{\memglodesc{(\ref {expr.dynamic.cast})}} {\memgloref{}}|memjustarg}{120} -\glossaryentry{expr.typeid@ {\memgloterm{expr.typeid}}{\memglodesc{(\ref {expr.typeid})}} {\memgloref{}}|memjustarg}{121} -\glossaryentry{expr.static.cast@ {\memgloterm{expr.static.cast}}{\memglodesc{(\ref {expr.static.cast})}} {\memgloref{}}|memjustarg}{122} -\glossaryentry{expr.reinterpret.cast@ {\memgloterm{expr.reinterpret.cast}}{\memglodesc{(\ref {expr.reinterpret.cast})}} {\memgloref{}}|memjustarg}{123} -\glossaryentry{expr.const.cast@ {\memgloterm{expr.const.cast}}{\memglodesc{(\ref {expr.const.cast})}} {\memgloref{}}|memjustarg}{125} -\glossaryentry{expr.unary@ {\memgloterm{expr.unary}}{\memglodesc{(\ref {expr.unary})}} {\memgloref{}}|memjustarg}{126} -\glossaryentry{expr.unary.general@ {\memgloterm{expr.unary.general}}{\memglodesc{(\ref {expr.unary.general})}} {\memgloref{}}|memjustarg}{126} -\glossaryentry{expr.unary.op@ {\memgloterm{expr.unary.op}}{\memglodesc{(\ref {expr.unary.op})}} {\memgloref{}}|memjustarg}{126} -\glossaryentry{expr.pre.incr@ {\memgloterm{expr.pre.incr}}{\memglodesc{(\ref {expr.pre.incr})}} {\memgloref{}}|memjustarg}{127} -\glossaryentry{expr.await@ {\memgloterm{expr.await}}{\memglodesc{(\ref {expr.await})}} {\memgloref{}}|memjustarg}{127} -\glossaryentry{expr.sizeof@ {\memgloterm{expr.sizeof}}{\memglodesc{(\ref {expr.sizeof})}} {\memgloref{}}|memjustarg}{129} -\glossaryentry{expr.alignof@ {\memgloterm{expr.alignof}}{\memglodesc{(\ref {expr.alignof})}} {\memgloref{}}|memjustarg}{129} -\glossaryentry{expr.unary.noexcept@ {\memgloterm{expr.unary.noexcept}}{\memglodesc{(\ref {expr.unary.noexcept})}} {\memgloref{}}|memjustarg}{130} -\glossaryentry{expr.new@ {\memgloterm{expr.new}}{\memglodesc{(\ref {expr.new})}} {\memgloref{}}|memjustarg}{130} -\glossaryentry{expr.delete@ {\memgloterm{expr.delete}}{\memglodesc{(\ref {expr.delete})}} {\memgloref{}}|memjustarg}{134} -\glossaryentry{expr.cast@ {\memgloterm{expr.cast}}{\memglodesc{(\ref {expr.cast})}} {\memgloref{}}|memjustarg}{136} -\glossaryentry{expr.mptr.oper@ {\memgloterm{expr.mptr.oper}}{\memglodesc{(\ref {expr.mptr.oper})}} {\memgloref{}}|memjustarg}{137} -\glossaryentry{expr.mul@ {\memgloterm{expr.mul}}{\memglodesc{(\ref {expr.mul})}} {\memgloref{}}|memjustarg}{138} -\glossaryentry{expr.add@ {\memgloterm{expr.add}}{\memglodesc{(\ref {expr.add})}} {\memgloref{}}|memjustarg}{138} -\glossaryentry{expr.shift@ {\memgloterm{expr.shift}}{\memglodesc{(\ref {expr.shift})}} {\memgloref{}}|memjustarg}{139} -\glossaryentry{expr.spaceship@ {\memgloterm{expr.spaceship}}{\memglodesc{(\ref {expr.spaceship})}} {\memgloref{}}|memjustarg}{139} -\glossaryentry{expr.rel@ {\memgloterm{expr.rel}}{\memglodesc{(\ref {expr.rel})}} {\memgloref{}}|memjustarg}{140} -\glossaryentry{expr.eq@ {\memgloterm{expr.eq}}{\memglodesc{(\ref {expr.eq})}} {\memgloref{}}|memjustarg}{141} -\glossaryentry{expr.bit.and@ {\memgloterm{expr.bit.and}}{\memglodesc{(\ref {expr.bit.and})}} {\memgloref{}}|memjustarg}{142} -\glossaryentry{expr.xor@ {\memgloterm{expr.xor}}{\memglodesc{(\ref {expr.xor})}} {\memgloref{}}|memjustarg}{142} -\glossaryentry{expr.or@ {\memgloterm{expr.or}}{\memglodesc{(\ref {expr.or})}} {\memgloref{}}|memjustarg}{142} -\glossaryentry{expr.log.and@ {\memgloterm{expr.log.and}}{\memglodesc{(\ref {expr.log.and})}} {\memgloref{}}|memjustarg}{142} -\glossaryentry{expr.log.or@ {\memgloterm{expr.log.or}}{\memglodesc{(\ref {expr.log.or})}} {\memgloref{}}|memjustarg}{143} -\glossaryentry{expr.cond@ {\memgloterm{expr.cond}}{\memglodesc{(\ref {expr.cond})}} {\memgloref{}}|memjustarg}{143} -\glossaryentry{expr.yield@ {\memgloterm{expr.yield}}{\memglodesc{(\ref {expr.yield})}} {\memgloref{}}|memjustarg}{144} -\glossaryentry{expr.throw@ {\memgloterm{expr.throw}}{\memglodesc{(\ref {expr.throw})}} {\memgloref{}}|memjustarg}{145} -\glossaryentry{expr.ass@ {\memgloterm{expr.ass}}{\memglodesc{(\ref {expr.ass})}} {\memgloref{}}|memjustarg}{145} -\glossaryentry{expr.comma@ {\memgloterm{expr.comma}}{\memglodesc{(\ref {expr.comma})}} {\memgloref{}}|memjustarg}{146} -\glossaryentry{expr.const@ {\memgloterm{expr.const}}{\memglodesc{(\ref {expr.const})}} {\memgloref{}}|memjustarg}{147} -\glossaryentry{stmt.stmt@ {\memgloterm{stmt.stmt}}{\memglodesc{(\ref {stmt.stmt})}} {\memgloref{}}|memjustarg}{153} -\glossaryentry{stmt.pre@ {\memgloterm{stmt.pre}}{\memglodesc{(\ref {stmt.pre})}} {\memgloref{}}|memjustarg}{153} -\glossaryentry{stmt.label@ {\memgloterm{stmt.label}}{\memglodesc{(\ref {stmt.label})}} {\memgloref{}}|memjustarg}{154} -\glossaryentry{stmt.expr@ {\memgloterm{stmt.expr}}{\memglodesc{(\ref {stmt.expr})}} {\memgloref{}}|memjustarg}{154} -\glossaryentry{stmt.block@ {\memgloterm{stmt.block}}{\memglodesc{(\ref {stmt.block})}} {\memgloref{}}|memjustarg}{154} -\glossaryentry{stmt.select@ {\memgloterm{stmt.select}}{\memglodesc{(\ref {stmt.select})}} {\memgloref{}}|memjustarg}{154} -\glossaryentry{stmt.select.general@ {\memgloterm{stmt.select.general}}{\memglodesc{(\ref {stmt.select.general})}} {\memgloref{}}|memjustarg}{154} -\glossaryentry{stmt.if@ {\memgloterm{stmt.if}}{\memglodesc{(\ref {stmt.if})}} {\memgloref{}}|memjustarg}{155} -\glossaryentry{stmt.switch@ {\memgloterm{stmt.switch}}{\memglodesc{(\ref {stmt.switch})}} {\memgloref{}}|memjustarg}{156} -\glossaryentry{stmt.iter@ {\memgloterm{stmt.iter}}{\memglodesc{(\ref {stmt.iter})}} {\memgloref{}}|memjustarg}{156} -\glossaryentry{stmt.iter.general@ {\memgloterm{stmt.iter.general}}{\memglodesc{(\ref {stmt.iter.general})}} {\memgloref{}}|memjustarg}{156} -\glossaryentry{stmt.while@ {\memgloterm{stmt.while}}{\memglodesc{(\ref {stmt.while})}} {\memgloref{}}|memjustarg}{157} -\glossaryentry{stmt.do@ {\memgloterm{stmt.do}}{\memglodesc{(\ref {stmt.do})}} {\memgloref{}}|memjustarg}{157} -\glossaryentry{stmt.for@ {\memgloterm{stmt.for}}{\memglodesc{(\ref {stmt.for})}} {\memgloref{}}|memjustarg}{158} -\glossaryentry{stmt.ranged@ {\memgloterm{stmt.ranged}}{\memglodesc{(\ref {stmt.ranged})}} {\memgloref{}}|memjustarg}{158} -\glossaryentry{stmt.jump@ {\memgloterm{stmt.jump}}{\memglodesc{(\ref {stmt.jump})}} {\memgloref{}}|memjustarg}{159} -\glossaryentry{stmt.jump.general@ {\memgloterm{stmt.jump.general}}{\memglodesc{(\ref {stmt.jump.general})}} {\memgloref{}}|memjustarg}{159} -\glossaryentry{stmt.break@ {\memgloterm{stmt.break}}{\memglodesc{(\ref {stmt.break})}} {\memgloref{}}|memjustarg}{159} -\glossaryentry{stmt.cont@ {\memgloterm{stmt.cont}}{\memglodesc{(\ref {stmt.cont})}} {\memgloref{}}|memjustarg}{159} -\glossaryentry{stmt.return@ {\memgloterm{stmt.return}}{\memglodesc{(\ref {stmt.return})}} {\memgloref{}}|memjustarg}{160} -\glossaryentry{stmt.return.coroutine@ {\memgloterm{stmt.return.coroutine}}{\memglodesc{(\ref {stmt.return.coroutine})}} {\memgloref{}}|memjustarg}{160} -\glossaryentry{stmt.goto@ {\memgloterm{stmt.goto}}{\memglodesc{(\ref {stmt.goto})}} {\memgloref{}}|memjustarg}{160} -\glossaryentry{stmt.dcl@ {\memgloterm{stmt.dcl}}{\memglodesc{(\ref {stmt.dcl})}} {\memgloref{}}|memjustarg}{161} -\glossaryentry{stmt.ambig@ {\memgloterm{stmt.ambig}}{\memglodesc{(\ref {stmt.ambig})}} {\memgloref{}}|memjustarg}{161} -\glossaryentry{dcl.dcl@ {\memgloterm{dcl.dcl}}{\memglodesc{(\ref {dcl.dcl})}} {\memgloref{}}|memjustarg}{163} -\glossaryentry{dcl.pre@ {\memgloterm{dcl.pre}}{\memglodesc{(\ref {dcl.pre})}} {\memgloref{}}|memjustarg}{163} -\glossaryentry{dcl.spec@ {\memgloterm{dcl.spec}}{\memglodesc{(\ref {dcl.spec})}} {\memgloref{}}|memjustarg}{165} -\glossaryentry{dcl.spec.general@ {\memgloterm{dcl.spec.general}}{\memglodesc{(\ref {dcl.spec.general})}} {\memgloref{}}|memjustarg}{165} -\glossaryentry{dcl.stc@ {\memgloterm{dcl.stc}}{\memglodesc{(\ref {dcl.stc})}} {\memgloref{}}|memjustarg}{165} -\glossaryentry{dcl.fct.spec@ {\memgloterm{dcl.fct.spec}}{\memglodesc{(\ref {dcl.fct.spec})}} {\memgloref{}}|memjustarg}{167} -\glossaryentry{dcl.typedef@ {\memgloterm{dcl.typedef}}{\memglodesc{(\ref {dcl.typedef})}} {\memgloref{}}|memjustarg}{167} -\glossaryentry{dcl.friend@ {\memgloterm{dcl.friend}}{\memglodesc{(\ref {dcl.friend})}} {\memgloref{}}|memjustarg}{169} -\glossaryentry{dcl.constexpr@ {\memgloterm{dcl.constexpr}}{\memglodesc{(\ref {dcl.constexpr})}} {\memgloref{}}|memjustarg}{169} -\glossaryentry{dcl.constinit@ {\memgloterm{dcl.constinit}}{\memglodesc{(\ref {dcl.constinit})}} {\memgloref{}}|memjustarg}{172} -\glossaryentry{dcl.inline@ {\memgloterm{dcl.inline}}{\memglodesc{(\ref {dcl.inline})}} {\memgloref{}}|memjustarg}{172} -\glossaryentry{dcl.type@ {\memgloterm{dcl.type}}{\memglodesc{(\ref {dcl.type})}} {\memgloref{}}|memjustarg}{173} -\glossaryentry{dcl.type.general@ {\memgloterm{dcl.type.general}}{\memglodesc{(\ref {dcl.type.general})}} {\memgloref{}}|memjustarg}{173} -\glossaryentry{dcl.type.cv@ {\memgloterm{dcl.type.cv}}{\memglodesc{(\ref {dcl.type.cv})}} {\memgloref{}}|memjustarg}{173} -\glossaryentry{dcl.type.simple@ {\memgloterm{dcl.type.simple}}{\memglodesc{(\ref {dcl.type.simple})}} {\memgloref{}}|memjustarg}{174} -\glossaryentry{dcl.type.elab@ {\memgloterm{dcl.type.elab}}{\memglodesc{(\ref {dcl.type.elab})}} {\memgloref{}}|memjustarg}{175} -\glossaryentry{dcl.type.decltype@ {\memgloterm{dcl.type.decltype}}{\memglodesc{(\ref {dcl.type.decltype})}} {\memgloref{}}|memjustarg}{177} -\glossaryentry{dcl.spec.auto@ {\memgloterm{dcl.spec.auto}}{\memglodesc{(\ref {dcl.spec.auto})}} {\memgloref{}}|memjustarg}{178} -\glossaryentry{dcl.spec.auto.general@ {\memgloterm{dcl.spec.auto.general}}{\memglodesc{(\ref {dcl.spec.auto.general})}} {\memgloref{}}|memjustarg}{178} -\glossaryentry{dcl.type.auto.deduct@ {\memgloterm{dcl.type.auto.deduct}}{\memglodesc{(\ref {dcl.type.auto.deduct})}} {\memgloref{}}|memjustarg}{180} -\glossaryentry{dcl.type.class.deduct@ {\memgloterm{dcl.type.class.deduct}}{\memglodesc{(\ref {dcl.type.class.deduct})}} {\memgloref{}}|memjustarg}{181} -\glossaryentry{dcl.decl@ {\memgloterm{dcl.decl}}{\memglodesc{(\ref {dcl.decl})}} {\memgloref{}}|memjustarg}{182} -\glossaryentry{dcl.decl.general@ {\memgloterm{dcl.decl.general}}{\memglodesc{(\ref {dcl.decl.general})}} {\memgloref{}}|memjustarg}{182} -\glossaryentry{dcl.name@ {\memgloterm{dcl.name}}{\memglodesc{(\ref {dcl.name})}} {\memgloref{}}|memjustarg}{184} -\glossaryentry{dcl.ambig.res@ {\memgloterm{dcl.ambig.res}}{\memglodesc{(\ref {dcl.ambig.res})}} {\memgloref{}}|memjustarg}{184} -\glossaryentry{dcl.meaning@ {\memgloterm{dcl.meaning}}{\memglodesc{(\ref {dcl.meaning})}} {\memgloref{}}|memjustarg}{185} -\glossaryentry{dcl.meaning.general@ {\memgloterm{dcl.meaning.general}}{\memglodesc{(\ref {dcl.meaning.general})}} {\memgloref{}}|memjustarg}{185} -\glossaryentry{dcl.ptr@ {\memgloterm{dcl.ptr}}{\memglodesc{(\ref {dcl.ptr})}} {\memgloref{}}|memjustarg}{186} -\glossaryentry{dcl.ref@ {\memgloterm{dcl.ref}}{\memglodesc{(\ref {dcl.ref})}} {\memgloref{}}|memjustarg}{187} -\glossaryentry{dcl.mptr@ {\memgloterm{dcl.mptr}}{\memglodesc{(\ref {dcl.mptr})}} {\memgloref{}}|memjustarg}{188} -\glossaryentry{dcl.array@ {\memgloterm{dcl.array}}{\memglodesc{(\ref {dcl.array})}} {\memgloref{}}|memjustarg}{189} -\glossaryentry{dcl.fct@ {\memgloterm{dcl.fct}}{\memglodesc{(\ref {dcl.fct})}} {\memgloref{}}|memjustarg}{190} -\glossaryentry{dcl.fct.default@ {\memgloterm{dcl.fct.default}}{\memglodesc{(\ref {dcl.fct.default})}} {\memgloref{}}|memjustarg}{194} -\glossaryentry{dcl.init@ {\memgloterm{dcl.init}}{\memglodesc{(\ref {dcl.init})}} {\memgloref{}}|memjustarg}{197} -\glossaryentry{dcl.init.general@ {\memgloterm{dcl.init.general}}{\memglodesc{(\ref {dcl.init.general})}} {\memgloref{}}|memjustarg}{197} -\glossaryentry{dcl.init.aggr@ {\memgloterm{dcl.init.aggr}}{\memglodesc{(\ref {dcl.init.aggr})}} {\memgloref{}}|memjustarg}{201} -\glossaryentry{dcl.init.string@ {\memgloterm{dcl.init.string}}{\memglodesc{(\ref {dcl.init.string})}} {\memgloref{}}|memjustarg}{206} -\glossaryentry{dcl.init.ref@ {\memgloterm{dcl.init.ref}}{\memglodesc{(\ref {dcl.init.ref})}} {\memgloref{}}|memjustarg}{206} -\glossaryentry{dcl.init.list@ {\memgloterm{dcl.init.list}}{\memglodesc{(\ref {dcl.init.list})}} {\memgloref{}}|memjustarg}{208} -\glossaryentry{dcl.fct.def@ {\memgloterm{dcl.fct.def}}{\memglodesc{(\ref {dcl.fct.def})}} {\memgloref{}}|memjustarg}{213} -\glossaryentry{dcl.fct.def.general@ {\memgloterm{dcl.fct.def.general}}{\memglodesc{(\ref {dcl.fct.def.general})}} {\memgloref{}}|memjustarg}{213} -\glossaryentry{dcl.fct.def.default@ {\memgloterm{dcl.fct.def.default}}{\memglodesc{(\ref {dcl.fct.def.default})}} {\memgloref{}}|memjustarg}{214} -\glossaryentry{dcl.fct.def.delete@ {\memgloterm{dcl.fct.def.delete}}{\memglodesc{(\ref {dcl.fct.def.delete})}} {\memgloref{}}|memjustarg}{215} -\glossaryentry{dcl.fct.def.coroutine@ {\memgloterm{dcl.fct.def.coroutine}}{\memglodesc{(\ref {dcl.fct.def.coroutine})}} {\memgloref{}}|memjustarg}{216} -\glossaryentry{dcl.struct.bind@ {\memgloterm{dcl.struct.bind}}{\memglodesc{(\ref {dcl.struct.bind})}} {\memgloref{}}|memjustarg}{219} -\glossaryentry{enum@ {\memgloterm{enum}}{\memglodesc{(\ref {enum})}} {\memgloref{}}|memjustarg}{220} -\glossaryentry{dcl.enum@ {\memgloterm{dcl.enum}}{\memglodesc{(\ref {dcl.enum})}} {\memgloref{}}|memjustarg}{220} -\glossaryentry{enum.udecl@ {\memgloterm{enum.udecl}}{\memglodesc{(\ref {enum.udecl})}} {\memgloref{}}|memjustarg}{223} -\glossaryentry{basic.namespace@ {\memgloterm{basic.namespace}}{\memglodesc{(\ref {basic.namespace})}} {\memgloref{}}|memjustarg}{223} -\glossaryentry{basic.namespace.general@ {\memgloterm{basic.namespace.general}}{\memglodesc{(\ref {basic.namespace.general})}} {\memgloref{}}|memjustarg}{223} -\glossaryentry{namespace.def@ {\memgloterm{namespace.def}}{\memglodesc{(\ref {namespace.def})}} {\memgloref{}}|memjustarg}{224} -\glossaryentry{namespace.def.general@ {\memgloterm{namespace.def.general}}{\memglodesc{(\ref {namespace.def.general})}} {\memgloref{}}|memjustarg}{224} -\glossaryentry{namespace.unnamed@ {\memgloterm{namespace.unnamed}}{\memglodesc{(\ref {namespace.unnamed})}} {\memgloref{}}|memjustarg}{225} -\glossaryentry{namespace.memdef@ {\memgloterm{namespace.memdef}}{\memglodesc{(\ref {namespace.memdef})}} {\memgloref{}}|memjustarg}{226} -\glossaryentry{namespace.alias@ {\memgloterm{namespace.alias}}{\memglodesc{(\ref {namespace.alias})}} {\memgloref{}}|memjustarg}{227} -\glossaryentry{namespace.udir@ {\memgloterm{namespace.udir}}{\memglodesc{(\ref {namespace.udir})}} {\memgloref{}}|memjustarg}{228} -\glossaryentry{namespace.udecl@ {\memgloterm{namespace.udecl}}{\memglodesc{(\ref {namespace.udecl})}} {\memgloref{}}|memjustarg}{230} -\glossaryentry{dcl.asm@ {\memgloterm{dcl.asm}}{\memglodesc{(\ref {dcl.asm})}} {\memgloref{}}|memjustarg}{236} -\glossaryentry{dcl.link@ {\memgloterm{dcl.link}}{\memglodesc{(\ref {dcl.link})}} {\memgloref{}}|memjustarg}{236} -\glossaryentry{dcl.attr@ {\memgloterm{dcl.attr}}{\memglodesc{(\ref {dcl.attr})}} {\memgloref{}}|memjustarg}{239} -\glossaryentry{dcl.attr.grammar@ {\memgloterm{dcl.attr.grammar}}{\memglodesc{(\ref {dcl.attr.grammar})}} {\memgloref{}}|memjustarg}{239} -\glossaryentry{dcl.align@ {\memgloterm{dcl.align}}{\memglodesc{(\ref {dcl.align})}} {\memgloref{}}|memjustarg}{240} -\glossaryentry{dcl.attr.depend@ {\memgloterm{dcl.attr.depend}}{\memglodesc{(\ref {dcl.attr.depend})}} {\memgloref{}}|memjustarg}{241} -\glossaryentry{dcl.attr.deprecated@ {\memgloterm{dcl.attr.deprecated}}{\memglodesc{(\ref {dcl.attr.deprecated})}} {\memgloref{}}|memjustarg}{242} -\glossaryentry{dcl.attr.fallthrough@ {\memgloterm{dcl.attr.fallthrough}}{\memglodesc{(\ref {dcl.attr.fallthrough})}} {\memgloref{}}|memjustarg}{243} -\glossaryentry{dcl.attr.likelihood@ {\memgloterm{dcl.attr.likelihood}}{\memglodesc{(\ref {dcl.attr.likelihood})}} {\memgloref{}}|memjustarg}{243} -\glossaryentry{dcl.attr.unused@ {\memgloterm{dcl.attr.unused}}{\memglodesc{(\ref {dcl.attr.unused})}} {\memgloref{}}|memjustarg}{244} -\glossaryentry{dcl.attr.nodiscard@ {\memgloterm{dcl.attr.nodiscard}}{\memglodesc{(\ref {dcl.attr.nodiscard})}} {\memgloref{}}|memjustarg}{244} -\glossaryentry{dcl.attr.noreturn@ {\memgloterm{dcl.attr.noreturn}}{\memglodesc{(\ref {dcl.attr.noreturn})}} {\memgloref{}}|memjustarg}{245} -\glossaryentry{dcl.attr.nouniqueaddr@ {\memgloterm{dcl.attr.nouniqueaddr}}{\memglodesc{(\ref {dcl.attr.nouniqueaddr})}} {\memgloref{}}|memjustarg}{245} -\glossaryentry{module@ {\memgloterm{module}}{\memglodesc{(\ref {module})}} {\memgloref{}}|memjustarg}{247} -\glossaryentry{module.unit@ {\memgloterm{module.unit}}{\memglodesc{(\ref {module.unit})}} {\memgloref{}}|memjustarg}{247} -\glossaryentry{module.interface@ {\memgloterm{module.interface}}{\memglodesc{(\ref {module.interface})}} {\memgloref{}}|memjustarg}{248} -\glossaryentry{module.import@ {\memgloterm{module.import}}{\memglodesc{(\ref {module.import})}} {\memgloref{}}|memjustarg}{251} -\glossaryentry{module.global.frag@ {\memgloterm{module.global.frag}}{\memglodesc{(\ref {module.global.frag})}} {\memgloref{}}|memjustarg}{252} -\glossaryentry{module.private.frag@ {\memgloterm{module.private.frag}}{\memglodesc{(\ref {module.private.frag})}} {\memgloref{}}|memjustarg}{254} -\glossaryentry{module.context@ {\memgloterm{module.context}}{\memglodesc{(\ref {module.context})}} {\memgloref{}}|memjustarg}{255} -\glossaryentry{module.reach@ {\memgloterm{module.reach}}{\memglodesc{(\ref {module.reach})}} {\memgloref{}}|memjustarg}{256} -\glossaryentry{class@ {\memgloterm{class}}{\memglodesc{(\ref {class})}} {\memgloref{}}|memjustarg}{258} -\glossaryentry{class.pre@ {\memgloterm{class.pre}}{\memglodesc{(\ref {class.pre})}} {\memgloref{}}|memjustarg}{258} -\glossaryentry{class.prop@ {\memgloterm{class.prop}}{\memglodesc{(\ref {class.prop})}} {\memgloref{}}|memjustarg}{259} -\glossaryentry{class.name@ {\memgloterm{class.name}}{\memglodesc{(\ref {class.name})}} {\memgloref{}}|memjustarg}{260} -\glossaryentry{class.mem@ {\memgloterm{class.mem}}{\memglodesc{(\ref {class.mem})}} {\memgloref{}}|memjustarg}{262} -\glossaryentry{class.mem.general@ {\memgloterm{class.mem.general}}{\memglodesc{(\ref {class.mem.general})}} {\memgloref{}}|memjustarg}{262} -\glossaryentry{class.mfct@ {\memgloterm{class.mfct}}{\memglodesc{(\ref {class.mfct})}} {\memgloref{}}|memjustarg}{265} -\glossaryentry{class.mfct.non-static@ {\memgloterm{class.mfct.non-static}}{\memglodesc{(\ref {class.mfct.non-static})}} {\memgloref{}}|memjustarg}{266} -\glossaryentry{class.mfct.non-static.general@ {\memgloterm{class.mfct.non-static.general}}{\memglodesc{(\ref {class.mfct.non-static.general})}} {\memgloref{}}|memjustarg}{266} -\glossaryentry{class.this@ {\memgloterm{class.this}}{\memglodesc{(\ref {class.this})}} {\memgloref{}}|memjustarg}{267} -\glossaryentry{special@ {\memgloterm{special}}{\memglodesc{(\ref {special})}} {\memgloref{}}|memjustarg}{268} -\glossaryentry{class.ctor@ {\memgloterm{class.ctor}}{\memglodesc{(\ref {class.ctor})}} {\memgloref{}}|memjustarg}{269} -\glossaryentry{class.ctor.general@ {\memgloterm{class.ctor.general}}{\memglodesc{(\ref {class.ctor.general})}} {\memgloref{}}|memjustarg}{269} -\glossaryentry{class.default.ctor@ {\memgloterm{class.default.ctor}}{\memglodesc{(\ref {class.default.ctor})}} {\memgloref{}}|memjustarg}{269} -\glossaryentry{class.copy.ctor@ {\memgloterm{class.copy.ctor}}{\memglodesc{(\ref {class.copy.ctor})}} {\memgloref{}}|memjustarg}{270} -\glossaryentry{class.copy.assign@ {\memgloterm{class.copy.assign}}{\memglodesc{(\ref {class.copy.assign})}} {\memgloref{}}|memjustarg}{273} -\glossaryentry{class.dtor@ {\memgloterm{class.dtor}}{\memglodesc{(\ref {class.dtor})}} {\memgloref{}}|memjustarg}{275} -\glossaryentry{class.conv@ {\memgloterm{class.conv}}{\memglodesc{(\ref {class.conv})}} {\memgloref{}}|memjustarg}{278} -\glossaryentry{class.conv.general@ {\memgloterm{class.conv.general}}{\memglodesc{(\ref {class.conv.general})}} {\memgloref{}}|memjustarg}{278} -\glossaryentry{class.conv.ctor@ {\memgloterm{class.conv.ctor}}{\memglodesc{(\ref {class.conv.ctor})}} {\memgloref{}}|memjustarg}{279} -\glossaryentry{class.conv.fct@ {\memgloterm{class.conv.fct}}{\memglodesc{(\ref {class.conv.fct})}} {\memgloref{}}|memjustarg}{279} -\glossaryentry{class.static@ {\memgloterm{class.static}}{\memglodesc{(\ref {class.static})}} {\memgloref{}}|memjustarg}{281} -\glossaryentry{class.static.general@ {\memgloterm{class.static.general}}{\memglodesc{(\ref {class.static.general})}} {\memgloref{}}|memjustarg}{281} -\glossaryentry{class.static.mfct@ {\memgloterm{class.static.mfct}}{\memglodesc{(\ref {class.static.mfct})}} {\memgloref{}}|memjustarg}{281} -\glossaryentry{class.static.data@ {\memgloterm{class.static.data}}{\memglodesc{(\ref {class.static.data})}} {\memgloref{}}|memjustarg}{282} -\glossaryentry{class.bit@ {\memgloterm{class.bit}}{\memglodesc{(\ref {class.bit})}} {\memgloref{}}|memjustarg}{282} -\glossaryentry{class.nest@ {\memgloterm{class.nest}}{\memglodesc{(\ref {class.nest})}} {\memgloref{}}|memjustarg}{283} -\glossaryentry{class.nested.type@ {\memgloterm{class.nested.type}}{\memglodesc{(\ref {class.nested.type})}} {\memgloref{}}|memjustarg}{284} -\glossaryentry{class.union@ {\memgloterm{class.union}}{\memglodesc{(\ref {class.union})}} {\memgloref{}}|memjustarg}{284} -\glossaryentry{class.union.general@ {\memgloterm{class.union.general}}{\memglodesc{(\ref {class.union.general})}} {\memgloref{}}|memjustarg}{284} -\glossaryentry{class.union.anon@ {\memgloterm{class.union.anon}}{\memglodesc{(\ref {class.union.anon})}} {\memgloref{}}|memjustarg}{286} -\glossaryentry{class.local@ {\memgloterm{class.local}}{\memglodesc{(\ref {class.local})}} {\memgloref{}}|memjustarg}{287} -\glossaryentry{class.derived@ {\memgloterm{class.derived}}{\memglodesc{(\ref {class.derived})}} {\memgloref{}}|memjustarg}{287} -\glossaryentry{class.derived.general@ {\memgloterm{class.derived.general}}{\memglodesc{(\ref {class.derived.general})}} {\memgloref{}}|memjustarg}{287} -\glossaryentry{class.mi@ {\memgloterm{class.mi}}{\memglodesc{(\ref {class.mi})}} {\memgloref{}}|memjustarg}{289} -\glossaryentry{class.virtual@ {\memgloterm{class.virtual}}{\memglodesc{(\ref {class.virtual})}} {\memgloref{}}|memjustarg}{290} -\glossaryentry{class.abstract@ {\memgloterm{class.abstract}}{\memglodesc{(\ref {class.abstract})}} {\memgloref{}}|memjustarg}{294} -\glossaryentry{class.member.lookup@ {\memgloterm{class.member.lookup}}{\memglodesc{(\ref {class.member.lookup})}} {\memgloref{}}|memjustarg}{295} -\glossaryentry{class.access@ {\memgloterm{class.access}}{\memglodesc{(\ref {class.access})}} {\memgloref{}}|memjustarg}{298} -\glossaryentry{class.access.general@ {\memgloterm{class.access.general}}{\memglodesc{(\ref {class.access.general})}} {\memgloref{}}|memjustarg}{298} -\glossaryentry{class.access.spec@ {\memgloterm{class.access.spec}}{\memglodesc{(\ref {class.access.spec})}} {\memgloref{}}|memjustarg}{300} -\glossaryentry{class.access.base@ {\memgloterm{class.access.base}}{\memglodesc{(\ref {class.access.base})}} {\memgloref{}}|memjustarg}{301} -\glossaryentry{class.friend@ {\memgloterm{class.friend}}{\memglodesc{(\ref {class.friend})}} {\memgloref{}}|memjustarg}{303} -\glossaryentry{class.protected@ {\memgloterm{class.protected}}{\memglodesc{(\ref {class.protected})}} {\memgloref{}}|memjustarg}{306} -\glossaryentry{class.access.virt@ {\memgloterm{class.access.virt}}{\memglodesc{(\ref {class.access.virt})}} {\memgloref{}}|memjustarg}{306} -\glossaryentry{class.paths@ {\memgloterm{class.paths}}{\memglodesc{(\ref {class.paths})}} {\memgloref{}}|memjustarg}{307} -\glossaryentry{class.access.nest@ {\memgloterm{class.access.nest}}{\memglodesc{(\ref {class.access.nest})}} {\memgloref{}}|memjustarg}{307} -\glossaryentry{class.init@ {\memgloterm{class.init}}{\memglodesc{(\ref {class.init})}} {\memgloref{}}|memjustarg}{308} -\glossaryentry{class.init.general@ {\memgloterm{class.init.general}}{\memglodesc{(\ref {class.init.general})}} {\memgloref{}}|memjustarg}{308} -\glossaryentry{class.expl.init@ {\memgloterm{class.expl.init}}{\memglodesc{(\ref {class.expl.init})}} {\memgloref{}}|memjustarg}{308} -\glossaryentry{class.base.init@ {\memgloterm{class.base.init}}{\memglodesc{(\ref {class.base.init})}} {\memgloref{}}|memjustarg}{309} -\glossaryentry{class.inhctor.init@ {\memgloterm{class.inhctor.init}}{\memglodesc{(\ref {class.inhctor.init})}} {\memgloref{}}|memjustarg}{313} -\glossaryentry{class.cdtor@ {\memgloterm{class.cdtor}}{\memglodesc{(\ref {class.cdtor})}} {\memgloref{}}|memjustarg}{314} -\glossaryentry{class.copy.elision@ {\memgloterm{class.copy.elision}}{\memglodesc{(\ref {class.copy.elision})}} {\memgloref{}}|memjustarg}{317} -\glossaryentry{class.compare@ {\memgloterm{class.compare}}{\memglodesc{(\ref {class.compare})}} {\memgloref{}}|memjustarg}{319} -\glossaryentry{class.compare.default@ {\memgloterm{class.compare.default}}{\memglodesc{(\ref {class.compare.default})}} {\memgloref{}}|memjustarg}{319} -\glossaryentry{class.eq@ {\memgloterm{class.eq}}{\memglodesc{(\ref {class.eq})}} {\memgloref{}}|memjustarg}{320} -\glossaryentry{class.spaceship@ {\memgloterm{class.spaceship}}{\memglodesc{(\ref {class.spaceship})}} {\memgloref{}}|memjustarg}{321} -\glossaryentry{class.compare.secondary@ {\memgloterm{class.compare.secondary}}{\memglodesc{(\ref {class.compare.secondary})}} {\memgloref{}}|memjustarg}{321} -\glossaryentry{class.free@ {\memgloterm{class.free}}{\memglodesc{(\ref {class.free})}} {\memgloref{}}|memjustarg}{322} -\glossaryentry{over@ {\memgloterm{over}}{\memglodesc{(\ref {over})}} {\memgloref{}}|memjustarg}{324} -\glossaryentry{over.pre@ {\memgloterm{over.pre}}{\memglodesc{(\ref {over.pre})}} {\memgloref{}}|memjustarg}{324} -\glossaryentry{over.load@ {\memgloterm{over.load}}{\memglodesc{(\ref {over.load})}} {\memgloref{}}|memjustarg}{324} -\glossaryentry{over.dcl@ {\memgloterm{over.dcl}}{\memglodesc{(\ref {over.dcl})}} {\memgloref{}}|memjustarg}{326} -\glossaryentry{over.match@ {\memgloterm{over.match}}{\memglodesc{(\ref {over.match})}} {\memgloref{}}|memjustarg}{327} -\glossaryentry{over.match.general@ {\memgloterm{over.match.general}}{\memglodesc{(\ref {over.match.general})}} {\memgloref{}}|memjustarg}{327} -\glossaryentry{over.match.funcs@ {\memgloterm{over.match.funcs}}{\memglodesc{(\ref {over.match.funcs})}} {\memgloref{}}|memjustarg}{328} -\glossaryentry{over.match.funcs.general@ {\memgloterm{over.match.funcs.general}}{\memglodesc{(\ref {over.match.funcs.general})}} {\memgloref{}}|memjustarg}{328} -\glossaryentry{over.match.call@ {\memgloterm{over.match.call}}{\memglodesc{(\ref {over.match.call})}} {\memgloref{}}|memjustarg}{329} -\glossaryentry{over.match.call.general@ {\memgloterm{over.match.call.general}}{\memglodesc{(\ref {over.match.call.general})}} {\memgloref{}}|memjustarg}{329} -\glossaryentry{over.call.func@ {\memgloterm{over.call.func}}{\memglodesc{(\ref {over.call.func})}} {\memgloref{}}|memjustarg}{330} -\glossaryentry{over.call.object@ {\memgloterm{over.call.object}}{\memglodesc{(\ref {over.call.object})}} {\memgloref{}}|memjustarg}{330} -\glossaryentry{over.match.oper@ {\memgloterm{over.match.oper}}{\memglodesc{(\ref {over.match.oper})}} {\memgloref{}}|memjustarg}{331} -\glossaryentry{over.match.ctor@ {\memgloterm{over.match.ctor}}{\memglodesc{(\ref {over.match.ctor})}} {\memgloref{}}|memjustarg}{334} -\glossaryentry{over.match.copy@ {\memgloterm{over.match.copy}}{\memglodesc{(\ref {over.match.copy})}} {\memgloref{}}|memjustarg}{334} -\glossaryentry{over.match.conv@ {\memgloterm{over.match.conv}}{\memglodesc{(\ref {over.match.conv})}} {\memgloref{}}|memjustarg}{334} -\glossaryentry{over.match.ref@ {\memgloterm{over.match.ref}}{\memglodesc{(\ref {over.match.ref})}} {\memgloref{}}|memjustarg}{335} -\glossaryentry{over.match.list@ {\memgloterm{over.match.list}}{\memglodesc{(\ref {over.match.list})}} {\memgloref{}}|memjustarg}{335} -\glossaryentry{over.match.class.deduct@ {\memgloterm{over.match.class.deduct}}{\memglodesc{(\ref {over.match.class.deduct})}} {\memgloref{}}|memjustarg}{335} -\glossaryentry{over.match.viable@ {\memgloterm{over.match.viable}}{\memglodesc{(\ref {over.match.viable})}} {\memgloref{}}|memjustarg}{339} -\glossaryentry{over.match.best@ {\memgloterm{over.match.best}}{\memglodesc{(\ref {over.match.best})}} {\memgloref{}}|memjustarg}{339} -\glossaryentry{over.match.best.general@ {\memgloterm{over.match.best.general}}{\memglodesc{(\ref {over.match.best.general})}} {\memgloref{}}|memjustarg}{339} -\glossaryentry{over.best.ics@ {\memgloterm{over.best.ics}}{\memglodesc{(\ref {over.best.ics})}} {\memgloref{}}|memjustarg}{342} -\glossaryentry{over.best.ics.general@ {\memgloterm{over.best.ics.general}}{\memglodesc{(\ref {over.best.ics.general})}} {\memgloref{}}|memjustarg}{342} -\glossaryentry{over.ics.scs@ {\memgloterm{over.ics.scs}}{\memglodesc{(\ref {over.ics.scs})}} {\memgloref{}}|memjustarg}{344} -\glossaryentry{over.ics.user@ {\memgloterm{over.ics.user}}{\memglodesc{(\ref {over.ics.user})}} {\memgloref{}}|memjustarg}{344} -\glossaryentry{over.ics.ellipsis@ {\memgloterm{over.ics.ellipsis}}{\memglodesc{(\ref {over.ics.ellipsis})}} {\memgloref{}}|memjustarg}{345} -\glossaryentry{over.ics.ref@ {\memgloterm{over.ics.ref}}{\memglodesc{(\ref {over.ics.ref})}} {\memgloref{}}|memjustarg}{345} -\glossaryentry{over.ics.list@ {\memgloterm{over.ics.list}}{\memglodesc{(\ref {over.ics.list})}} {\memgloref{}}|memjustarg}{345} -\glossaryentry{over.ics.rank@ {\memgloterm{over.ics.rank}}{\memglodesc{(\ref {over.ics.rank})}} {\memgloref{}}|memjustarg}{348} -\glossaryentry{over.over@ {\memgloterm{over.over}}{\memglodesc{(\ref {over.over})}} {\memgloref{}}|memjustarg}{351} -\glossaryentry{over.oper@ {\memgloterm{over.oper}}{\memglodesc{(\ref {over.oper})}} {\memgloref{}}|memjustarg}{352} -\glossaryentry{over.oper.general@ {\memgloterm{over.oper.general}}{\memglodesc{(\ref {over.oper.general})}} {\memgloref{}}|memjustarg}{352} -\glossaryentry{over.unary@ {\memgloterm{over.unary}}{\memglodesc{(\ref {over.unary})}} {\memgloref{}}|memjustarg}{353} -\glossaryentry{over.binary@ {\memgloterm{over.binary}}{\memglodesc{(\ref {over.binary})}} {\memgloref{}}|memjustarg}{354} -\glossaryentry{over.binary.general@ {\memgloterm{over.binary.general}}{\memglodesc{(\ref {over.binary.general})}} {\memgloref{}}|memjustarg}{354} -\glossaryentry{over.ass@ {\memgloterm{over.ass}}{\memglodesc{(\ref {over.ass})}} {\memgloref{}}|memjustarg}{354} -\glossaryentry{over.call@ {\memgloterm{over.call}}{\memglodesc{(\ref {over.call})}} {\memgloref{}}|memjustarg}{354} -\glossaryentry{over.sub@ {\memgloterm{over.sub}}{\memglodesc{(\ref {over.sub})}} {\memgloref{}}|memjustarg}{355} -\glossaryentry{over.ref@ {\memgloterm{over.ref}}{\memglodesc{(\ref {over.ref})}} {\memgloref{}}|memjustarg}{355} -\glossaryentry{over.inc@ {\memgloterm{over.inc}}{\memglodesc{(\ref {over.inc})}} {\memgloref{}}|memjustarg}{355} -\glossaryentry{over.built@ {\memgloterm{over.built}}{\memglodesc{(\ref {over.built})}} {\memgloref{}}|memjustarg}{356} -\glossaryentry{over.literal@ {\memgloterm{over.literal}}{\memglodesc{(\ref {over.literal})}} {\memgloref{}}|memjustarg}{358} -\glossaryentry{temp@ {\memgloterm{temp}}{\memglodesc{(\ref {temp})}} {\memgloref{}}|memjustarg}{360} -\glossaryentry{temp.pre@ {\memgloterm{temp.pre}}{\memglodesc{(\ref {temp.pre})}} {\memgloref{}}|memjustarg}{360} -\glossaryentry{temp.param@ {\memgloterm{temp.param}}{\memglodesc{(\ref {temp.param})}} {\memgloref{}}|memjustarg}{361} -\glossaryentry{temp.names@ {\memgloterm{temp.names}}{\memglodesc{(\ref {temp.names})}} {\memgloref{}}|memjustarg}{365} -\glossaryentry{temp.arg@ {\memgloterm{temp.arg}}{\memglodesc{(\ref {temp.arg})}} {\memgloref{}}|memjustarg}{368} -\glossaryentry{temp.arg.general@ {\memgloterm{temp.arg.general}}{\memglodesc{(\ref {temp.arg.general})}} {\memgloref{}}|memjustarg}{368} -\glossaryentry{temp.arg.type@ {\memgloterm{temp.arg.type}}{\memglodesc{(\ref {temp.arg.type})}} {\memgloref{}}|memjustarg}{370} -\glossaryentry{temp.arg.nontype@ {\memgloterm{temp.arg.nontype}}{\memglodesc{(\ref {temp.arg.nontype})}} {\memgloref{}}|memjustarg}{370} -\glossaryentry{temp.arg.template@ {\memgloterm{temp.arg.template}}{\memglodesc{(\ref {temp.arg.template})}} {\memgloref{}}|memjustarg}{372} -\glossaryentry{temp.constr@ {\memgloterm{temp.constr}}{\memglodesc{(\ref {temp.constr})}} {\memgloref{}}|memjustarg}{374} -\glossaryentry{temp.constr.general@ {\memgloterm{temp.constr.general}}{\memglodesc{(\ref {temp.constr.general})}} {\memgloref{}}|memjustarg}{374} -\glossaryentry{temp.constr.constr@ {\memgloterm{temp.constr.constr}}{\memglodesc{(\ref {temp.constr.constr})}} {\memgloref{}}|memjustarg}{374} -\glossaryentry{temp.constr.constr.general@ {\memgloterm{temp.constr.constr.general}}{\memglodesc{(\ref {temp.constr.constr.general})}} {\memgloref{}}|memjustarg}{374} -\glossaryentry{temp.constr.op@ {\memgloterm{temp.constr.op}}{\memglodesc{(\ref {temp.constr.op})}} {\memgloref{}}|memjustarg}{374} -\glossaryentry{temp.constr.atomic@ {\memgloterm{temp.constr.atomic}}{\memglodesc{(\ref {temp.constr.atomic})}} {\memgloref{}}|memjustarg}{375} -\glossaryentry{temp.constr.decl@ {\memgloterm{temp.constr.decl}}{\memglodesc{(\ref {temp.constr.decl})}} {\memgloref{}}|memjustarg}{376} -\glossaryentry{temp.constr.normal@ {\memgloterm{temp.constr.normal}}{\memglodesc{(\ref {temp.constr.normal})}} {\memgloref{}}|memjustarg}{377} -\glossaryentry{temp.constr.order@ {\memgloterm{temp.constr.order}}{\memglodesc{(\ref {temp.constr.order})}} {\memgloref{}}|memjustarg}{378} -\glossaryentry{temp.type@ {\memgloterm{temp.type}}{\memglodesc{(\ref {temp.type})}} {\memgloref{}}|memjustarg}{379} -\glossaryentry{temp.decls@ {\memgloterm{temp.decls}}{\memglodesc{(\ref {temp.decls})}} {\memgloref{}}|memjustarg}{380} -\glossaryentry{temp.decls.general@ {\memgloterm{temp.decls.general}}{\memglodesc{(\ref {temp.decls.general})}} {\memgloref{}}|memjustarg}{380} -\glossaryentry{temp.class@ {\memgloterm{temp.class}}{\memglodesc{(\ref {temp.class})}} {\memgloref{}}|memjustarg}{380} -\glossaryentry{temp.class.general@ {\memgloterm{temp.class.general}}{\memglodesc{(\ref {temp.class.general})}} {\memgloref{}}|memjustarg}{380} -\glossaryentry{temp.mem.func@ {\memgloterm{temp.mem.func}}{\memglodesc{(\ref {temp.mem.func})}} {\memgloref{}}|memjustarg}{381} -\glossaryentry{temp.deduct.guide@ {\memgloterm{temp.deduct.guide}}{\memglodesc{(\ref {temp.deduct.guide})}} {\memgloref{}}|memjustarg}{382} -\glossaryentry{temp.mem.class@ {\memgloterm{temp.mem.class}}{\memglodesc{(\ref {temp.mem.class})}} {\memgloref{}}|memjustarg}{382} -\glossaryentry{temp.static@ {\memgloterm{temp.static}}{\memglodesc{(\ref {temp.static})}} {\memgloref{}}|memjustarg}{382} -\glossaryentry{temp.mem.enum@ {\memgloterm{temp.mem.enum}}{\memglodesc{(\ref {temp.mem.enum})}} {\memgloref{}}|memjustarg}{383} -\glossaryentry{temp.mem@ {\memgloterm{temp.mem}}{\memglodesc{(\ref {temp.mem})}} {\memgloref{}}|memjustarg}{383} -\glossaryentry{temp.variadic@ {\memgloterm{temp.variadic}}{\memglodesc{(\ref {temp.variadic})}} {\memgloref{}}|memjustarg}{385} -\glossaryentry{temp.friend@ {\memgloterm{temp.friend}}{\memglodesc{(\ref {temp.friend})}} {\memgloref{}}|memjustarg}{387} -\glossaryentry{temp.class.spec@ {\memgloterm{temp.class.spec}}{\memglodesc{(\ref {temp.class.spec})}} {\memgloref{}}|memjustarg}{390} -\glossaryentry{temp.class.spec.general@ {\memgloterm{temp.class.spec.general}}{\memglodesc{(\ref {temp.class.spec.general})}} {\memgloref{}}|memjustarg}{390} -\glossaryentry{temp.class.spec.match@ {\memgloterm{temp.class.spec.match}}{\memglodesc{(\ref {temp.class.spec.match})}} {\memgloref{}}|memjustarg}{391} -\glossaryentry{temp.class.order@ {\memgloterm{temp.class.order}}{\memglodesc{(\ref {temp.class.order})}} {\memgloref{}}|memjustarg}{392} -\glossaryentry{temp.class.spec.mfunc@ {\memgloterm{temp.class.spec.mfunc}}{\memglodesc{(\ref {temp.class.spec.mfunc})}} {\memgloref{}}|memjustarg}{393} -\glossaryentry{temp.fct@ {\memgloterm{temp.fct}}{\memglodesc{(\ref {temp.fct})}} {\memgloref{}}|memjustarg}{394} -\glossaryentry{temp.fct.general@ {\memgloterm{temp.fct.general}}{\memglodesc{(\ref {temp.fct.general})}} {\memgloref{}}|memjustarg}{394} -\glossaryentry{temp.over.link@ {\memgloterm{temp.over.link}}{\memglodesc{(\ref {temp.over.link})}} {\memgloref{}}|memjustarg}{394} -\glossaryentry{temp.func.order@ {\memgloterm{temp.func.order}}{\memglodesc{(\ref {temp.func.order})}} {\memgloref{}}|memjustarg}{396} -\glossaryentry{temp.alias@ {\memgloterm{temp.alias}}{\memglodesc{(\ref {temp.alias})}} {\memgloref{}}|memjustarg}{399} -\glossaryentry{temp.concept@ {\memgloterm{temp.concept}}{\memglodesc{(\ref {temp.concept})}} {\memgloref{}}|memjustarg}{400} -\glossaryentry{temp.res@ {\memgloterm{temp.res}}{\memglodesc{(\ref {temp.res})}} {\memgloref{}}|memjustarg}{401} -\glossaryentry{temp.res.general@ {\memgloterm{temp.res.general}}{\memglodesc{(\ref {temp.res.general})}} {\memgloref{}}|memjustarg}{401} -\glossaryentry{temp.local@ {\memgloterm{temp.local}}{\memglodesc{(\ref {temp.local})}} {\memgloref{}}|memjustarg}{405} -\glossaryentry{temp.dep@ {\memgloterm{temp.dep}}{\memglodesc{(\ref {temp.dep})}} {\memgloref{}}|memjustarg}{407} -\glossaryentry{temp.dep.general@ {\memgloterm{temp.dep.general}}{\memglodesc{(\ref {temp.dep.general})}} {\memgloref{}}|memjustarg}{407} -\glossaryentry{temp.dep.type@ {\memgloterm{temp.dep.type}}{\memglodesc{(\ref {temp.dep.type})}} {\memgloref{}}|memjustarg}{408} -\glossaryentry{temp.dep.expr@ {\memgloterm{temp.dep.expr}}{\memglodesc{(\ref {temp.dep.expr})}} {\memgloref{}}|memjustarg}{412} -\glossaryentry{temp.dep.constexpr@ {\memgloterm{temp.dep.constexpr}}{\memglodesc{(\ref {temp.dep.constexpr})}} {\memgloref{}}|memjustarg}{413} -\glossaryentry{temp.dep.temp@ {\memgloterm{temp.dep.temp}}{\memglodesc{(\ref {temp.dep.temp})}} {\memgloref{}}|memjustarg}{413} -\glossaryentry{temp.nondep@ {\memgloterm{temp.nondep}}{\memglodesc{(\ref {temp.nondep})}} {\memgloref{}}|memjustarg}{413} -\glossaryentry{temp.dep.res@ {\memgloterm{temp.dep.res}}{\memglodesc{(\ref {temp.dep.res})}} {\memgloref{}}|memjustarg}{414} -\glossaryentry{temp.point@ {\memgloterm{temp.point}}{\memglodesc{(\ref {temp.point})}} {\memgloref{}}|memjustarg}{414} -\glossaryentry{temp.dep.candidate@ {\memgloterm{temp.dep.candidate}}{\memglodesc{(\ref {temp.dep.candidate})}} {\memgloref{}}|memjustarg}{414} -\glossaryentry{temp.inject@ {\memgloterm{temp.inject}}{\memglodesc{(\ref {temp.inject})}} {\memgloref{}}|memjustarg}{417} -\glossaryentry{temp.spec@ {\memgloterm{temp.spec}}{\memglodesc{(\ref {temp.spec})}} {\memgloref{}}|memjustarg}{417} -\glossaryentry{temp.spec.general@ {\memgloterm{temp.spec.general}}{\memglodesc{(\ref {temp.spec.general})}} {\memgloref{}}|memjustarg}{417} -\glossaryentry{temp.inst@ {\memgloterm{temp.inst}}{\memglodesc{(\ref {temp.inst})}} {\memgloref{}}|memjustarg}{419} -\glossaryentry{temp.explicit@ {\memgloterm{temp.explicit}}{\memglodesc{(\ref {temp.explicit})}} {\memgloref{}}|memjustarg}{423} -\glossaryentry{temp.expl.spec@ {\memgloterm{temp.expl.spec}}{\memglodesc{(\ref {temp.expl.spec})}} {\memgloref{}}|memjustarg}{426} -\glossaryentry{temp.fct.spec@ {\memgloterm{temp.fct.spec}}{\memglodesc{(\ref {temp.fct.spec})}} {\memgloref{}}|memjustarg}{431} -\glossaryentry{temp.fct.spec.general@ {\memgloterm{temp.fct.spec.general}}{\memglodesc{(\ref {temp.fct.spec.general})}} {\memgloref{}}|memjustarg}{431} -\glossaryentry{temp.arg.explicit@ {\memgloterm{temp.arg.explicit}}{\memglodesc{(\ref {temp.arg.explicit})}} {\memgloref{}}|memjustarg}{431} -\glossaryentry{temp.deduct@ {\memgloterm{temp.deduct}}{\memglodesc{(\ref {temp.deduct})}} {\memgloref{}}|memjustarg}{433} -\glossaryentry{temp.deduct.general@ {\memgloterm{temp.deduct.general}}{\memglodesc{(\ref {temp.deduct.general})}} {\memgloref{}}|memjustarg}{433} -\glossaryentry{temp.deduct.call@ {\memgloterm{temp.deduct.call}}{\memglodesc{(\ref {temp.deduct.call})}} {\memgloref{}}|memjustarg}{437} -\glossaryentry{temp.deduct.funcaddr@ {\memgloterm{temp.deduct.funcaddr}}{\memglodesc{(\ref {temp.deduct.funcaddr})}} {\memgloref{}}|memjustarg}{440} -\glossaryentry{temp.deduct.conv@ {\memgloterm{temp.deduct.conv}}{\memglodesc{(\ref {temp.deduct.conv})}} {\memgloref{}}|memjustarg}{440} -\glossaryentry{temp.deduct.partial@ {\memgloterm{temp.deduct.partial}}{\memglodesc{(\ref {temp.deduct.partial})}} {\memgloref{}}|memjustarg}{441} -\glossaryentry{temp.deduct.type@ {\memgloterm{temp.deduct.type}}{\memglodesc{(\ref {temp.deduct.type})}} {\memgloref{}}|memjustarg}{442} -\glossaryentry{temp.deduct.decl@ {\memgloterm{temp.deduct.decl}}{\memglodesc{(\ref {temp.deduct.decl})}} {\memgloref{}}|memjustarg}{448} -\glossaryentry{temp.over@ {\memgloterm{temp.over}}{\memglodesc{(\ref {temp.over})}} {\memgloref{}}|memjustarg}{449} -\glossaryentry{except@ {\memgloterm{except}}{\memglodesc{(\ref {except})}} {\memgloref{}}|memjustarg}{451} -\glossaryentry{except.pre@ {\memgloterm{except.pre}}{\memglodesc{(\ref {except.pre})}} {\memgloref{}}|memjustarg}{451} -\glossaryentry{except.throw@ {\memgloterm{except.throw}}{\memglodesc{(\ref {except.throw})}} {\memgloref{}}|memjustarg}{452} -\glossaryentry{except.ctor@ {\memgloterm{except.ctor}}{\memglodesc{(\ref {except.ctor})}} {\memgloref{}}|memjustarg}{453} -\glossaryentry{except.handle@ {\memgloterm{except.handle}}{\memglodesc{(\ref {except.handle})}} {\memgloref{}}|memjustarg}{454} -\glossaryentry{except.spec@ {\memgloterm{except.spec}}{\memglodesc{(\ref {except.spec})}} {\memgloref{}}|memjustarg}{456} -\glossaryentry{except.special@ {\memgloterm{except.special}}{\memglodesc{(\ref {except.special})}} {\memgloref{}}|memjustarg}{458} -\glossaryentry{except.special.general@ {\memgloterm{except.special.general}}{\memglodesc{(\ref {except.special.general})}} {\memgloref{}}|memjustarg}{458} -\glossaryentry{except.terminate@ {\memgloterm{except.terminate}}{\memglodesc{(\ref {except.terminate})}} {\memgloref{}}|memjustarg}{458} -\glossaryentry{except.uncaught@ {\memgloterm{except.uncaught}}{\memglodesc{(\ref {except.uncaught})}} {\memgloref{}}|memjustarg}{459} -\glossaryentry{cpp@ {\memgloterm{cpp}}{\memglodesc{(\ref {cpp})}} {\memgloref{}}|memjustarg}{460} -\glossaryentry{cpp.pre@ {\memgloterm{cpp.pre}}{\memglodesc{(\ref {cpp.pre})}} {\memgloref{}}|memjustarg}{460} -\glossaryentry{cpp.cond@ {\memgloterm{cpp.cond}}{\memglodesc{(\ref {cpp.cond})}} {\memgloref{}}|memjustarg}{462} -\glossaryentry{cpp.include@ {\memgloterm{cpp.include}}{\memglodesc{(\ref {cpp.include})}} {\memgloref{}}|memjustarg}{464} -\glossaryentry{cpp.module@ {\memgloterm{cpp.module}}{\memglodesc{(\ref {cpp.module})}} {\memgloref{}}|memjustarg}{465} -\glossaryentry{cpp.import@ {\memgloterm{cpp.import}}{\memglodesc{(\ref {cpp.import})}} {\memgloref{}}|memjustarg}{466} -\glossaryentry{cpp.replace@ {\memgloterm{cpp.replace}}{\memglodesc{(\ref {cpp.replace})}} {\memgloref{}}|memjustarg}{467} -\glossaryentry{cpp.replace.general@ {\memgloterm{cpp.replace.general}}{\memglodesc{(\ref {cpp.replace.general})}} {\memgloref{}}|memjustarg}{467} -\glossaryentry{cpp.subst@ {\memgloterm{cpp.subst}}{\memglodesc{(\ref {cpp.subst})}} {\memgloref{}}|memjustarg}{468} -\glossaryentry{cpp.stringize@ {\memgloterm{cpp.stringize}}{\memglodesc{(\ref {cpp.stringize})}} {\memgloref{}}|memjustarg}{470} -\glossaryentry{cpp.concat@ {\memgloterm{cpp.concat}}{\memglodesc{(\ref {cpp.concat})}} {\memgloref{}}|memjustarg}{470} -\glossaryentry{cpp.rescan@ {\memgloterm{cpp.rescan}}{\memglodesc{(\ref {cpp.rescan})}} {\memgloref{}}|memjustarg}{471} -\glossaryentry{cpp.scope@ {\memgloterm{cpp.scope}}{\memglodesc{(\ref {cpp.scope})}} {\memgloref{}}|memjustarg}{472} -\glossaryentry{cpp.line@ {\memgloterm{cpp.line}}{\memglodesc{(\ref {cpp.line})}} {\memgloref{}}|memjustarg}{472} -\glossaryentry{cpp.error@ {\memgloterm{cpp.error}}{\memglodesc{(\ref {cpp.error})}} {\memgloref{}}|memjustarg}{473} -\glossaryentry{cpp.pragma@ {\memgloterm{cpp.pragma}}{\memglodesc{(\ref {cpp.pragma})}} {\memgloref{}}|memjustarg}{473} -\glossaryentry{cpp.null@ {\memgloterm{cpp.null}}{\memglodesc{(\ref {cpp.null})}} {\memgloref{}}|memjustarg}{473} -\glossaryentry{cpp.predefined@ {\memgloterm{cpp.predefined}}{\memglodesc{(\ref {cpp.predefined})}} {\memgloref{}}|memjustarg}{473} -\glossaryentry{cpp.pragma.op@ {\memgloterm{cpp.pragma.op}}{\memglodesc{(\ref {cpp.pragma.op})}} {\memgloref{}}|memjustarg}{476} -\glossaryentry{library@ {\memgloterm{library}}{\memglodesc{(\ref {library})}} {\memgloref{}}|memjustarg}{478} -\glossaryentry{library.general@ {\memgloterm{library.general}}{\memglodesc{(\ref {library.general})}} {\memgloref{}}|memjustarg}{478} -\glossaryentry{library.c@ {\memgloterm{library.c}}{\memglodesc{(\ref {library.c})}} {\memgloref{}}|memjustarg}{479} -\glossaryentry{description@ {\memgloterm{description}}{\memglodesc{(\ref {description})}} {\memgloref{}}|memjustarg}{479} -\glossaryentry{description.general@ {\memgloterm{description.general}}{\memglodesc{(\ref {description.general})}} {\memgloref{}}|memjustarg}{479} -\glossaryentry{structure@ {\memgloterm{structure}}{\memglodesc{(\ref {structure})}} {\memgloref{}}|memjustarg}{479} -\glossaryentry{structure.elements@ {\memgloterm{structure.elements}}{\memglodesc{(\ref {structure.elements})}} {\memgloref{}}|memjustarg}{479} -\glossaryentry{structure.summary@ {\memgloterm{structure.summary}}{\memglodesc{(\ref {structure.summary})}} {\memgloref{}}|memjustarg}{479} -\glossaryentry{structure.requirements@ {\memgloterm{structure.requirements}}{\memglodesc{(\ref {structure.requirements})}} {\memgloref{}}|memjustarg}{479} -\glossaryentry{structure.specifications@ {\memgloterm{structure.specifications}}{\memglodesc{(\ref {structure.specifications})}} {\memgloref{}}|memjustarg}{480} -\glossaryentry{structure.see.also@ {\memgloterm{structure.see.also}}{\memglodesc{(\ref {structure.see.also})}} {\memgloref{}}|memjustarg}{481} -\glossaryentry{conventions@ {\memgloterm{conventions}}{\memglodesc{(\ref {conventions})}} {\memgloref{}}|memjustarg}{481} -\glossaryentry{conventions.general@ {\memgloterm{conventions.general}}{\memglodesc{(\ref {conventions.general})}} {\memgloref{}}|memjustarg}{481} -\glossaryentry{expos.only.func@ {\memgloterm{expos.only.func}}{\memglodesc{(\ref {expos.only.func})}} {\memgloref{}}|memjustarg}{482} -\glossaryentry{type.descriptions@ {\memgloterm{type.descriptions}}{\memglodesc{(\ref {type.descriptions})}} {\memgloref{}}|memjustarg}{482} -\glossaryentry{type.descriptions.general@ {\memgloterm{type.descriptions.general}}{\memglodesc{(\ref {type.descriptions.general})}} {\memgloref{}}|memjustarg}{482} -\glossaryentry{expos.only.types@ {\memgloterm{expos.only.types}}{\memglodesc{(\ref {expos.only.types})}} {\memgloref{}}|memjustarg}{482} -\glossaryentry{enumerated.types@ {\memgloterm{enumerated.types}}{\memglodesc{(\ref {enumerated.types})}} {\memgloref{}}|memjustarg}{482} -\glossaryentry{bitmask.types@ {\memgloterm{bitmask.types}}{\memglodesc{(\ref {bitmask.types})}} {\memgloref{}}|memjustarg}{483} -\glossaryentry{character.seq@ {\memgloterm{character.seq}}{\memglodesc{(\ref {character.seq})}} {\memgloref{}}|memjustarg}{483} -\glossaryentry{character.seq.general@ {\memgloterm{character.seq.general}}{\memglodesc{(\ref {character.seq.general})}} {\memgloref{}}|memjustarg}{483} -\glossaryentry{byte.strings@ {\memgloterm{byte.strings}}{\memglodesc{(\ref {byte.strings})}} {\memgloref{}}|memjustarg}{484} -\glossaryentry{multibyte.strings@ {\memgloterm{multibyte.strings}}{\memglodesc{(\ref {multibyte.strings})}} {\memgloref{}}|memjustarg}{484} -\glossaryentry{customization.point.object@ {\memgloterm{customization.point.object}}{\memglodesc{(\ref {customization.point.object})}} {\memgloref{}}|memjustarg}{484} -\glossaryentry{functions.within.classes@ {\memgloterm{functions.within.classes}}{\memglodesc{(\ref {functions.within.classes})}} {\memgloref{}}|memjustarg}{484} -\glossaryentry{objects.within.classes@ {\memgloterm{objects.within.classes}}{\memglodesc{(\ref {objects.within.classes})}} {\memgloref{}}|memjustarg}{485} -\glossaryentry{requirements@ {\memgloterm{requirements}}{\memglodesc{(\ref {requirements})}} {\memgloref{}}|memjustarg}{485} -\glossaryentry{requirements.general@ {\memgloterm{requirements.general}}{\memglodesc{(\ref {requirements.general})}} {\memgloref{}}|memjustarg}{485} -\glossaryentry{organization@ {\memgloterm{organization}}{\memglodesc{(\ref {organization})}} {\memgloref{}}|memjustarg}{485} -\glossaryentry{organization.general@ {\memgloterm{organization.general}}{\memglodesc{(\ref {organization.general})}} {\memgloref{}}|memjustarg}{485} -\glossaryentry{contents@ {\memgloterm{contents}}{\memglodesc{(\ref {contents})}} {\memgloref{}}|memjustarg}{485} -\glossaryentry{headers@ {\memgloterm{headers}}{\memglodesc{(\ref {headers})}} {\memgloref{}}|memjustarg}{485} -\glossaryentry{compliance@ {\memgloterm{compliance}}{\memglodesc{(\ref {compliance})}} {\memgloref{}}|memjustarg}{487} -\glossaryentry{using@ {\memgloterm{using}}{\memglodesc{(\ref {using})}} {\memgloref{}}|memjustarg}{487} -\glossaryentry{using.overview@ {\memgloterm{using.overview}}{\memglodesc{(\ref {using.overview})}} {\memgloref{}}|memjustarg}{487} -\glossaryentry{using.headers@ {\memgloterm{using.headers}}{\memglodesc{(\ref {using.headers})}} {\memgloref{}}|memjustarg}{487} -\glossaryentry{using.linkage@ {\memgloterm{using.linkage}}{\memglodesc{(\ref {using.linkage})}} {\memgloref{}}|memjustarg}{488} -\glossaryentry{utility.requirements@ {\memgloterm{utility.requirements}}{\memglodesc{(\ref {utility.requirements})}} {\memgloref{}}|memjustarg}{488} -\glossaryentry{utility.requirements.general@ {\memgloterm{utility.requirements.general}}{\memglodesc{(\ref {utility.requirements.general})}} {\memgloref{}}|memjustarg}{488} -\glossaryentry{utility.arg.requirements@ {\memgloterm{utility.arg.requirements}}{\memglodesc{(\ref {utility.arg.requirements})}} {\memgloref{}}|memjustarg}{488} -\glossaryentry{swappable.requirements@ {\memgloterm{swappable.requirements}}{\memglodesc{(\ref {swappable.requirements})}} {\memgloref{}}|memjustarg}{489} -\glossaryentry{nullablepointer.requirements@ {\memgloterm{nullablepointer.requirements}}{\memglodesc{(\ref {nullablepointer.requirements})}} {\memgloref{}}|memjustarg}{491} -\glossaryentry{hash.requirements@ {\memgloterm{hash.requirements}}{\memglodesc{(\ref {hash.requirements})}} {\memgloref{}}|memjustarg}{491} -\glossaryentry{allocator.requirements@ {\memgloterm{allocator.requirements}}{\memglodesc{(\ref {allocator.requirements})}} {\memgloref{}}|memjustarg}{492} -\glossaryentry{allocator.requirements.general@ {\memgloterm{allocator.requirements.general}}{\memglodesc{(\ref {allocator.requirements.general})}} {\memgloref{}}|memjustarg}{492} -\glossaryentry{allocator.requirements.completeness@ {\memgloterm{allocator.requirements.completeness}}{\memglodesc{(\ref {allocator.requirements.completeness})}} {\memgloref{}}|memjustarg}{497} -\glossaryentry{constraints@ {\memgloterm{constraints}}{\memglodesc{(\ref {constraints})}} {\memgloref{}}|memjustarg}{497} -\glossaryentry{constraints.overview@ {\memgloterm{constraints.overview}}{\memglodesc{(\ref {constraints.overview})}} {\memgloref{}}|memjustarg}{497} -\glossaryentry{namespace.constraints@ {\memgloterm{namespace.constraints}}{\memglodesc{(\ref {namespace.constraints})}} {\memgloref{}}|memjustarg}{497} -\glossaryentry{namespace.std@ {\memgloterm{namespace.std}}{\memglodesc{(\ref {namespace.std})}} {\memgloref{}}|memjustarg}{497} -\glossaryentry{namespace.posix@ {\memgloterm{namespace.posix}}{\memglodesc{(\ref {namespace.posix})}} {\memgloref{}}|memjustarg}{498} -\glossaryentry{namespace.future@ {\memgloterm{namespace.future}}{\memglodesc{(\ref {namespace.future})}} {\memgloref{}}|memjustarg}{498} -\glossaryentry{reserved.names@ {\memgloterm{reserved.names}}{\memglodesc{(\ref {reserved.names})}} {\memgloref{}}|memjustarg}{498} -\glossaryentry{reserved.names.general@ {\memgloterm{reserved.names.general}}{\memglodesc{(\ref {reserved.names.general})}} {\memgloref{}}|memjustarg}{498} -\glossaryentry{zombie.names@ {\memgloterm{zombie.names}}{\memglodesc{(\ref {zombie.names})}} {\memgloref{}}|memjustarg}{498} -\glossaryentry{macro.names@ {\memgloterm{macro.names}}{\memglodesc{(\ref {macro.names})}} {\memgloref{}}|memjustarg}{500} -\glossaryentry{extern.names@ {\memgloterm{extern.names}}{\memglodesc{(\ref {extern.names})}} {\memgloref{}}|memjustarg}{500} -\glossaryentry{extern.types@ {\memgloterm{extern.types}}{\memglodesc{(\ref {extern.types})}} {\memgloref{}}|memjustarg}{500} -\glossaryentry{usrlit.suffix@ {\memgloterm{usrlit.suffix}}{\memglodesc{(\ref {usrlit.suffix})}} {\memgloref{}}|memjustarg}{500} -\glossaryentry{alt.headers@ {\memgloterm{alt.headers}}{\memglodesc{(\ref {alt.headers})}} {\memgloref{}}|memjustarg}{500} -\glossaryentry{derived.classes@ {\memgloterm{derived.classes}}{\memglodesc{(\ref {derived.classes})}} {\memgloref{}}|memjustarg}{500} -\glossaryentry{replacement.functions@ {\memgloterm{replacement.functions}}{\memglodesc{(\ref {replacement.functions})}} {\memgloref{}}|memjustarg}{500} -\glossaryentry{handler.functions@ {\memgloterm{handler.functions}}{\memglodesc{(\ref {handler.functions})}} {\memgloref{}}|memjustarg}{501} -\glossaryentry{res.on.functions@ {\memgloterm{res.on.functions}}{\memglodesc{(\ref {res.on.functions})}} {\memgloref{}}|memjustarg}{501} -\glossaryentry{res.on.arguments@ {\memgloterm{res.on.arguments}}{\memglodesc{(\ref {res.on.arguments})}} {\memgloref{}}|memjustarg}{501} -\glossaryentry{res.on.objects@ {\memgloterm{res.on.objects}}{\memglodesc{(\ref {res.on.objects})}} {\memgloref{}}|memjustarg}{502} -\glossaryentry{res.on.requirements@ {\memgloterm{res.on.requirements}}{\memglodesc{(\ref {res.on.requirements})}} {\memgloref{}}|memjustarg}{502} -\glossaryentry{conforming@ {\memgloterm{conforming}}{\memglodesc{(\ref {conforming})}} {\memgloref{}}|memjustarg}{502} -\glossaryentry{conforming.overview@ {\memgloterm{conforming.overview}}{\memglodesc{(\ref {conforming.overview})}} {\memgloref{}}|memjustarg}{502} -\glossaryentry{res.on.headers@ {\memgloterm{res.on.headers}}{\memglodesc{(\ref {res.on.headers})}} {\memgloref{}}|memjustarg}{502} -\glossaryentry{res.on.macro.definitions@ {\memgloterm{res.on.macro.definitions}}{\memglodesc{(\ref {res.on.macro.definitions})}} {\memgloref{}}|memjustarg}{502} -\glossaryentry{global.functions@ {\memgloterm{global.functions}}{\memglodesc{(\ref {global.functions})}} {\memgloref{}}|memjustarg}{503} -\glossaryentry{member.functions@ {\memgloterm{member.functions}}{\memglodesc{(\ref {member.functions})}} {\memgloref{}}|memjustarg}{503} -\glossaryentry{hidden.friends@ {\memgloterm{hidden.friends}}{\memglodesc{(\ref {hidden.friends})}} {\memgloref{}}|memjustarg}{503} -\glossaryentry{constexpr.functions@ {\memgloterm{constexpr.functions}}{\memglodesc{(\ref {constexpr.functions})}} {\memgloref{}}|memjustarg}{503} -\glossaryentry{algorithm.stable@ {\memgloterm{algorithm.stable}}{\memglodesc{(\ref {algorithm.stable})}} {\memgloref{}}|memjustarg}{503} -\glossaryentry{reentrancy@ {\memgloterm{reentrancy}}{\memglodesc{(\ref {reentrancy})}} {\memgloref{}}|memjustarg}{503} -\glossaryentry{res.on.data.races@ {\memgloterm{res.on.data.races}}{\memglodesc{(\ref {res.on.data.races})}} {\memgloref{}}|memjustarg}{504} -\glossaryentry{protection.within.classes@ {\memgloterm{protection.within.classes}}{\memglodesc{(\ref {protection.within.classes})}} {\memgloref{}}|memjustarg}{504} -\glossaryentry{derivation@ {\memgloterm{derivation}}{\memglodesc{(\ref {derivation})}} {\memgloref{}}|memjustarg}{504} -\glossaryentry{res.on.exception.handling@ {\memgloterm{res.on.exception.handling}}{\memglodesc{(\ref {res.on.exception.handling})}} {\memgloref{}}|memjustarg}{504} -\glossaryentry{res.on.pointer.storage@ {\memgloterm{res.on.pointer.storage}}{\memglodesc{(\ref {res.on.pointer.storage})}} {\memgloref{}}|memjustarg}{505} -\glossaryentry{value.error.codes@ {\memgloterm{value.error.codes}}{\memglodesc{(\ref {value.error.codes})}} {\memgloref{}}|memjustarg}{505} -\glossaryentry{lib.types.movedfrom@ {\memgloterm{lib.types.movedfrom}}{\memglodesc{(\ref {lib.types.movedfrom})}} {\memgloref{}}|memjustarg}{505} -\glossaryentry{support@ {\memgloterm{support}}{\memglodesc{(\ref {support})}} {\memgloref{}}|memjustarg}{506} -\glossaryentry{support.general@ {\memgloterm{support.general}}{\memglodesc{(\ref {support.general})}} {\memgloref{}}|memjustarg}{506} -\glossaryentry{support.types@ {\memgloterm{support.types}}{\memglodesc{(\ref {support.types})}} {\memgloref{}}|memjustarg}{506} -\glossaryentry{cstddef.syn@ {\memgloterm{cstddef.syn}}{\memglodesc{(\ref {cstddef.syn})}} {\memgloref{}}|memjustarg}{506} -\glossaryentry{cstdlib.syn@ {\memgloterm{cstdlib.syn}}{\memglodesc{(\ref {cstdlib.syn})}} {\memgloref{}}|memjustarg}{507} -\glossaryentry{support.types.nullptr@ {\memgloterm{support.types.nullptr}}{\memglodesc{(\ref {support.types.nullptr})}} {\memgloref{}}|memjustarg}{508} -\glossaryentry{support.types.layout@ {\memgloterm{support.types.layout}}{\memglodesc{(\ref {support.types.layout})}} {\memgloref{}}|memjustarg}{508} -\glossaryentry{support.types.byteops@ {\memgloterm{support.types.byteops}}{\memglodesc{(\ref {support.types.byteops})}} {\memgloref{}}|memjustarg}{509} -\glossaryentry{support.limits@ {\memgloterm{support.limits}}{\memglodesc{(\ref {support.limits})}} {\memgloref{}}|memjustarg}{510} -\glossaryentry{support.limits.general@ {\memgloterm{support.limits.general}}{\memglodesc{(\ref {support.limits.general})}} {\memgloref{}}|memjustarg}{510} -\glossaryentry{version.syn@ {\memgloterm{version.syn}}{\memglodesc{(\ref {version.syn})}} {\memgloref{}}|memjustarg}{510} -\glossaryentry{limits.syn@ {\memgloterm{limits.syn}}{\memglodesc{(\ref {limits.syn})}} {\memgloref{}}|memjustarg}{512} -\glossaryentry{fp.style@ {\memgloterm{fp.style}}{\memglodesc{(\ref {fp.style})}} {\memgloref{}}|memjustarg}{513} -\glossaryentry{round.style@ {\memgloterm{round.style}}{\memglodesc{(\ref {round.style})}} {\memgloref{}}|memjustarg}{513} -\glossaryentry{denorm.style@ {\memgloterm{denorm.style}}{\memglodesc{(\ref {denorm.style})}} {\memgloref{}}|memjustarg}{513} -\glossaryentry{numeric.limits@ {\memgloterm{numeric.limits}}{\memglodesc{(\ref {numeric.limits})}} {\memgloref{}}|memjustarg}{513} -\glossaryentry{numeric.limits.general@ {\memgloterm{numeric.limits.general}}{\memglodesc{(\ref {numeric.limits.general})}} {\memgloref{}}|memjustarg}{513} -\glossaryentry{numeric.limits.members@ {\memgloterm{numeric.limits.members}}{\memglodesc{(\ref {numeric.limits.members})}} {\memgloref{}}|memjustarg}{514} -\glossaryentry{numeric.special@ {\memgloterm{numeric.special}}{\memglodesc{(\ref {numeric.special})}} {\memgloref{}}|memjustarg}{518} -\glossaryentry{climits.syn@ {\memgloterm{climits.syn}}{\memglodesc{(\ref {climits.syn})}} {\memgloref{}}|memjustarg}{519} -\glossaryentry{cfloat.syn@ {\memgloterm{cfloat.syn}}{\memglodesc{(\ref {cfloat.syn})}} {\memgloref{}}|memjustarg}{520} -\glossaryentry{cstdint@ {\memgloterm{cstdint}}{\memglodesc{(\ref {cstdint})}} {\memgloref{}}|memjustarg}{520} -\glossaryentry{cstdint.general@ {\memgloterm{cstdint.general}}{\memglodesc{(\ref {cstdint.general})}} {\memgloref{}}|memjustarg}{520} -\glossaryentry{cstdint.syn@ {\memgloterm{cstdint.syn}}{\memglodesc{(\ref {cstdint.syn})}} {\memgloref{}}|memjustarg}{520} -\glossaryentry{support.start.term@ {\memgloterm{support.start.term}}{\memglodesc{(\ref {support.start.term})}} {\memgloref{}}|memjustarg}{521} -\glossaryentry{support.dynamic@ {\memgloterm{support.dynamic}}{\memglodesc{(\ref {support.dynamic})}} {\memgloref{}}|memjustarg}{523} -\glossaryentry{support.dynamic.general@ {\memgloterm{support.dynamic.general}}{\memglodesc{(\ref {support.dynamic.general})}} {\memgloref{}}|memjustarg}{523} -\glossaryentry{new.syn@ {\memgloterm{new.syn}}{\memglodesc{(\ref {new.syn})}} {\memgloref{}}|memjustarg}{523} -\glossaryentry{new.delete@ {\memgloterm{new.delete}}{\memglodesc{(\ref {new.delete})}} {\memgloref{}}|memjustarg}{524} -\glossaryentry{new.delete.general@ {\memgloterm{new.delete.general}}{\memglodesc{(\ref {new.delete.general})}} {\memgloref{}}|memjustarg}{524} -\glossaryentry{new.delete.single@ {\memgloterm{new.delete.single}}{\memglodesc{(\ref {new.delete.single})}} {\memgloref{}}|memjustarg}{524} -\glossaryentry{new.delete.array@ {\memgloterm{new.delete.array}}{\memglodesc{(\ref {new.delete.array})}} {\memgloref{}}|memjustarg}{525} -\glossaryentry{new.delete.placement@ {\memgloterm{new.delete.placement}}{\memglodesc{(\ref {new.delete.placement})}} {\memgloref{}}|memjustarg}{527} -\glossaryentry{new.delete.dataraces@ {\memgloterm{new.delete.dataraces}}{\memglodesc{(\ref {new.delete.dataraces})}} {\memgloref{}}|memjustarg}{528} -\glossaryentry{alloc.errors@ {\memgloterm{alloc.errors}}{\memglodesc{(\ref {alloc.errors})}} {\memgloref{}}|memjustarg}{528} -\glossaryentry{bad.alloc@ {\memgloterm{bad.alloc}}{\memglodesc{(\ref {bad.alloc})}} {\memgloref{}}|memjustarg}{528} -\glossaryentry{new.badlength@ {\memgloterm{new.badlength}}{\memglodesc{(\ref {new.badlength})}} {\memgloref{}}|memjustarg}{528} -\glossaryentry{new.handler@ {\memgloterm{new.handler}}{\memglodesc{(\ref {new.handler})}} {\memgloref{}}|memjustarg}{528} -\glossaryentry{set.new.handler@ {\memgloterm{set.new.handler}}{\memglodesc{(\ref {set.new.handler})}} {\memgloref{}}|memjustarg}{528} -\glossaryentry{get.new.handler@ {\memgloterm{get.new.handler}}{\memglodesc{(\ref {get.new.handler})}} {\memgloref{}}|memjustarg}{529} -\glossaryentry{ptr.launder@ {\memgloterm{ptr.launder}}{\memglodesc{(\ref {ptr.launder})}} {\memgloref{}}|memjustarg}{529} -\glossaryentry{hardware.interference@ {\memgloterm{hardware.interference}}{\memglodesc{(\ref {hardware.interference})}} {\memgloref{}}|memjustarg}{529} -\glossaryentry{support.rtti@ {\memgloterm{support.rtti}}{\memglodesc{(\ref {support.rtti})}} {\memgloref{}}|memjustarg}{530} -\glossaryentry{support.rtti.general@ {\memgloterm{support.rtti.general}}{\memglodesc{(\ref {support.rtti.general})}} {\memgloref{}}|memjustarg}{530} -\glossaryentry{typeinfo.syn@ {\memgloterm{typeinfo.syn}}{\memglodesc{(\ref {typeinfo.syn})}} {\memgloref{}}|memjustarg}{530} -\glossaryentry{type.info@ {\memgloterm{type.info}}{\memglodesc{(\ref {type.info})}} {\memgloref{}}|memjustarg}{530} -\glossaryentry{bad.cast@ {\memgloterm{bad.cast}}{\memglodesc{(\ref {bad.cast})}} {\memgloref{}}|memjustarg}{531} -\glossaryentry{bad.typeid@ {\memgloterm{bad.typeid}}{\memglodesc{(\ref {bad.typeid})}} {\memgloref{}}|memjustarg}{531} -\glossaryentry{support.srcloc@ {\memgloterm{support.srcloc}}{\memglodesc{(\ref {support.srcloc})}} {\memgloref{}}|memjustarg}{531} -\glossaryentry{source.location.syn@ {\memgloterm{source.location.syn}}{\memglodesc{(\ref {source.location.syn})}} {\memgloref{}}|memjustarg}{531} -\glossaryentry{support.srcloc.class@ {\memgloterm{support.srcloc.class}}{\memglodesc{(\ref {support.srcloc.class})}} {\memgloref{}}|memjustarg}{531} -\glossaryentry{support.srcloc.class.general@ {\memgloterm{support.srcloc.class.general}}{\memglodesc{(\ref {support.srcloc.class.general})}} {\memgloref{}}|memjustarg}{531} -\glossaryentry{support.srcloc.cons@ {\memgloterm{support.srcloc.cons}}{\memglodesc{(\ref {support.srcloc.cons})}} {\memgloref{}}|memjustarg}{532} -\glossaryentry{support.srcloc.obs@ {\memgloterm{support.srcloc.obs}}{\memglodesc{(\ref {support.srcloc.obs})}} {\memgloref{}}|memjustarg}{533} -\glossaryentry{support.exception@ {\memgloterm{support.exception}}{\memglodesc{(\ref {support.exception})}} {\memgloref{}}|memjustarg}{533} -\glossaryentry{support.exception.general@ {\memgloterm{support.exception.general}}{\memglodesc{(\ref {support.exception.general})}} {\memgloref{}}|memjustarg}{533} -\glossaryentry{exception.syn@ {\memgloterm{exception.syn}}{\memglodesc{(\ref {exception.syn})}} {\memgloref{}}|memjustarg}{533} -\glossaryentry{exception@ {\memgloterm{exception}}{\memglodesc{(\ref {exception})}} {\memgloref{}}|memjustarg}{534} -\glossaryentry{bad.exception@ {\memgloterm{bad.exception}}{\memglodesc{(\ref {bad.exception})}} {\memgloref{}}|memjustarg}{534} -\glossaryentry{exception.terminate@ {\memgloterm{exception.terminate}}{\memglodesc{(\ref {exception.terminate})}} {\memgloref{}}|memjustarg}{535} -\glossaryentry{terminate.handler@ {\memgloterm{terminate.handler}}{\memglodesc{(\ref {terminate.handler})}} {\memgloref{}}|memjustarg}{535} -\glossaryentry{set.terminate@ {\memgloterm{set.terminate}}{\memglodesc{(\ref {set.terminate})}} {\memgloref{}}|memjustarg}{535} -\glossaryentry{get.terminate@ {\memgloterm{get.terminate}}{\memglodesc{(\ref {get.terminate})}} {\memgloref{}}|memjustarg}{535} -\glossaryentry{terminate@ {\memgloterm{terminate}}{\memglodesc{(\ref {terminate})}} {\memgloref{}}|memjustarg}{535} -\glossaryentry{uncaught.exceptions@ {\memgloterm{uncaught.exceptions}}{\memglodesc{(\ref {uncaught.exceptions})}} {\memgloref{}}|memjustarg}{535} -\glossaryentry{propagation@ {\memgloterm{propagation}}{\memglodesc{(\ref {propagation})}} {\memgloref{}}|memjustarg}{535} -\glossaryentry{except.nested@ {\memgloterm{except.nested}}{\memglodesc{(\ref {except.nested})}} {\memgloref{}}|memjustarg}{536} -\glossaryentry{support.initlist@ {\memgloterm{support.initlist}}{\memglodesc{(\ref {support.initlist})}} {\memgloref{}}|memjustarg}{537} -\glossaryentry{support.initlist.general@ {\memgloterm{support.initlist.general}}{\memglodesc{(\ref {support.initlist.general})}} {\memgloref{}}|memjustarg}{537} -\glossaryentry{initializer.list.syn@ {\memgloterm{initializer.list.syn}}{\memglodesc{(\ref {initializer.list.syn})}} {\memgloref{}}|memjustarg}{537} -\glossaryentry{support.initlist.cons@ {\memgloterm{support.initlist.cons}}{\memglodesc{(\ref {support.initlist.cons})}} {\memgloref{}}|memjustarg}{538} -\glossaryentry{support.initlist.access@ {\memgloterm{support.initlist.access}}{\memglodesc{(\ref {support.initlist.access})}} {\memgloref{}}|memjustarg}{538} -\glossaryentry{support.initlist.range@ {\memgloterm{support.initlist.range}}{\memglodesc{(\ref {support.initlist.range})}} {\memgloref{}}|memjustarg}{538} -\glossaryentry{cmp@ {\memgloterm{cmp}}{\memglodesc{(\ref {cmp})}} {\memgloref{}}|memjustarg}{538} -\glossaryentry{compare.syn@ {\memgloterm{compare.syn}}{\memglodesc{(\ref {compare.syn})}} {\memgloref{}}|memjustarg}{538} -\glossaryentry{cmp.categories@ {\memgloterm{cmp.categories}}{\memglodesc{(\ref {cmp.categories})}} {\memgloref{}}|memjustarg}{539} -\glossaryentry{cmp.categories.pre@ {\memgloterm{cmp.categories.pre}}{\memglodesc{(\ref {cmp.categories.pre})}} {\memgloref{}}|memjustarg}{539} -\glossaryentry{cmp.partialord@ {\memgloterm{cmp.partialord}}{\memglodesc{(\ref {cmp.partialord})}} {\memgloref{}}|memjustarg}{539} -\glossaryentry{cmp.weakord@ {\memgloterm{cmp.weakord}}{\memglodesc{(\ref {cmp.weakord})}} {\memgloref{}}|memjustarg}{540} -\glossaryentry{cmp.strongord@ {\memgloterm{cmp.strongord}}{\memglodesc{(\ref {cmp.strongord})}} {\memgloref{}}|memjustarg}{541} -\glossaryentry{cmp.common@ {\memgloterm{cmp.common}}{\memglodesc{(\ref {cmp.common})}} {\memgloref{}}|memjustarg}{542} -\glossaryentry{cmp.concept@ {\memgloterm{cmp.concept}}{\memglodesc{(\ref {cmp.concept})}} {\memgloref{}}|memjustarg}{543} -\glossaryentry{cmp.result@ {\memgloterm{cmp.result}}{\memglodesc{(\ref {cmp.result})}} {\memgloref{}}|memjustarg}{544} -\glossaryentry{cmp.alg@ {\memgloterm{cmp.alg}}{\memglodesc{(\ref {cmp.alg})}} {\memgloref{}}|memjustarg}{544} -\glossaryentry{support.coroutine@ {\memgloterm{support.coroutine}}{\memglodesc{(\ref {support.coroutine})}} {\memgloref{}}|memjustarg}{546} -\glossaryentry{support.coroutine.general@ {\memgloterm{support.coroutine.general}}{\memglodesc{(\ref {support.coroutine.general})}} {\memgloref{}}|memjustarg}{546} -\glossaryentry{coroutine.syn@ {\memgloterm{coroutine.syn}}{\memglodesc{(\ref {coroutine.syn})}} {\memgloref{}}|memjustarg}{546} -\glossaryentry{coroutine.traits@ {\memgloterm{coroutine.traits}}{\memglodesc{(\ref {coroutine.traits})}} {\memgloref{}}|memjustarg}{547} -\glossaryentry{coroutine.traits.general@ {\memgloterm{coroutine.traits.general}}{\memglodesc{(\ref {coroutine.traits.general})}} {\memgloref{}}|memjustarg}{547} -\glossaryentry{coroutine.traits.primary@ {\memgloterm{coroutine.traits.primary}}{\memglodesc{(\ref {coroutine.traits.primary})}} {\memgloref{}}|memjustarg}{547} -\glossaryentry{coroutine.handle@ {\memgloterm{coroutine.handle}}{\memglodesc{(\ref {coroutine.handle})}} {\memgloref{}}|memjustarg}{547} -\glossaryentry{coroutine.handle.general@ {\memgloterm{coroutine.handle.general}}{\memglodesc{(\ref {coroutine.handle.general})}} {\memgloref{}}|memjustarg}{547} -\glossaryentry{coroutine.handle.con@ {\memgloterm{coroutine.handle.con}}{\memglodesc{(\ref {coroutine.handle.con})}} {\memgloref{}}|memjustarg}{548} -\glossaryentry{coroutine.handle.export.import@ {\memgloterm{coroutine.handle.export.import}}{\memglodesc{(\ref {coroutine.handle.export.import})}} {\memgloref{}}|memjustarg}{548} -\glossaryentry{coroutine.handle.observers@ {\memgloterm{coroutine.handle.observers}}{\memglodesc{(\ref {coroutine.handle.observers})}} {\memgloref{}}|memjustarg}{548} -\glossaryentry{coroutine.handle.resumption@ {\memgloterm{coroutine.handle.resumption}}{\memglodesc{(\ref {coroutine.handle.resumption})}} {\memgloref{}}|memjustarg}{548} -\glossaryentry{coroutine.handle.promise@ {\memgloterm{coroutine.handle.promise}}{\memglodesc{(\ref {coroutine.handle.promise})}} {\memgloref{}}|memjustarg}{548} -\glossaryentry{coroutine.handle.compare@ {\memgloterm{coroutine.handle.compare}}{\memglodesc{(\ref {coroutine.handle.compare})}} {\memgloref{}}|memjustarg}{549} -\glossaryentry{coroutine.handle.hash@ {\memgloterm{coroutine.handle.hash}}{\memglodesc{(\ref {coroutine.handle.hash})}} {\memgloref{}}|memjustarg}{549} -\glossaryentry{coroutine.noop@ {\memgloterm{coroutine.noop}}{\memglodesc{(\ref {coroutine.noop})}} {\memgloref{}}|memjustarg}{549} -\glossaryentry{coroutine.promise.noop@ {\memgloterm{coroutine.promise.noop}}{\memglodesc{(\ref {coroutine.promise.noop})}} {\memgloref{}}|memjustarg}{549} -\glossaryentry{coroutine.handle.noop@ {\memgloterm{coroutine.handle.noop}}{\memglodesc{(\ref {coroutine.handle.noop})}} {\memgloref{}}|memjustarg}{549} -\glossaryentry{coroutine.handle.noop.observers@ {\memgloterm{coroutine.handle.noop.observers}}{\memglodesc{(\ref {coroutine.handle.noop.observers})}} {\memgloref{}}|memjustarg}{549} -\glossaryentry{coroutine.handle.noop.resumption@ {\memgloterm{coroutine.handle.noop.resumption}}{\memglodesc{(\ref {coroutine.handle.noop.resumption})}} {\memgloref{}}|memjustarg}{549} -\glossaryentry{coroutine.handle.noop.promise@ {\memgloterm{coroutine.handle.noop.promise}}{\memglodesc{(\ref {coroutine.handle.noop.promise})}} {\memgloref{}}|memjustarg}{550} -\glossaryentry{coroutine.handle.noop.address@ {\memgloterm{coroutine.handle.noop.address}}{\memglodesc{(\ref {coroutine.handle.noop.address})}} {\memgloref{}}|memjustarg}{550} -\glossaryentry{coroutine.noop.coroutine@ {\memgloterm{coroutine.noop.coroutine}}{\memglodesc{(\ref {coroutine.noop.coroutine})}} {\memgloref{}}|memjustarg}{550} -\glossaryentry{coroutine.trivial.awaitables@ {\memgloterm{coroutine.trivial.awaitables}}{\memglodesc{(\ref {coroutine.trivial.awaitables})}} {\memgloref{}}|memjustarg}{550} -\glossaryentry{support.runtime@ {\memgloterm{support.runtime}}{\memglodesc{(\ref {support.runtime})}} {\memgloref{}}|memjustarg}{550} -\glossaryentry{support.runtime.general@ {\memgloterm{support.runtime.general}}{\memglodesc{(\ref {support.runtime.general})}} {\memgloref{}}|memjustarg}{550} -\glossaryentry{cstdarg.syn@ {\memgloterm{cstdarg.syn}}{\memglodesc{(\ref {cstdarg.syn})}} {\memgloref{}}|memjustarg}{550} -\glossaryentry{csetjmp.syn@ {\memgloterm{csetjmp.syn}}{\memglodesc{(\ref {csetjmp.syn})}} {\memgloref{}}|memjustarg}{551} -\glossaryentry{csignal.syn@ {\memgloterm{csignal.syn}}{\memglodesc{(\ref {csignal.syn})}} {\memgloref{}}|memjustarg}{551} -\glossaryentry{support.signal@ {\memgloterm{support.signal}}{\memglodesc{(\ref {support.signal})}} {\memgloref{}}|memjustarg}{551} -\glossaryentry{concepts@ {\memgloterm{concepts}}{\memglodesc{(\ref {concepts})}} {\memgloref{}}|memjustarg}{553} -\glossaryentry{concepts.general@ {\memgloterm{concepts.general}}{\memglodesc{(\ref {concepts.general})}} {\memgloref{}}|memjustarg}{553} -\glossaryentry{concepts.equality@ {\memgloterm{concepts.equality}}{\memglodesc{(\ref {concepts.equality})}} {\memgloref{}}|memjustarg}{553} -\glossaryentry{concepts.syn@ {\memgloterm{concepts.syn}}{\memglodesc{(\ref {concepts.syn})}} {\memgloref{}}|memjustarg}{554} -\glossaryentry{concepts.lang@ {\memgloterm{concepts.lang}}{\memglodesc{(\ref {concepts.lang})}} {\memgloref{}}|memjustarg}{556} -\glossaryentry{concepts.lang.general@ {\memgloterm{concepts.lang.general}}{\memglodesc{(\ref {concepts.lang.general})}} {\memgloref{}}|memjustarg}{556} -\glossaryentry{concept.same@ {\memgloterm{concept.same}}{\memglodesc{(\ref {concept.same})}} {\memgloref{}}|memjustarg}{556} -\glossaryentry{concept.derived@ {\memgloterm{concept.derived}}{\memglodesc{(\ref {concept.derived})}} {\memgloref{}}|memjustarg}{556} -\glossaryentry{concept.convertible@ {\memgloterm{concept.convertible}}{\memglodesc{(\ref {concept.convertible})}} {\memgloref{}}|memjustarg}{557} -\glossaryentry{concept.commonref@ {\memgloterm{concept.commonref}}{\memglodesc{(\ref {concept.commonref})}} {\memgloref{}}|memjustarg}{557} -\glossaryentry{concept.common@ {\memgloterm{concept.common}}{\memglodesc{(\ref {concept.common})}} {\memgloref{}}|memjustarg}{557} -\glossaryentry{concepts.arithmetic@ {\memgloterm{concepts.arithmetic}}{\memglodesc{(\ref {concepts.arithmetic})}} {\memgloref{}}|memjustarg}{558} -\glossaryentry{concept.assignable@ {\memgloterm{concept.assignable}}{\memglodesc{(\ref {concept.assignable})}} {\memgloref{}}|memjustarg}{558} -\glossaryentry{concept.swappable@ {\memgloterm{concept.swappable}}{\memglodesc{(\ref {concept.swappable})}} {\memgloref{}}|memjustarg}{559} -\glossaryentry{concept.destructible@ {\memgloterm{concept.destructible}}{\memglodesc{(\ref {concept.destructible})}} {\memgloref{}}|memjustarg}{560} -\glossaryentry{concept.constructible@ {\memgloterm{concept.constructible}}{\memglodesc{(\ref {concept.constructible})}} {\memgloref{}}|memjustarg}{560} -\glossaryentry{concept.default.init@ {\memgloterm{concept.default.init}}{\memglodesc{(\ref {concept.default.init})}} {\memgloref{}}|memjustarg}{560} -\glossaryentry{concept.moveconstructible@ {\memgloterm{concept.moveconstructible}}{\memglodesc{(\ref {concept.moveconstructible})}} {\memgloref{}}|memjustarg}{561} -\glossaryentry{concept.copyconstructible@ {\memgloterm{concept.copyconstructible}}{\memglodesc{(\ref {concept.copyconstructible})}} {\memgloref{}}|memjustarg}{561} -\glossaryentry{concepts.compare@ {\memgloterm{concepts.compare}}{\memglodesc{(\ref {concepts.compare})}} {\memgloref{}}|memjustarg}{561} -\glossaryentry{concepts.compare.general@ {\memgloterm{concepts.compare.general}}{\memglodesc{(\ref {concepts.compare.general})}} {\memgloref{}}|memjustarg}{561} -\glossaryentry{concept.booleantestable@ {\memgloterm{concept.booleantestable}}{\memglodesc{(\ref {concept.booleantestable})}} {\memgloref{}}|memjustarg}{561} -\glossaryentry{concept.equalitycomparable@ {\memgloterm{concept.equalitycomparable}}{\memglodesc{(\ref {concept.equalitycomparable})}} {\memgloref{}}|memjustarg}{562} -\glossaryentry{concept.totallyordered@ {\memgloterm{concept.totallyordered}}{\memglodesc{(\ref {concept.totallyordered})}} {\memgloref{}}|memjustarg}{563} -\glossaryentry{concepts.object@ {\memgloterm{concepts.object}}{\memglodesc{(\ref {concepts.object})}} {\memgloref{}}|memjustarg}{564} -\glossaryentry{concepts.callable@ {\memgloterm{concepts.callable}}{\memglodesc{(\ref {concepts.callable})}} {\memgloref{}}|memjustarg}{564} -\glossaryentry{concepts.callable.general@ {\memgloterm{concepts.callable.general}}{\memglodesc{(\ref {concepts.callable.general})}} {\memgloref{}}|memjustarg}{564} -\glossaryentry{concept.invocable@ {\memgloterm{concept.invocable}}{\memglodesc{(\ref {concept.invocable})}} {\memgloref{}}|memjustarg}{564} -\glossaryentry{concept.regularinvocable@ {\memgloterm{concept.regularinvocable}}{\memglodesc{(\ref {concept.regularinvocable})}} {\memgloref{}}|memjustarg}{564} -\glossaryentry{concept.predicate@ {\memgloterm{concept.predicate}}{\memglodesc{(\ref {concept.predicate})}} {\memgloref{}}|memjustarg}{564} -\glossaryentry{concept.relation@ {\memgloterm{concept.relation}}{\memglodesc{(\ref {concept.relation})}} {\memgloref{}}|memjustarg}{564} -\glossaryentry{concept.equiv@ {\memgloterm{concept.equiv}}{\memglodesc{(\ref {concept.equiv})}} {\memgloref{}}|memjustarg}{565} -\glossaryentry{concept.strictweakorder@ {\memgloterm{concept.strictweakorder}}{\memglodesc{(\ref {concept.strictweakorder})}} {\memgloref{}}|memjustarg}{565} -\glossaryentry{diagnostics@ {\memgloterm{diagnostics}}{\memglodesc{(\ref {diagnostics})}} {\memgloref{}}|memjustarg}{566} -\glossaryentry{diagnostics.general@ {\memgloterm{diagnostics.general}}{\memglodesc{(\ref {diagnostics.general})}} {\memgloref{}}|memjustarg}{566} -\glossaryentry{std.exceptions@ {\memgloterm{std.exceptions}}{\memglodesc{(\ref {std.exceptions})}} {\memgloref{}}|memjustarg}{566} -\glossaryentry{std.exceptions.general@ {\memgloterm{std.exceptions.general}}{\memglodesc{(\ref {std.exceptions.general})}} {\memgloref{}}|memjustarg}{566} -\glossaryentry{stdexcept.syn@ {\memgloterm{stdexcept.syn}}{\memglodesc{(\ref {stdexcept.syn})}} {\memgloref{}}|memjustarg}{566} -\glossaryentry{logic.error@ {\memgloterm{logic.error}}{\memglodesc{(\ref {logic.error})}} {\memgloref{}}|memjustarg}{566} -\glossaryentry{domain.error@ {\memgloterm{domain.error}}{\memglodesc{(\ref {domain.error})}} {\memgloref{}}|memjustarg}{567} -\glossaryentry{invalid.argument@ {\memgloterm{invalid.argument}}{\memglodesc{(\ref {invalid.argument})}} {\memgloref{}}|memjustarg}{567} -\glossaryentry{length.error@ {\memgloterm{length.error}}{\memglodesc{(\ref {length.error})}} {\memgloref{}}|memjustarg}{567} -\glossaryentry{out.of.range@ {\memgloterm{out.of.range}}{\memglodesc{(\ref {out.of.range})}} {\memgloref{}}|memjustarg}{567} -\glossaryentry{runtime.error@ {\memgloterm{runtime.error}}{\memglodesc{(\ref {runtime.error})}} {\memgloref{}}|memjustarg}{568} -\glossaryentry{range.error@ {\memgloterm{range.error}}{\memglodesc{(\ref {range.error})}} {\memgloref{}}|memjustarg}{568} -\glossaryentry{overflow.error@ {\memgloterm{overflow.error}}{\memglodesc{(\ref {overflow.error})}} {\memgloref{}}|memjustarg}{568} -\glossaryentry{underflow.error@ {\memgloterm{underflow.error}}{\memglodesc{(\ref {underflow.error})}} {\memgloref{}}|memjustarg}{569} -\glossaryentry{assertions@ {\memgloterm{assertions}}{\memglodesc{(\ref {assertions})}} {\memgloref{}}|memjustarg}{569} -\glossaryentry{assertions.general@ {\memgloterm{assertions.general}}{\memglodesc{(\ref {assertions.general})}} {\memgloref{}}|memjustarg}{569} -\glossaryentry{cassert.syn@ {\memgloterm{cassert.syn}}{\memglodesc{(\ref {cassert.syn})}} {\memgloref{}}|memjustarg}{569} -\glossaryentry{assertions.assert@ {\memgloterm{assertions.assert}}{\memglodesc{(\ref {assertions.assert})}} {\memgloref{}}|memjustarg}{569} -\glossaryentry{errno@ {\memgloterm{errno}}{\memglodesc{(\ref {errno})}} {\memgloref{}}|memjustarg}{569} -\glossaryentry{errno.general@ {\memgloterm{errno.general}}{\memglodesc{(\ref {errno.general})}} {\memgloref{}}|memjustarg}{569} -\glossaryentry{cerrno.syn@ {\memgloterm{cerrno.syn}}{\memglodesc{(\ref {cerrno.syn})}} {\memgloref{}}|memjustarg}{569} -\glossaryentry{syserr@ {\memgloterm{syserr}}{\memglodesc{(\ref {syserr})}} {\memgloref{}}|memjustarg}{571} -\glossaryentry{syserr.general@ {\memgloterm{syserr.general}}{\memglodesc{(\ref {syserr.general})}} {\memgloref{}}|memjustarg}{571} -\glossaryentry{system.error.syn@ {\memgloterm{system.error.syn}}{\memglodesc{(\ref {system.error.syn})}} {\memgloref{}}|memjustarg}{571} -\glossaryentry{syserr.errcat@ {\memgloterm{syserr.errcat}}{\memglodesc{(\ref {syserr.errcat})}} {\memgloref{}}|memjustarg}{573} -\glossaryentry{syserr.errcat.overview@ {\memgloterm{syserr.errcat.overview}}{\memglodesc{(\ref {syserr.errcat.overview})}} {\memgloref{}}|memjustarg}{573} -\glossaryentry{syserr.errcat.virtuals@ {\memgloterm{syserr.errcat.virtuals}}{\memglodesc{(\ref {syserr.errcat.virtuals})}} {\memgloref{}}|memjustarg}{573} -\glossaryentry{syserr.errcat.nonvirtuals@ {\memgloterm{syserr.errcat.nonvirtuals}}{\memglodesc{(\ref {syserr.errcat.nonvirtuals})}} {\memgloref{}}|memjustarg}{574} -\glossaryentry{syserr.errcat.derived@ {\memgloterm{syserr.errcat.derived}}{\memglodesc{(\ref {syserr.errcat.derived})}} {\memgloref{}}|memjustarg}{574} -\glossaryentry{syserr.errcat.objects@ {\memgloterm{syserr.errcat.objects}}{\memglodesc{(\ref {syserr.errcat.objects})}} {\memgloref{}}|memjustarg}{574} -\glossaryentry{syserr.errcode@ {\memgloterm{syserr.errcode}}{\memglodesc{(\ref {syserr.errcode})}} {\memgloref{}}|memjustarg}{575} -\glossaryentry{syserr.errcode.overview@ {\memgloterm{syserr.errcode.overview}}{\memglodesc{(\ref {syserr.errcode.overview})}} {\memgloref{}}|memjustarg}{575} -\glossaryentry{syserr.errcode.constructors@ {\memgloterm{syserr.errcode.constructors}}{\memglodesc{(\ref {syserr.errcode.constructors})}} {\memgloref{}}|memjustarg}{575} -\glossaryentry{syserr.errcode.modifiers@ {\memgloterm{syserr.errcode.modifiers}}{\memglodesc{(\ref {syserr.errcode.modifiers})}} {\memgloref{}}|memjustarg}{575} -\glossaryentry{syserr.errcode.observers@ {\memgloterm{syserr.errcode.observers}}{\memglodesc{(\ref {syserr.errcode.observers})}} {\memgloref{}}|memjustarg}{576} -\glossaryentry{syserr.errcode.nonmembers@ {\memgloterm{syserr.errcode.nonmembers}}{\memglodesc{(\ref {syserr.errcode.nonmembers})}} {\memgloref{}}|memjustarg}{576} -\glossaryentry{syserr.errcondition@ {\memgloterm{syserr.errcondition}}{\memglodesc{(\ref {syserr.errcondition})}} {\memgloref{}}|memjustarg}{576} -\glossaryentry{syserr.errcondition.overview@ {\memgloterm{syserr.errcondition.overview}}{\memglodesc{(\ref {syserr.errcondition.overview})}} {\memgloref{}}|memjustarg}{576} -\glossaryentry{syserr.errcondition.constructors@ {\memgloterm{syserr.errcondition.constructors}}{\memglodesc{(\ref {syserr.errcondition.constructors})}} {\memgloref{}}|memjustarg}{577} -\glossaryentry{syserr.errcondition.modifiers@ {\memgloterm{syserr.errcondition.modifiers}}{\memglodesc{(\ref {syserr.errcondition.modifiers})}} {\memgloref{}}|memjustarg}{577} -\glossaryentry{syserr.errcondition.observers@ {\memgloterm{syserr.errcondition.observers}}{\memglodesc{(\ref {syserr.errcondition.observers})}} {\memgloref{}}|memjustarg}{577} -\glossaryentry{syserr.errcondition.nonmembers@ {\memgloterm{syserr.errcondition.nonmembers}}{\memglodesc{(\ref {syserr.errcondition.nonmembers})}} {\memgloref{}}|memjustarg}{577} -\glossaryentry{syserr.compare@ {\memgloterm{syserr.compare}}{\memglodesc{(\ref {syserr.compare})}} {\memgloref{}}|memjustarg}{577} -\glossaryentry{syserr.hash@ {\memgloterm{syserr.hash}}{\memglodesc{(\ref {syserr.hash})}} {\memgloref{}}|memjustarg}{578} -\glossaryentry{syserr.syserr@ {\memgloterm{syserr.syserr}}{\memglodesc{(\ref {syserr.syserr})}} {\memgloref{}}|memjustarg}{578} -\glossaryentry{syserr.syserr.overview@ {\memgloterm{syserr.syserr.overview}}{\memglodesc{(\ref {syserr.syserr.overview})}} {\memgloref{}}|memjustarg}{578} -\glossaryentry{syserr.syserr.members@ {\memgloterm{syserr.syserr.members}}{\memglodesc{(\ref {syserr.syserr.members})}} {\memgloref{}}|memjustarg}{578} -\glossaryentry{utilities@ {\memgloterm{utilities}}{\memglodesc{(\ref {utilities})}} {\memgloref{}}|memjustarg}{580} -\glossaryentry{utilities.general@ {\memgloterm{utilities.general}}{\memglodesc{(\ref {utilities.general})}} {\memgloref{}}|memjustarg}{580} -\glossaryentry{utility@ {\memgloterm{utility}}{\memglodesc{(\ref {utility})}} {\memgloref{}}|memjustarg}{580} -\glossaryentry{utility.syn@ {\memgloterm{utility.syn}}{\memglodesc{(\ref {utility.syn})}} {\memgloref{}}|memjustarg}{580} -\glossaryentry{utility.swap@ {\memgloterm{utility.swap}}{\memglodesc{(\ref {utility.swap})}} {\memgloref{}}|memjustarg}{582} -\glossaryentry{utility.exchange@ {\memgloterm{utility.exchange}}{\memglodesc{(\ref {utility.exchange})}} {\memgloref{}}|memjustarg}{583} -\glossaryentry{forward@ {\memgloterm{forward}}{\memglodesc{(\ref {forward})}} {\memgloref{}}|memjustarg}{583} -\glossaryentry{utility.as.const@ {\memgloterm{utility.as.const}}{\memglodesc{(\ref {utility.as.const})}} {\memgloref{}}|memjustarg}{584} -\glossaryentry{declval@ {\memgloterm{declval}}{\memglodesc{(\ref {declval})}} {\memgloref{}}|memjustarg}{584} -\glossaryentry{utility.intcmp@ {\memgloterm{utility.intcmp}}{\memglodesc{(\ref {utility.intcmp})}} {\memgloref{}}|memjustarg}{584} -\glossaryentry{intseq@ {\memgloterm{intseq}}{\memglodesc{(\ref {intseq})}} {\memgloref{}}|memjustarg}{585} -\glossaryentry{intseq.general@ {\memgloterm{intseq.general}}{\memglodesc{(\ref {intseq.general})}} {\memgloref{}}|memjustarg}{585} -\glossaryentry{intseq.intseq@ {\memgloterm{intseq.intseq}}{\memglodesc{(\ref {intseq.intseq})}} {\memgloref{}}|memjustarg}{585} -\glossaryentry{intseq.make@ {\memgloterm{intseq.make}}{\memglodesc{(\ref {intseq.make})}} {\memgloref{}}|memjustarg}{585} -\glossaryentry{pairs@ {\memgloterm{pairs}}{\memglodesc{(\ref {pairs})}} {\memgloref{}}|memjustarg}{586} -\glossaryentry{pairs.general@ {\memgloterm{pairs.general}}{\memglodesc{(\ref {pairs.general})}} {\memgloref{}}|memjustarg}{586} -\glossaryentry{pairs.pair@ {\memgloterm{pairs.pair}}{\memglodesc{(\ref {pairs.pair})}} {\memgloref{}}|memjustarg}{586} -\glossaryentry{pairs.spec@ {\memgloterm{pairs.spec}}{\memglodesc{(\ref {pairs.spec})}} {\memgloref{}}|memjustarg}{588} -\glossaryentry{pair.astuple@ {\memgloterm{pair.astuple}}{\memglodesc{(\ref {pair.astuple})}} {\memgloref{}}|memjustarg}{589} -\glossaryentry{pair.piecewise@ {\memgloterm{pair.piecewise}}{\memglodesc{(\ref {pair.piecewise})}} {\memgloref{}}|memjustarg}{590} -\glossaryentry{tuple@ {\memgloterm{tuple}}{\memglodesc{(\ref {tuple})}} {\memgloref{}}|memjustarg}{590} -\glossaryentry{tuple.general@ {\memgloterm{tuple.general}}{\memglodesc{(\ref {tuple.general})}} {\memgloref{}}|memjustarg}{590} -\glossaryentry{tuple.syn@ {\memgloterm{tuple.syn}}{\memglodesc{(\ref {tuple.syn})}} {\memgloref{}}|memjustarg}{590} -\glossaryentry{tuple.tuple@ {\memgloterm{tuple.tuple}}{\memglodesc{(\ref {tuple.tuple})}} {\memgloref{}}|memjustarg}{591} -\glossaryentry{tuple.cnstr@ {\memgloterm{tuple.cnstr}}{\memglodesc{(\ref {tuple.cnstr})}} {\memgloref{}}|memjustarg}{593} -\glossaryentry{tuple.assign@ {\memgloterm{tuple.assign}}{\memglodesc{(\ref {tuple.assign})}} {\memgloref{}}|memjustarg}{595} -\glossaryentry{tuple.swap@ {\memgloterm{tuple.swap}}{\memglodesc{(\ref {tuple.swap})}} {\memgloref{}}|memjustarg}{596} -\glossaryentry{tuple.creation@ {\memgloterm{tuple.creation}}{\memglodesc{(\ref {tuple.creation})}} {\memgloref{}}|memjustarg}{596} -\glossaryentry{tuple.apply@ {\memgloterm{tuple.apply}}{\memglodesc{(\ref {tuple.apply})}} {\memgloref{}}|memjustarg}{597} -\glossaryentry{tuple.helper@ {\memgloterm{tuple.helper}}{\memglodesc{(\ref {tuple.helper})}} {\memgloref{}}|memjustarg}{597} -\glossaryentry{tuple.elem@ {\memgloterm{tuple.elem}}{\memglodesc{(\ref {tuple.elem})}} {\memgloref{}}|memjustarg}{598} -\glossaryentry{tuple.rel@ {\memgloterm{tuple.rel}}{\memglodesc{(\ref {tuple.rel})}} {\memgloref{}}|memjustarg}{599} -\glossaryentry{tuple.traits@ {\memgloterm{tuple.traits}}{\memglodesc{(\ref {tuple.traits})}} {\memgloref{}}|memjustarg}{599} -\glossaryentry{tuple.special@ {\memgloterm{tuple.special}}{\memglodesc{(\ref {tuple.special})}} {\memgloref{}}|memjustarg}{599} -\glossaryentry{optional@ {\memgloterm{optional}}{\memglodesc{(\ref {optional})}} {\memgloref{}}|memjustarg}{600} -\glossaryentry{optional.general@ {\memgloterm{optional.general}}{\memglodesc{(\ref {optional.general})}} {\memgloref{}}|memjustarg}{600} -\glossaryentry{optional.syn@ {\memgloterm{optional.syn}}{\memglodesc{(\ref {optional.syn})}} {\memgloref{}}|memjustarg}{600} -\glossaryentry{optional.optional@ {\memgloterm{optional.optional}}{\memglodesc{(\ref {optional.optional})}} {\memgloref{}}|memjustarg}{601} -\glossaryentry{optional.optional.general@ {\memgloterm{optional.optional.general}}{\memglodesc{(\ref {optional.optional.general})}} {\memgloref{}}|memjustarg}{601} -\glossaryentry{optional.ctor@ {\memgloterm{optional.ctor}}{\memglodesc{(\ref {optional.ctor})}} {\memgloref{}}|memjustarg}{602} -\glossaryentry{optional.dtor@ {\memgloterm{optional.dtor}}{\memglodesc{(\ref {optional.dtor})}} {\memgloref{}}|memjustarg}{604} -\glossaryentry{optional.assign@ {\memgloterm{optional.assign}}{\memglodesc{(\ref {optional.assign})}} {\memgloref{}}|memjustarg}{604} -\glossaryentry{optional.swap@ {\memgloterm{optional.swap}}{\memglodesc{(\ref {optional.swap})}} {\memgloref{}}|memjustarg}{607} -\glossaryentry{optional.observe@ {\memgloterm{optional.observe}}{\memglodesc{(\ref {optional.observe})}} {\memgloref{}}|memjustarg}{608} -\glossaryentry{optional.mod@ {\memgloterm{optional.mod}}{\memglodesc{(\ref {optional.mod})}} {\memgloref{}}|memjustarg}{609} -\glossaryentry{optional.nullopt@ {\memgloterm{optional.nullopt}}{\memglodesc{(\ref {optional.nullopt})}} {\memgloref{}}|memjustarg}{609} -\glossaryentry{optional.bad.access@ {\memgloterm{optional.bad.access}}{\memglodesc{(\ref {optional.bad.access})}} {\memgloref{}}|memjustarg}{609} -\glossaryentry{optional.relops@ {\memgloterm{optional.relops}}{\memglodesc{(\ref {optional.relops})}} {\memgloref{}}|memjustarg}{609} -\glossaryentry{optional.nullops@ {\memgloterm{optional.nullops}}{\memglodesc{(\ref {optional.nullops})}} {\memgloref{}}|memjustarg}{610} -\glossaryentry{optional.comp.with.t@ {\memgloterm{optional.comp.with.t}}{\memglodesc{(\ref {optional.comp.with.t})}} {\memgloref{}}|memjustarg}{610} -\glossaryentry{optional.specalg@ {\memgloterm{optional.specalg}}{\memglodesc{(\ref {optional.specalg})}} {\memgloref{}}|memjustarg}{611} -\glossaryentry{optional.hash@ {\memgloterm{optional.hash}}{\memglodesc{(\ref {optional.hash})}} {\memgloref{}}|memjustarg}{612} -\glossaryentry{variant@ {\memgloterm{variant}}{\memglodesc{(\ref {variant})}} {\memgloref{}}|memjustarg}{612} -\glossaryentry{variant.general@ {\memgloterm{variant.general}}{\memglodesc{(\ref {variant.general})}} {\memgloref{}}|memjustarg}{612} -\glossaryentry{variant.syn@ {\memgloterm{variant.syn}}{\memglodesc{(\ref {variant.syn})}} {\memgloref{}}|memjustarg}{612} -\glossaryentry{variant.variant@ {\memgloterm{variant.variant}}{\memglodesc{(\ref {variant.variant})}} {\memgloref{}}|memjustarg}{614} -\glossaryentry{variant.variant.general@ {\memgloterm{variant.variant.general}}{\memglodesc{(\ref {variant.variant.general})}} {\memgloref{}}|memjustarg}{614} -\glossaryentry{variant.ctor@ {\memgloterm{variant.ctor}}{\memglodesc{(\ref {variant.ctor})}} {\memgloref{}}|memjustarg}{615} -\glossaryentry{variant.dtor@ {\memgloterm{variant.dtor}}{\memglodesc{(\ref {variant.dtor})}} {\memgloref{}}|memjustarg}{617} -\glossaryentry{variant.assign@ {\memgloterm{variant.assign}}{\memglodesc{(\ref {variant.assign})}} {\memgloref{}}|memjustarg}{617} -\glossaryentry{variant.mod@ {\memgloterm{variant.mod}}{\memglodesc{(\ref {variant.mod})}} {\memgloref{}}|memjustarg}{618} -\glossaryentry{variant.status@ {\memgloterm{variant.status}}{\memglodesc{(\ref {variant.status})}} {\memgloref{}}|memjustarg}{619} -\glossaryentry{variant.swap@ {\memgloterm{variant.swap}}{\memglodesc{(\ref {variant.swap})}} {\memgloref{}}|memjustarg}{619} -\glossaryentry{variant.helper@ {\memgloterm{variant.helper}}{\memglodesc{(\ref {variant.helper})}} {\memgloref{}}|memjustarg}{620} -\glossaryentry{variant.get@ {\memgloterm{variant.get}}{\memglodesc{(\ref {variant.get})}} {\memgloref{}}|memjustarg}{620} -\glossaryentry{variant.relops@ {\memgloterm{variant.relops}}{\memglodesc{(\ref {variant.relops})}} {\memgloref{}}|memjustarg}{621} -\glossaryentry{variant.visit@ {\memgloterm{variant.visit}}{\memglodesc{(\ref {variant.visit})}} {\memgloref{}}|memjustarg}{622} -\glossaryentry{variant.monostate@ {\memgloterm{variant.monostate}}{\memglodesc{(\ref {variant.monostate})}} {\memgloref{}}|memjustarg}{622} -\glossaryentry{variant.monostate.relops@ {\memgloterm{variant.monostate.relops}}{\memglodesc{(\ref {variant.monostate.relops})}} {\memgloref{}}|memjustarg}{622} -\glossaryentry{variant.specalg@ {\memgloterm{variant.specalg}}{\memglodesc{(\ref {variant.specalg})}} {\memgloref{}}|memjustarg}{622} -\glossaryentry{variant.bad.access@ {\memgloterm{variant.bad.access}}{\memglodesc{(\ref {variant.bad.access})}} {\memgloref{}}|memjustarg}{622} -\glossaryentry{variant.hash@ {\memgloterm{variant.hash}}{\memglodesc{(\ref {variant.hash})}} {\memgloref{}}|memjustarg}{623} -\glossaryentry{any@ {\memgloterm{any}}{\memglodesc{(\ref {any})}} {\memgloref{}}|memjustarg}{623} -\glossaryentry{any.general@ {\memgloterm{any.general}}{\memglodesc{(\ref {any.general})}} {\memgloref{}}|memjustarg}{623} -\glossaryentry{any.synop@ {\memgloterm{any.synop}}{\memglodesc{(\ref {any.synop})}} {\memgloref{}}|memjustarg}{623} -\glossaryentry{any.bad.any.cast@ {\memgloterm{any.bad.any.cast}}{\memglodesc{(\ref {any.bad.any.cast})}} {\memgloref{}}|memjustarg}{623} -\glossaryentry{any.class@ {\memgloterm{any.class}}{\memglodesc{(\ref {any.class})}} {\memgloref{}}|memjustarg}{624} -\glossaryentry{any.class.general@ {\memgloterm{any.class.general}}{\memglodesc{(\ref {any.class.general})}} {\memgloref{}}|memjustarg}{624} -\glossaryentry{any.cons@ {\memgloterm{any.cons}}{\memglodesc{(\ref {any.cons})}} {\memgloref{}}|memjustarg}{624} -\glossaryentry{any.assign@ {\memgloterm{any.assign}}{\memglodesc{(\ref {any.assign})}} {\memgloref{}}|memjustarg}{625} -\glossaryentry{any.modifiers@ {\memgloterm{any.modifiers}}{\memglodesc{(\ref {any.modifiers})}} {\memgloref{}}|memjustarg}{626} -\glossaryentry{any.observers@ {\memgloterm{any.observers}}{\memglodesc{(\ref {any.observers})}} {\memgloref{}}|memjustarg}{627} -\glossaryentry{any.nonmembers@ {\memgloterm{any.nonmembers}}{\memglodesc{(\ref {any.nonmembers})}} {\memgloref{}}|memjustarg}{627} -\glossaryentry{bitset@ {\memgloterm{bitset}}{\memglodesc{(\ref {bitset})}} {\memgloref{}}|memjustarg}{628} -\glossaryentry{bitset.syn@ {\memgloterm{bitset.syn}}{\memglodesc{(\ref {bitset.syn})}} {\memgloref{}}|memjustarg}{628} -\glossaryentry{template.bitset@ {\memgloterm{template.bitset}}{\memglodesc{(\ref {template.bitset})}} {\memgloref{}}|memjustarg}{628} -\glossaryentry{template.bitset.general@ {\memgloterm{template.bitset.general}}{\memglodesc{(\ref {template.bitset.general})}} {\memgloref{}}|memjustarg}{628} -\glossaryentry{bitset.cons@ {\memgloterm{bitset.cons}}{\memglodesc{(\ref {bitset.cons})}} {\memgloref{}}|memjustarg}{630} -\glossaryentry{bitset.members@ {\memgloterm{bitset.members}}{\memglodesc{(\ref {bitset.members})}} {\memgloref{}}|memjustarg}{630} -\glossaryentry{bitset.hash@ {\memgloterm{bitset.hash}}{\memglodesc{(\ref {bitset.hash})}} {\memgloref{}}|memjustarg}{633} -\glossaryentry{bitset.operators@ {\memgloterm{bitset.operators}}{\memglodesc{(\ref {bitset.operators})}} {\memgloref{}}|memjustarg}{633} -\glossaryentry{memory@ {\memgloterm{memory}}{\memglodesc{(\ref {memory})}} {\memgloref{}}|memjustarg}{633} -\glossaryentry{memory.general@ {\memgloterm{memory.general}}{\memglodesc{(\ref {memory.general})}} {\memgloref{}}|memjustarg}{633} -\glossaryentry{memory.syn@ {\memgloterm{memory.syn}}{\memglodesc{(\ref {memory.syn})}} {\memgloref{}}|memjustarg}{634} -\glossaryentry{pointer.traits@ {\memgloterm{pointer.traits}}{\memglodesc{(\ref {pointer.traits})}} {\memgloref{}}|memjustarg}{641} -\glossaryentry{pointer.traits.general@ {\memgloterm{pointer.traits.general}}{\memglodesc{(\ref {pointer.traits.general})}} {\memgloref{}}|memjustarg}{641} -\glossaryentry{pointer.traits.types@ {\memgloterm{pointer.traits.types}}{\memglodesc{(\ref {pointer.traits.types})}} {\memgloref{}}|memjustarg}{641} -\glossaryentry{pointer.traits.functions@ {\memgloterm{pointer.traits.functions}}{\memglodesc{(\ref {pointer.traits.functions})}} {\memgloref{}}|memjustarg}{642} -\glossaryentry{pointer.traits.optmem@ {\memgloterm{pointer.traits.optmem}}{\memglodesc{(\ref {pointer.traits.optmem})}} {\memgloref{}}|memjustarg}{642} -\glossaryentry{pointer.conversion@ {\memgloterm{pointer.conversion}}{\memglodesc{(\ref {pointer.conversion})}} {\memgloref{}}|memjustarg}{642} -\glossaryentry{util.dynamic.safety@ {\memgloterm{util.dynamic.safety}}{\memglodesc{(\ref {util.dynamic.safety})}} {\memgloref{}}|memjustarg}{642} -\glossaryentry{ptr.align@ {\memgloterm{ptr.align}}{\memglodesc{(\ref {ptr.align})}} {\memgloref{}}|memjustarg}{643} -\glossaryentry{allocator.tag@ {\memgloterm{allocator.tag}}{\memglodesc{(\ref {allocator.tag})}} {\memgloref{}}|memjustarg}{643} -\glossaryentry{allocator.uses@ {\memgloterm{allocator.uses}}{\memglodesc{(\ref {allocator.uses})}} {\memgloref{}}|memjustarg}{644} -\glossaryentry{allocator.uses.trait@ {\memgloterm{allocator.uses.trait}}{\memglodesc{(\ref {allocator.uses.trait})}} {\memgloref{}}|memjustarg}{644} -\glossaryentry{allocator.uses.construction@ {\memgloterm{allocator.uses.construction}}{\memglodesc{(\ref {allocator.uses.construction})}} {\memgloref{}}|memjustarg}{644} -\glossaryentry{allocator.traits@ {\memgloterm{allocator.traits}}{\memglodesc{(\ref {allocator.traits})}} {\memgloref{}}|memjustarg}{646} -\glossaryentry{allocator.traits.general@ {\memgloterm{allocator.traits.general}}{\memglodesc{(\ref {allocator.traits.general})}} {\memgloref{}}|memjustarg}{646} -\glossaryentry{allocator.traits.types@ {\memgloterm{allocator.traits.types}}{\memglodesc{(\ref {allocator.traits.types})}} {\memgloref{}}|memjustarg}{647} -\glossaryentry{allocator.traits.members@ {\memgloterm{allocator.traits.members}}{\memglodesc{(\ref {allocator.traits.members})}} {\memgloref{}}|memjustarg}{647} -\glossaryentry{default.allocator@ {\memgloterm{default.allocator}}{\memglodesc{(\ref {default.allocator})}} {\memgloref{}}|memjustarg}{648} -\glossaryentry{default.allocator.general@ {\memgloterm{default.allocator.general}}{\memglodesc{(\ref {default.allocator.general})}} {\memgloref{}}|memjustarg}{648} -\glossaryentry{allocator.members@ {\memgloterm{allocator.members}}{\memglodesc{(\ref {allocator.members})}} {\memgloref{}}|memjustarg}{648} -\glossaryentry{allocator.globals@ {\memgloterm{allocator.globals}}{\memglodesc{(\ref {allocator.globals})}} {\memgloref{}}|memjustarg}{649} -\glossaryentry{specialized.addressof@ {\memgloterm{specialized.addressof}}{\memglodesc{(\ref {specialized.addressof})}} {\memgloref{}}|memjustarg}{649} -\glossaryentry{c.malloc@ {\memgloterm{c.malloc}}{\memglodesc{(\ref {c.malloc})}} {\memgloref{}}|memjustarg}{649} -\glossaryentry{smartptr@ {\memgloterm{smartptr}}{\memglodesc{(\ref {smartptr})}} {\memgloref{}}|memjustarg}{649} -\glossaryentry{unique.ptr@ {\memgloterm{unique.ptr}}{\memglodesc{(\ref {unique.ptr})}} {\memgloref{}}|memjustarg}{649} -\glossaryentry{unique.ptr.general@ {\memgloterm{unique.ptr.general}}{\memglodesc{(\ref {unique.ptr.general})}} {\memgloref{}}|memjustarg}{649} -\glossaryentry{unique.ptr.dltr@ {\memgloterm{unique.ptr.dltr}}{\memglodesc{(\ref {unique.ptr.dltr})}} {\memgloref{}}|memjustarg}{650} -\glossaryentry{unique.ptr.dltr.general@ {\memgloterm{unique.ptr.dltr.general}}{\memglodesc{(\ref {unique.ptr.dltr.general})}} {\memgloref{}}|memjustarg}{650} -\glossaryentry{unique.ptr.dltr.dflt@ {\memgloterm{unique.ptr.dltr.dflt}}{\memglodesc{(\ref {unique.ptr.dltr.dflt})}} {\memgloref{}}|memjustarg}{650} -\glossaryentry{unique.ptr.dltr.dflt1@ {\memgloterm{unique.ptr.dltr.dflt1}}{\memglodesc{(\ref {unique.ptr.dltr.dflt1})}} {\memgloref{}}|memjustarg}{650} -\glossaryentry{unique.ptr.single@ {\memgloterm{unique.ptr.single}}{\memglodesc{(\ref {unique.ptr.single})}} {\memgloref{}}|memjustarg}{650} -\glossaryentry{unique.ptr.single.general@ {\memgloterm{unique.ptr.single.general}}{\memglodesc{(\ref {unique.ptr.single.general})}} {\memgloref{}}|memjustarg}{650} -\glossaryentry{unique.ptr.single.ctor@ {\memgloterm{unique.ptr.single.ctor}}{\memglodesc{(\ref {unique.ptr.single.ctor})}} {\memgloref{}}|memjustarg}{651} -\glossaryentry{unique.ptr.single.dtor@ {\memgloterm{unique.ptr.single.dtor}}{\memglodesc{(\ref {unique.ptr.single.dtor})}} {\memgloref{}}|memjustarg}{653} -\glossaryentry{unique.ptr.single.asgn@ {\memgloterm{unique.ptr.single.asgn}}{\memglodesc{(\ref {unique.ptr.single.asgn})}} {\memgloref{}}|memjustarg}{653} -\glossaryentry{unique.ptr.single.observers@ {\memgloterm{unique.ptr.single.observers}}{\memglodesc{(\ref {unique.ptr.single.observers})}} {\memgloref{}}|memjustarg}{653} -\glossaryentry{unique.ptr.single.modifiers@ {\memgloterm{unique.ptr.single.modifiers}}{\memglodesc{(\ref {unique.ptr.single.modifiers})}} {\memgloref{}}|memjustarg}{654} -\glossaryentry{unique.ptr.runtime@ {\memgloterm{unique.ptr.runtime}}{\memglodesc{(\ref {unique.ptr.runtime})}} {\memgloref{}}|memjustarg}{654} -\glossaryentry{unique.ptr.runtime.general@ {\memgloterm{unique.ptr.runtime.general}}{\memglodesc{(\ref {unique.ptr.runtime.general})}} {\memgloref{}}|memjustarg}{654} -\glossaryentry{unique.ptr.runtime.ctor@ {\memgloterm{unique.ptr.runtime.ctor}}{\memglodesc{(\ref {unique.ptr.runtime.ctor})}} {\memgloref{}}|memjustarg}{655} -\glossaryentry{unique.ptr.runtime.asgn@ {\memgloterm{unique.ptr.runtime.asgn}}{\memglodesc{(\ref {unique.ptr.runtime.asgn})}} {\memgloref{}}|memjustarg}{656} -\glossaryentry{unique.ptr.runtime.observers@ {\memgloterm{unique.ptr.runtime.observers}}{\memglodesc{(\ref {unique.ptr.runtime.observers})}} {\memgloref{}}|memjustarg}{656} -\glossaryentry{unique.ptr.runtime.modifiers@ {\memgloterm{unique.ptr.runtime.modifiers}}{\memglodesc{(\ref {unique.ptr.runtime.modifiers})}} {\memgloref{}}|memjustarg}{656} -\glossaryentry{unique.ptr.create@ {\memgloterm{unique.ptr.create}}{\memglodesc{(\ref {unique.ptr.create})}} {\memgloref{}}|memjustarg}{656} -\glossaryentry{unique.ptr.special@ {\memgloterm{unique.ptr.special}}{\memglodesc{(\ref {unique.ptr.special})}} {\memgloref{}}|memjustarg}{657} -\glossaryentry{unique.ptr.io@ {\memgloterm{unique.ptr.io}}{\memglodesc{(\ref {unique.ptr.io})}} {\memgloref{}}|memjustarg}{658} -\glossaryentry{util.smartptr.weak.bad@ {\memgloterm{util.smartptr.weak.bad}}{\memglodesc{(\ref {util.smartptr.weak.bad})}} {\memgloref{}}|memjustarg}{658} -\glossaryentry{util.smartptr.shared@ {\memgloterm{util.smartptr.shared}}{\memglodesc{(\ref {util.smartptr.shared})}} {\memgloref{}}|memjustarg}{659} -\glossaryentry{util.smartptr.shared.general@ {\memgloterm{util.smartptr.shared.general}}{\memglodesc{(\ref {util.smartptr.shared.general})}} {\memgloref{}}|memjustarg}{659} -\glossaryentry{util.smartptr.shared.const@ {\memgloterm{util.smartptr.shared.const}}{\memglodesc{(\ref {util.smartptr.shared.const})}} {\memgloref{}}|memjustarg}{660} -\glossaryentry{util.smartptr.shared.dest@ {\memgloterm{util.smartptr.shared.dest}}{\memglodesc{(\ref {util.smartptr.shared.dest})}} {\memgloref{}}|memjustarg}{662} -\glossaryentry{util.smartptr.shared.assign@ {\memgloterm{util.smartptr.shared.assign}}{\memglodesc{(\ref {util.smartptr.shared.assign})}} {\memgloref{}}|memjustarg}{662} -\glossaryentry{util.smartptr.shared.mod@ {\memgloterm{util.smartptr.shared.mod}}{\memglodesc{(\ref {util.smartptr.shared.mod})}} {\memgloref{}}|memjustarg}{662} -\glossaryentry{util.smartptr.shared.obs@ {\memgloterm{util.smartptr.shared.obs}}{\memglodesc{(\ref {util.smartptr.shared.obs})}} {\memgloref{}}|memjustarg}{663} -\glossaryentry{util.smartptr.shared.create@ {\memgloterm{util.smartptr.shared.create}}{\memglodesc{(\ref {util.smartptr.shared.create})}} {\memgloref{}}|memjustarg}{664} -\glossaryentry{util.smartptr.shared.cmp@ {\memgloterm{util.smartptr.shared.cmp}}{\memglodesc{(\ref {util.smartptr.shared.cmp})}} {\memgloref{}}|memjustarg}{667} -\glossaryentry{util.smartptr.shared.spec@ {\memgloterm{util.smartptr.shared.spec}}{\memglodesc{(\ref {util.smartptr.shared.spec})}} {\memgloref{}}|memjustarg}{667} -\glossaryentry{util.smartptr.shared.cast@ {\memgloterm{util.smartptr.shared.cast}}{\memglodesc{(\ref {util.smartptr.shared.cast})}} {\memgloref{}}|memjustarg}{667} -\glossaryentry{util.smartptr.getdeleter@ {\memgloterm{util.smartptr.getdeleter}}{\memglodesc{(\ref {util.smartptr.getdeleter})}} {\memgloref{}}|memjustarg}{668} -\glossaryentry{util.smartptr.shared.io@ {\memgloterm{util.smartptr.shared.io}}{\memglodesc{(\ref {util.smartptr.shared.io})}} {\memgloref{}}|memjustarg}{668} -\glossaryentry{util.smartptr.weak@ {\memgloterm{util.smartptr.weak}}{\memglodesc{(\ref {util.smartptr.weak})}} {\memgloref{}}|memjustarg}{668} -\glossaryentry{util.smartptr.weak.general@ {\memgloterm{util.smartptr.weak.general}}{\memglodesc{(\ref {util.smartptr.weak.general})}} {\memgloref{}}|memjustarg}{668} -\glossaryentry{util.smartptr.weak.const@ {\memgloterm{util.smartptr.weak.const}}{\memglodesc{(\ref {util.smartptr.weak.const})}} {\memgloref{}}|memjustarg}{669} -\glossaryentry{util.smartptr.weak.dest@ {\memgloterm{util.smartptr.weak.dest}}{\memglodesc{(\ref {util.smartptr.weak.dest})}} {\memgloref{}}|memjustarg}{670} -\glossaryentry{util.smartptr.weak.assign@ {\memgloterm{util.smartptr.weak.assign}}{\memglodesc{(\ref {util.smartptr.weak.assign})}} {\memgloref{}}|memjustarg}{670} -\glossaryentry{util.smartptr.weak.mod@ {\memgloterm{util.smartptr.weak.mod}}{\memglodesc{(\ref {util.smartptr.weak.mod})}} {\memgloref{}}|memjustarg}{670} -\glossaryentry{util.smartptr.weak.obs@ {\memgloterm{util.smartptr.weak.obs}}{\memglodesc{(\ref {util.smartptr.weak.obs})}} {\memgloref{}}|memjustarg}{670} -\glossaryentry{util.smartptr.weak.spec@ {\memgloterm{util.smartptr.weak.spec}}{\memglodesc{(\ref {util.smartptr.weak.spec})}} {\memgloref{}}|memjustarg}{670} -\glossaryentry{util.smartptr.ownerless@ {\memgloterm{util.smartptr.ownerless}}{\memglodesc{(\ref {util.smartptr.ownerless})}} {\memgloref{}}|memjustarg}{670} -\glossaryentry{util.smartptr.enab@ {\memgloterm{util.smartptr.enab}}{\memglodesc{(\ref {util.smartptr.enab})}} {\memgloref{}}|memjustarg}{671} -\glossaryentry{util.smartptr.hash@ {\memgloterm{util.smartptr.hash}}{\memglodesc{(\ref {util.smartptr.hash})}} {\memgloref{}}|memjustarg}{672} -\glossaryentry{mem.res@ {\memgloterm{mem.res}}{\memglodesc{(\ref {mem.res})}} {\memgloref{}}|memjustarg}{672} -\glossaryentry{mem.res.syn@ {\memgloterm{mem.res.syn}}{\memglodesc{(\ref {mem.res.syn})}} {\memgloref{}}|memjustarg}{672} -\glossaryentry{mem.res.class@ {\memgloterm{mem.res.class}}{\memglodesc{(\ref {mem.res.class})}} {\memgloref{}}|memjustarg}{673} -\glossaryentry{mem.res.class.general@ {\memgloterm{mem.res.class.general}}{\memglodesc{(\ref {mem.res.class.general})}} {\memgloref{}}|memjustarg}{673} -\glossaryentry{mem.res.public@ {\memgloterm{mem.res.public}}{\memglodesc{(\ref {mem.res.public})}} {\memgloref{}}|memjustarg}{673} -\glossaryentry{mem.res.private@ {\memgloterm{mem.res.private}}{\memglodesc{(\ref {mem.res.private})}} {\memgloref{}}|memjustarg}{673} -\glossaryentry{mem.res.eq@ {\memgloterm{mem.res.eq}}{\memglodesc{(\ref {mem.res.eq})}} {\memgloref{}}|memjustarg}{674} -\glossaryentry{mem.poly.allocator.class@ {\memgloterm{mem.poly.allocator.class}}{\memglodesc{(\ref {mem.poly.allocator.class})}} {\memgloref{}}|memjustarg}{674} -\glossaryentry{mem.poly.allocator.class.general@ {\memgloterm{mem.poly.allocator.class.general}}{\memglodesc{(\ref {mem.poly.allocator.class.general})}} {\memgloref{}}|memjustarg}{674} -\glossaryentry{mem.poly.allocator.ctor@ {\memgloterm{mem.poly.allocator.ctor}}{\memglodesc{(\ref {mem.poly.allocator.ctor})}} {\memgloref{}}|memjustarg}{675} -\glossaryentry{mem.poly.allocator.mem@ {\memgloterm{mem.poly.allocator.mem}}{\memglodesc{(\ref {mem.poly.allocator.mem})}} {\memgloref{}}|memjustarg}{675} -\glossaryentry{mem.poly.allocator.eq@ {\memgloterm{mem.poly.allocator.eq}}{\memglodesc{(\ref {mem.poly.allocator.eq})}} {\memgloref{}}|memjustarg}{676} -\glossaryentry{mem.res.global@ {\memgloterm{mem.res.global}}{\memglodesc{(\ref {mem.res.global})}} {\memgloref{}}|memjustarg}{676} -\glossaryentry{mem.res.pool@ {\memgloterm{mem.res.pool}}{\memglodesc{(\ref {mem.res.pool})}} {\memgloref{}}|memjustarg}{677} -\glossaryentry{mem.res.pool.overview@ {\memgloterm{mem.res.pool.overview}}{\memglodesc{(\ref {mem.res.pool.overview})}} {\memgloref{}}|memjustarg}{677} -\glossaryentry{mem.res.pool.options@ {\memgloterm{mem.res.pool.options}}{\memglodesc{(\ref {mem.res.pool.options})}} {\memgloref{}}|memjustarg}{678} -\glossaryentry{mem.res.pool.ctor@ {\memgloterm{mem.res.pool.ctor}}{\memglodesc{(\ref {mem.res.pool.ctor})}} {\memgloref{}}|memjustarg}{678} -\glossaryentry{mem.res.pool.mem@ {\memgloterm{mem.res.pool.mem}}{\memglodesc{(\ref {mem.res.pool.mem})}} {\memgloref{}}|memjustarg}{679} -\glossaryentry{mem.res.monotonic.buffer@ {\memgloterm{mem.res.monotonic.buffer}}{\memglodesc{(\ref {mem.res.monotonic.buffer})}} {\memgloref{}}|memjustarg}{679} -\glossaryentry{mem.res.monotonic.buffer.general@ {\memgloterm{mem.res.monotonic.buffer.general}}{\memglodesc{(\ref {mem.res.monotonic.buffer.general})}} {\memgloref{}}|memjustarg}{679} -\glossaryentry{mem.res.monotonic.buffer.ctor@ {\memgloterm{mem.res.monotonic.buffer.ctor}}{\memglodesc{(\ref {mem.res.monotonic.buffer.ctor})}} {\memgloref{}}|memjustarg}{680} -\glossaryentry{mem.res.monotonic.buffer.mem@ {\memgloterm{mem.res.monotonic.buffer.mem}}{\memglodesc{(\ref {mem.res.monotonic.buffer.mem})}} {\memgloref{}}|memjustarg}{680} -\glossaryentry{allocator.adaptor@ {\memgloterm{allocator.adaptor}}{\memglodesc{(\ref {allocator.adaptor})}} {\memgloref{}}|memjustarg}{681} -\glossaryentry{allocator.adaptor.syn@ {\memgloterm{allocator.adaptor.syn}}{\memglodesc{(\ref {allocator.adaptor.syn})}} {\memgloref{}}|memjustarg}{681} -\glossaryentry{allocator.adaptor.types@ {\memgloterm{allocator.adaptor.types}}{\memglodesc{(\ref {allocator.adaptor.types})}} {\memgloref{}}|memjustarg}{683} -\glossaryentry{allocator.adaptor.cnstr@ {\memgloterm{allocator.adaptor.cnstr}}{\memglodesc{(\ref {allocator.adaptor.cnstr})}} {\memgloref{}}|memjustarg}{683} -\glossaryentry{allocator.adaptor.members@ {\memgloterm{allocator.adaptor.members}}{\memglodesc{(\ref {allocator.adaptor.members})}} {\memgloref{}}|memjustarg}{684} -\glossaryentry{scoped.adaptor.operators@ {\memgloterm{scoped.adaptor.operators}}{\memglodesc{(\ref {scoped.adaptor.operators})}} {\memgloref{}}|memjustarg}{684} -\glossaryentry{function.objects@ {\memgloterm{function.objects}}{\memglodesc{(\ref {function.objects})}} {\memgloref{}}|memjustarg}{685} -\glossaryentry{function.objects.general@ {\memgloterm{function.objects.general}}{\memglodesc{(\ref {function.objects.general})}} {\memgloref{}}|memjustarg}{685} -\glossaryentry{functional.syn@ {\memgloterm{functional.syn}}{\memglodesc{(\ref {functional.syn})}} {\memgloref{}}|memjustarg}{685} -\glossaryentry{func.def@ {\memgloterm{func.def}}{\memglodesc{(\ref {func.def})}} {\memgloref{}}|memjustarg}{687} -\glossaryentry{func.require@ {\memgloterm{func.require}}{\memglodesc{(\ref {func.require})}} {\memgloref{}}|memjustarg}{687} -\glossaryentry{func.invoke@ {\memgloterm{func.invoke}}{\memglodesc{(\ref {func.invoke})}} {\memgloref{}}|memjustarg}{688} -\glossaryentry{refwrap@ {\memgloterm{refwrap}}{\memglodesc{(\ref {refwrap})}} {\memgloref{}}|memjustarg}{688} -\glossaryentry{refwrap.general@ {\memgloterm{refwrap.general}}{\memglodesc{(\ref {refwrap.general})}} {\memgloref{}}|memjustarg}{688} -\glossaryentry{refwrap.const@ {\memgloterm{refwrap.const}}{\memglodesc{(\ref {refwrap.const})}} {\memgloref{}}|memjustarg}{689} -\glossaryentry{refwrap.assign@ {\memgloterm{refwrap.assign}}{\memglodesc{(\ref {refwrap.assign})}} {\memgloref{}}|memjustarg}{689} -\glossaryentry{refwrap.access@ {\memgloterm{refwrap.access}}{\memglodesc{(\ref {refwrap.access})}} {\memgloref{}}|memjustarg}{689} -\glossaryentry{refwrap.invoke@ {\memgloterm{refwrap.invoke}}{\memglodesc{(\ref {refwrap.invoke})}} {\memgloref{}}|memjustarg}{690} -\glossaryentry{refwrap.helpers@ {\memgloterm{refwrap.helpers}}{\memglodesc{(\ref {refwrap.helpers})}} {\memgloref{}}|memjustarg}{690} -\glossaryentry{arithmetic.operations@ {\memgloterm{arithmetic.operations}}{\memglodesc{(\ref {arithmetic.operations})}} {\memgloref{}}|memjustarg}{690} -\glossaryentry{arithmetic.operations.general@ {\memgloterm{arithmetic.operations.general}}{\memglodesc{(\ref {arithmetic.operations.general})}} {\memgloref{}}|memjustarg}{690} -\glossaryentry{arithmetic.operations.plus@ {\memgloterm{arithmetic.operations.plus}}{\memglodesc{(\ref {arithmetic.operations.plus})}} {\memgloref{}}|memjustarg}{690} -\glossaryentry{arithmetic.operations.minus@ {\memgloterm{arithmetic.operations.minus}}{\memglodesc{(\ref {arithmetic.operations.minus})}} {\memgloref{}}|memjustarg}{690} -\glossaryentry{arithmetic.operations.multiplies@ {\memgloterm{arithmetic.operations.multiplies}}{\memglodesc{(\ref {arithmetic.operations.multiplies})}} {\memgloref{}}|memjustarg}{691} -\glossaryentry{arithmetic.operations.divides@ {\memgloterm{arithmetic.operations.divides}}{\memglodesc{(\ref {arithmetic.operations.divides})}} {\memgloref{}}|memjustarg}{691} -\glossaryentry{arithmetic.operations.modulus@ {\memgloterm{arithmetic.operations.modulus}}{\memglodesc{(\ref {arithmetic.operations.modulus})}} {\memgloref{}}|memjustarg}{691} -\glossaryentry{arithmetic.operations.negate@ {\memgloterm{arithmetic.operations.negate}}{\memglodesc{(\ref {arithmetic.operations.negate})}} {\memgloref{}}|memjustarg}{692} -\glossaryentry{comparisons@ {\memgloterm{comparisons}}{\memglodesc{(\ref {comparisons})}} {\memgloref{}}|memjustarg}{692} -\glossaryentry{comparisons.general@ {\memgloterm{comparisons.general}}{\memglodesc{(\ref {comparisons.general})}} {\memgloref{}}|memjustarg}{692} -\glossaryentry{comparisons.equal.to@ {\memgloterm{comparisons.equal.to}}{\memglodesc{(\ref {comparisons.equal.to})}} {\memgloref{}}|memjustarg}{692} -\glossaryentry{comparisons.not.equal.to@ {\memgloterm{comparisons.not.equal.to}}{\memglodesc{(\ref {comparisons.not.equal.to})}} {\memgloref{}}|memjustarg}{692} -\glossaryentry{comparisons.greater@ {\memgloterm{comparisons.greater}}{\memglodesc{(\ref {comparisons.greater})}} {\memgloref{}}|memjustarg}{693} -\glossaryentry{comparisons.less@ {\memgloterm{comparisons.less}}{\memglodesc{(\ref {comparisons.less})}} {\memgloref{}}|memjustarg}{693} -\glossaryentry{comparisons.greater.equal@ {\memgloterm{comparisons.greater.equal}}{\memglodesc{(\ref {comparisons.greater.equal})}} {\memgloref{}}|memjustarg}{693} -\glossaryentry{comparisons.less.equal@ {\memgloterm{comparisons.less.equal}}{\memglodesc{(\ref {comparisons.less.equal})}} {\memgloref{}}|memjustarg}{694} -\glossaryentry{comparisons.three.way@ {\memgloterm{comparisons.three.way}}{\memglodesc{(\ref {comparisons.three.way})}} {\memgloref{}}|memjustarg}{694} -\glossaryentry{range.cmp@ {\memgloterm{range.cmp}}{\memglodesc{(\ref {range.cmp})}} {\memgloref{}}|memjustarg}{695} -\glossaryentry{logical.operations@ {\memgloterm{logical.operations}}{\memglodesc{(\ref {logical.operations})}} {\memgloref{}}|memjustarg}{696} -\glossaryentry{logical.operations.general@ {\memgloterm{logical.operations.general}}{\memglodesc{(\ref {logical.operations.general})}} {\memgloref{}}|memjustarg}{696} -\glossaryentry{logical.operations.and@ {\memgloterm{logical.operations.and}}{\memglodesc{(\ref {logical.operations.and})}} {\memgloref{}}|memjustarg}{696} -\glossaryentry{logical.operations.or@ {\memgloterm{logical.operations.or}}{\memglodesc{(\ref {logical.operations.or})}} {\memgloref{}}|memjustarg}{696} -\glossaryentry{logical.operations.not@ {\memgloterm{logical.operations.not}}{\memglodesc{(\ref {logical.operations.not})}} {\memgloref{}}|memjustarg}{697} -\glossaryentry{bitwise.operations@ {\memgloterm{bitwise.operations}}{\memglodesc{(\ref {bitwise.operations})}} {\memgloref{}}|memjustarg}{697} -\glossaryentry{bitwise.operations.general@ {\memgloterm{bitwise.operations.general}}{\memglodesc{(\ref {bitwise.operations.general})}} {\memgloref{}}|memjustarg}{697} -\glossaryentry{bitwise.operations.and@ {\memgloterm{bitwise.operations.and}}{\memglodesc{(\ref {bitwise.operations.and})}} {\memgloref{}}|memjustarg}{697} -\glossaryentry{bitwise.operations.or@ {\memgloterm{bitwise.operations.or}}{\memglodesc{(\ref {bitwise.operations.or})}} {\memgloref{}}|memjustarg}{697} -\glossaryentry{bitwise.operations.xor@ {\memgloterm{bitwise.operations.xor}}{\memglodesc{(\ref {bitwise.operations.xor})}} {\memgloref{}}|memjustarg}{698} -\glossaryentry{bitwise.operations.not@ {\memgloterm{bitwise.operations.not}}{\memglodesc{(\ref {bitwise.operations.not})}} {\memgloref{}}|memjustarg}{698} -\glossaryentry{func.identity@ {\memgloterm{func.identity}}{\memglodesc{(\ref {func.identity})}} {\memgloref{}}|memjustarg}{698} -\glossaryentry{func.not.fn@ {\memgloterm{func.not.fn}}{\memglodesc{(\ref {func.not.fn})}} {\memgloref{}}|memjustarg}{699} -\glossaryentry{func.bind.front@ {\memgloterm{func.bind.front}}{\memglodesc{(\ref {func.bind.front})}} {\memgloref{}}|memjustarg}{699} -\glossaryentry{func.bind@ {\memgloterm{func.bind}}{\memglodesc{(\ref {func.bind})}} {\memgloref{}}|memjustarg}{699} -\glossaryentry{func.bind.general@ {\memgloterm{func.bind.general}}{\memglodesc{(\ref {func.bind.general})}} {\memgloref{}}|memjustarg}{699} -\glossaryentry{func.bind.isbind@ {\memgloterm{func.bind.isbind}}{\memglodesc{(\ref {func.bind.isbind})}} {\memgloref{}}|memjustarg}{699} -\glossaryentry{func.bind.isplace@ {\memgloterm{func.bind.isplace}}{\memglodesc{(\ref {func.bind.isplace})}} {\memgloref{}}|memjustarg}{700} -\glossaryentry{func.bind.bind@ {\memgloterm{func.bind.bind}}{\memglodesc{(\ref {func.bind.bind})}} {\memgloref{}}|memjustarg}{700} -\glossaryentry{func.bind.place@ {\memgloterm{func.bind.place}}{\memglodesc{(\ref {func.bind.place})}} {\memgloref{}}|memjustarg}{701} -\glossaryentry{func.memfn@ {\memgloterm{func.memfn}}{\memglodesc{(\ref {func.memfn})}} {\memgloref{}}|memjustarg}{701} -\glossaryentry{func.wrap@ {\memgloterm{func.wrap}}{\memglodesc{(\ref {func.wrap})}} {\memgloref{}}|memjustarg}{701} -\glossaryentry{func.wrap.general@ {\memgloterm{func.wrap.general}}{\memglodesc{(\ref {func.wrap.general})}} {\memgloref{}}|memjustarg}{701} -\glossaryentry{func.wrap.badcall@ {\memgloterm{func.wrap.badcall}}{\memglodesc{(\ref {func.wrap.badcall})}} {\memgloref{}}|memjustarg}{701} -\glossaryentry{func.wrap.func@ {\memgloterm{func.wrap.func}}{\memglodesc{(\ref {func.wrap.func})}} {\memgloref{}}|memjustarg}{702} -\glossaryentry{func.wrap.func.general@ {\memgloterm{func.wrap.func.general}}{\memglodesc{(\ref {func.wrap.func.general})}} {\memgloref{}}|memjustarg}{702} -\glossaryentry{func.wrap.func.con@ {\memgloterm{func.wrap.func.con}}{\memglodesc{(\ref {func.wrap.func.con})}} {\memgloref{}}|memjustarg}{703} -\glossaryentry{func.wrap.func.mod@ {\memgloterm{func.wrap.func.mod}}{\memglodesc{(\ref {func.wrap.func.mod})}} {\memgloref{}}|memjustarg}{704} -\glossaryentry{func.wrap.func.cap@ {\memgloterm{func.wrap.func.cap}}{\memglodesc{(\ref {func.wrap.func.cap})}} {\memgloref{}}|memjustarg}{704} -\glossaryentry{func.wrap.func.inv@ {\memgloterm{func.wrap.func.inv}}{\memglodesc{(\ref {func.wrap.func.inv})}} {\memgloref{}}|memjustarg}{704} -\glossaryentry{func.wrap.func.targ@ {\memgloterm{func.wrap.func.targ}}{\memglodesc{(\ref {func.wrap.func.targ})}} {\memgloref{}}|memjustarg}{704} -\glossaryentry{func.wrap.func.nullptr@ {\memgloterm{func.wrap.func.nullptr}}{\memglodesc{(\ref {func.wrap.func.nullptr})}} {\memgloref{}}|memjustarg}{704} -\glossaryentry{func.wrap.func.alg@ {\memgloterm{func.wrap.func.alg}}{\memglodesc{(\ref {func.wrap.func.alg})}} {\memgloref{}}|memjustarg}{705} -\glossaryentry{func.search@ {\memgloterm{func.search}}{\memglodesc{(\ref {func.search})}} {\memgloref{}}|memjustarg}{705} -\glossaryentry{func.search.general@ {\memgloterm{func.search.general}}{\memglodesc{(\ref {func.search.general})}} {\memgloref{}}|memjustarg}{705} -\glossaryentry{func.search.default@ {\memgloterm{func.search.default}}{\memglodesc{(\ref {func.search.default})}} {\memgloref{}}|memjustarg}{705} -\glossaryentry{func.search.bm@ {\memgloterm{func.search.bm}}{\memglodesc{(\ref {func.search.bm})}} {\memgloref{}}|memjustarg}{706} -\glossaryentry{func.search.bmh@ {\memgloterm{func.search.bmh}}{\memglodesc{(\ref {func.search.bmh})}} {\memgloref{}}|memjustarg}{706} -\glossaryentry{unord.hash@ {\memgloterm{unord.hash}}{\memglodesc{(\ref {unord.hash})}} {\memgloref{}}|memjustarg}{707} -\glossaryentry{meta@ {\memgloterm{meta}}{\memglodesc{(\ref {meta})}} {\memgloref{}}|memjustarg}{708} -\glossaryentry{meta.general@ {\memgloterm{meta.general}}{\memglodesc{(\ref {meta.general})}} {\memgloref{}}|memjustarg}{708} -\glossaryentry{meta.rqmts@ {\memgloterm{meta.rqmts}}{\memglodesc{(\ref {meta.rqmts})}} {\memgloref{}}|memjustarg}{708} -\glossaryentry{meta.type.synop@ {\memgloterm{meta.type.synop}}{\memglodesc{(\ref {meta.type.synop})}} {\memgloref{}}|memjustarg}{709} -\glossaryentry{meta.help@ {\memgloterm{meta.help}}{\memglodesc{(\ref {meta.help})}} {\memgloref{}}|memjustarg}{715} -\glossaryentry{meta.unary@ {\memgloterm{meta.unary}}{\memglodesc{(\ref {meta.unary})}} {\memgloref{}}|memjustarg}{715} -\glossaryentry{meta.unary.general@ {\memgloterm{meta.unary.general}}{\memglodesc{(\ref {meta.unary.general})}} {\memgloref{}}|memjustarg}{715} -\glossaryentry{meta.unary.cat@ {\memgloterm{meta.unary.cat}}{\memglodesc{(\ref {meta.unary.cat})}} {\memgloref{}}|memjustarg}{716} -\glossaryentry{meta.unary.comp@ {\memgloterm{meta.unary.comp}}{\memglodesc{(\ref {meta.unary.comp})}} {\memgloref{}}|memjustarg}{716} -\glossaryentry{meta.unary.prop@ {\memgloterm{meta.unary.prop}}{\memglodesc{(\ref {meta.unary.prop})}} {\memgloref{}}|memjustarg}{717} -\glossaryentry{meta.unary.prop.query@ {\memgloterm{meta.unary.prop.query}}{\memglodesc{(\ref {meta.unary.prop.query})}} {\memgloref{}}|memjustarg}{723} -\glossaryentry{meta.rel@ {\memgloterm{meta.rel}}{\memglodesc{(\ref {meta.rel})}} {\memgloref{}}|memjustarg}{724} -\glossaryentry{meta.trans@ {\memgloterm{meta.trans}}{\memglodesc{(\ref {meta.trans})}} {\memgloref{}}|memjustarg}{726} -\glossaryentry{meta.trans.general@ {\memgloterm{meta.trans.general}}{\memglodesc{(\ref {meta.trans.general})}} {\memgloref{}}|memjustarg}{726} -\glossaryentry{meta.trans.cv@ {\memgloterm{meta.trans.cv}}{\memglodesc{(\ref {meta.trans.cv})}} {\memgloref{}}|memjustarg}{726} -\glossaryentry{meta.trans.ref@ {\memgloterm{meta.trans.ref}}{\memglodesc{(\ref {meta.trans.ref})}} {\memgloref{}}|memjustarg}{726} -\glossaryentry{meta.trans.sign@ {\memgloterm{meta.trans.sign}}{\memglodesc{(\ref {meta.trans.sign})}} {\memgloref{}}|memjustarg}{727} -\glossaryentry{meta.trans.arr@ {\memgloterm{meta.trans.arr}}{\memglodesc{(\ref {meta.trans.arr})}} {\memgloref{}}|memjustarg}{727} -\glossaryentry{meta.trans.ptr@ {\memgloterm{meta.trans.ptr}}{\memglodesc{(\ref {meta.trans.ptr})}} {\memgloref{}}|memjustarg}{727} -\glossaryentry{meta.trans.other@ {\memgloterm{meta.trans.other}}{\memglodesc{(\ref {meta.trans.other})}} {\memgloref{}}|memjustarg}{728} -\glossaryentry{meta.logical@ {\memgloterm{meta.logical}}{\memglodesc{(\ref {meta.logical})}} {\memgloref{}}|memjustarg}{731} -\glossaryentry{meta.member@ {\memgloterm{meta.member}}{\memglodesc{(\ref {meta.member})}} {\memgloref{}}|memjustarg}{732} -\glossaryentry{meta.const.eval@ {\memgloterm{meta.const.eval}}{\memglodesc{(\ref {meta.const.eval})}} {\memgloref{}}|memjustarg}{733} -\glossaryentry{ratio@ {\memgloterm{ratio}}{\memglodesc{(\ref {ratio})}} {\memgloref{}}|memjustarg}{733} -\glossaryentry{ratio.general@ {\memgloterm{ratio.general}}{\memglodesc{(\ref {ratio.general})}} {\memgloref{}}|memjustarg}{733} -\glossaryentry{ratio.syn@ {\memgloterm{ratio.syn}}{\memglodesc{(\ref {ratio.syn})}} {\memgloref{}}|memjustarg}{733} -\glossaryentry{ratio.ratio@ {\memgloterm{ratio.ratio}}{\memglodesc{(\ref {ratio.ratio})}} {\memgloref{}}|memjustarg}{734} -\glossaryentry{ratio.arithmetic@ {\memgloterm{ratio.arithmetic}}{\memglodesc{(\ref {ratio.arithmetic})}} {\memgloref{}}|memjustarg}{734} -\glossaryentry{ratio.comparison@ {\memgloterm{ratio.comparison}}{\memglodesc{(\ref {ratio.comparison})}} {\memgloref{}}|memjustarg}{735} -\glossaryentry{ratio.si@ {\memgloterm{ratio.si}}{\memglodesc{(\ref {ratio.si})}} {\memgloref{}}|memjustarg}{735} -\glossaryentry{type.index@ {\memgloterm{type.index}}{\memglodesc{(\ref {type.index})}} {\memgloref{}}|memjustarg}{735} -\glossaryentry{type.index.synopsis@ {\memgloterm{type.index.synopsis}}{\memglodesc{(\ref {type.index.synopsis})}} {\memgloref{}}|memjustarg}{735} -\glossaryentry{type.index.overview@ {\memgloterm{type.index.overview}}{\memglodesc{(\ref {type.index.overview})}} {\memgloref{}}|memjustarg}{736} -\glossaryentry{type.index.members@ {\memgloterm{type.index.members}}{\memglodesc{(\ref {type.index.members})}} {\memgloref{}}|memjustarg}{736} -\glossaryentry{type.index.hash@ {\memgloterm{type.index.hash}}{\memglodesc{(\ref {type.index.hash})}} {\memgloref{}}|memjustarg}{737} -\glossaryentry{execpol@ {\memgloterm{execpol}}{\memglodesc{(\ref {execpol})}} {\memgloref{}}|memjustarg}{737} -\glossaryentry{execpol.general@ {\memgloterm{execpol.general}}{\memglodesc{(\ref {execpol.general})}} {\memgloref{}}|memjustarg}{737} -\glossaryentry{execution.syn@ {\memgloterm{execution.syn}}{\memglodesc{(\ref {execution.syn})}} {\memgloref{}}|memjustarg}{737} -\glossaryentry{execpol.type@ {\memgloterm{execpol.type}}{\memglodesc{(\ref {execpol.type})}} {\memgloref{}}|memjustarg}{738} -\glossaryentry{execpol.seq@ {\memgloterm{execpol.seq}}{\memglodesc{(\ref {execpol.seq})}} {\memgloref{}}|memjustarg}{738} -\glossaryentry{execpol.par@ {\memgloterm{execpol.par}}{\memglodesc{(\ref {execpol.par})}} {\memgloref{}}|memjustarg}{738} -\glossaryentry{execpol.parunseq@ {\memgloterm{execpol.parunseq}}{\memglodesc{(\ref {execpol.parunseq})}} {\memgloref{}}|memjustarg}{738} -\glossaryentry{execpol.unseq@ {\memgloterm{execpol.unseq}}{\memglodesc{(\ref {execpol.unseq})}} {\memgloref{}}|memjustarg}{738} -\glossaryentry{execpol.objects@ {\memgloterm{execpol.objects}}{\memglodesc{(\ref {execpol.objects})}} {\memgloref{}}|memjustarg}{738} -\glossaryentry{charconv@ {\memgloterm{charconv}}{\memglodesc{(\ref {charconv})}} {\memgloref{}}|memjustarg}{739} -\glossaryentry{charconv.syn@ {\memgloterm{charconv.syn}}{\memglodesc{(\ref {charconv.syn})}} {\memgloref{}}|memjustarg}{739} -\glossaryentry{charconv.to.chars@ {\memgloterm{charconv.to.chars}}{\memglodesc{(\ref {charconv.to.chars})}} {\memgloref{}}|memjustarg}{739} -\glossaryentry{charconv.from.chars@ {\memgloterm{charconv.from.chars}}{\memglodesc{(\ref {charconv.from.chars})}} {\memgloref{}}|memjustarg}{740} -\glossaryentry{format@ {\memgloterm{format}}{\memglodesc{(\ref {format})}} {\memgloref{}}|memjustarg}{741} -\glossaryentry{format.syn@ {\memgloterm{format.syn}}{\memglodesc{(\ref {format.syn})}} {\memgloref{}}|memjustarg}{741} -\glossaryentry{format.string@ {\memgloterm{format.string}}{\memglodesc{(\ref {format.string})}} {\memgloref{}}|memjustarg}{743} -\glossaryentry{format.string.general@ {\memgloterm{format.string.general}}{\memglodesc{(\ref {format.string.general})}} {\memgloref{}}|memjustarg}{743} -\glossaryentry{format.string.std@ {\memgloterm{format.string.std}}{\memglodesc{(\ref {format.string.std})}} {\memgloref{}}|memjustarg}{744} -\glossaryentry{format.err.report@ {\memgloterm{format.err.report}}{\memglodesc{(\ref {format.err.report})}} {\memgloref{}}|memjustarg}{749} -\glossaryentry{format.functions@ {\memgloterm{format.functions}}{\memglodesc{(\ref {format.functions})}} {\memgloref{}}|memjustarg}{749} -\glossaryentry{format.formatter@ {\memgloterm{format.formatter}}{\memglodesc{(\ref {format.formatter})}} {\memgloref{}}|memjustarg}{751} -\glossaryentry{formatter.requirements@ {\memgloterm{formatter.requirements}}{\memglodesc{(\ref {formatter.requirements})}} {\memgloref{}}|memjustarg}{751} -\glossaryentry{format.formatter.spec@ {\memgloterm{format.formatter.spec}}{\memglodesc{(\ref {format.formatter.spec})}} {\memgloref{}}|memjustarg}{751} -\glossaryentry{format.parse.ctx@ {\memgloterm{format.parse.ctx}}{\memglodesc{(\ref {format.parse.ctx})}} {\memgloref{}}|memjustarg}{753} -\glossaryentry{format.context@ {\memgloterm{format.context}}{\memglodesc{(\ref {format.context})}} {\memgloref{}}|memjustarg}{754} -\glossaryentry{format.arguments@ {\memgloterm{format.arguments}}{\memglodesc{(\ref {format.arguments})}} {\memgloref{}}|memjustarg}{755} -\glossaryentry{format.arg@ {\memgloterm{format.arg}}{\memglodesc{(\ref {format.arg})}} {\memgloref{}}|memjustarg}{755} -\glossaryentry{format.arg.store@ {\memgloterm{format.arg.store}}{\memglodesc{(\ref {format.arg.store})}} {\memgloref{}}|memjustarg}{757} -\glossaryentry{format.args@ {\memgloterm{format.args}}{\memglodesc{(\ref {format.args})}} {\memgloref{}}|memjustarg}{758} -\glossaryentry{format.error@ {\memgloterm{format.error}}{\memglodesc{(\ref {format.error})}} {\memgloref{}}|memjustarg}{758} -\glossaryentry{strings@ {\memgloterm{strings}}{\memglodesc{(\ref {strings})}} {\memgloref{}}|memjustarg}{760} -\glossaryentry{strings.general@ {\memgloterm{strings.general}}{\memglodesc{(\ref {strings.general})}} {\memgloref{}}|memjustarg}{760} -\glossaryentry{char.traits@ {\memgloterm{char.traits}}{\memglodesc{(\ref {char.traits})}} {\memgloref{}}|memjustarg}{760} -\glossaryentry{char.traits.general@ {\memgloterm{char.traits.general}}{\memglodesc{(\ref {char.traits.general})}} {\memgloref{}}|memjustarg}{760} -\glossaryentry{char.traits.require@ {\memgloterm{char.traits.require}}{\memglodesc{(\ref {char.traits.require})}} {\memgloref{}}|memjustarg}{760} -\glossaryentry{char.traits.typedefs@ {\memgloterm{char.traits.typedefs}}{\memglodesc{(\ref {char.traits.typedefs})}} {\memgloref{}}|memjustarg}{762} -\glossaryentry{char.traits.specializations@ {\memgloterm{char.traits.specializations}}{\memglodesc{(\ref {char.traits.specializations})}} {\memgloref{}}|memjustarg}{762} -\glossaryentry{char.traits.specializations.general@ {\memgloterm{char.traits.specializations.general}}{\memglodesc{(\ref {char.traits.specializations.general})}} {\memgloref{}}|memjustarg}{762} -\glossaryentry{char.traits.specializations.char@ {\memgloterm{char.traits.specializations.char}}{\memglodesc{(\ref {char.traits.specializations.char})}} {\memgloref{}}|memjustarg}{762} -\glossaryentry{char.traits.specializations.char8.t@ {\memgloterm{char.traits.specializations.char8.t}}{\memglodesc{(\ref {char.traits.specializations.char8.t})}} {\memgloref{}}|memjustarg}{763} -\glossaryentry{char.traits.specializations.char16.t@ {\memgloterm{char.traits.specializations.char16.t}}{\memglodesc{(\ref {char.traits.specializations.char16.t})}} {\memgloref{}}|memjustarg}{763} -\glossaryentry{char.traits.specializations.char32.t@ {\memgloterm{char.traits.specializations.char32.t}}{\memglodesc{(\ref {char.traits.specializations.char32.t})}} {\memgloref{}}|memjustarg}{764} -\glossaryentry{char.traits.specializations.wchar.t@ {\memgloterm{char.traits.specializations.wchar.t}}{\memglodesc{(\ref {char.traits.specializations.wchar.t})}} {\memgloref{}}|memjustarg}{764} -\glossaryentry{string.classes@ {\memgloterm{string.classes}}{\memglodesc{(\ref {string.classes})}} {\memgloref{}}|memjustarg}{765} -\glossaryentry{string.classes.general@ {\memgloterm{string.classes.general}}{\memglodesc{(\ref {string.classes.general})}} {\memgloref{}}|memjustarg}{765} -\glossaryentry{string.syn@ {\memgloterm{string.syn}}{\memglodesc{(\ref {string.syn})}} {\memgloref{}}|memjustarg}{765} -\glossaryentry{basic.string@ {\memgloterm{basic.string}}{\memglodesc{(\ref {basic.string})}} {\memgloref{}}|memjustarg}{768} -\glossaryentry{basic.string.general@ {\memgloterm{basic.string.general}}{\memglodesc{(\ref {basic.string.general})}} {\memgloref{}}|memjustarg}{768} -\glossaryentry{string.require@ {\memgloterm{string.require}}{\memglodesc{(\ref {string.require})}} {\memgloref{}}|memjustarg}{773} -\glossaryentry{string.cons@ {\memgloterm{string.cons}}{\memglodesc{(\ref {string.cons})}} {\memgloref{}}|memjustarg}{773} -\glossaryentry{string.iterators@ {\memgloterm{string.iterators}}{\memglodesc{(\ref {string.iterators})}} {\memgloref{}}|memjustarg}{775} -\glossaryentry{string.capacity@ {\memgloterm{string.capacity}}{\memglodesc{(\ref {string.capacity})}} {\memgloref{}}|memjustarg}{776} -\glossaryentry{string.access@ {\memgloterm{string.access}}{\memglodesc{(\ref {string.access})}} {\memgloref{}}|memjustarg}{777} -\glossaryentry{string.modifiers@ {\memgloterm{string.modifiers}}{\memglodesc{(\ref {string.modifiers})}} {\memgloref{}}|memjustarg}{777} -\glossaryentry{string.op.append@ {\memgloterm{string.op.append}}{\memglodesc{(\ref {string.op.append})}} {\memgloref{}}|memjustarg}{777} -\glossaryentry{string.append@ {\memgloterm{string.append}}{\memglodesc{(\ref {string.append})}} {\memgloref{}}|memjustarg}{778} -\glossaryentry{string.assign@ {\memgloterm{string.assign}}{\memglodesc{(\ref {string.assign})}} {\memgloref{}}|memjustarg}{779} -\glossaryentry{string.insert@ {\memgloterm{string.insert}}{\memglodesc{(\ref {string.insert})}} {\memgloref{}}|memjustarg}{780} -\glossaryentry{string.erase@ {\memgloterm{string.erase}}{\memglodesc{(\ref {string.erase})}} {\memgloref{}}|memjustarg}{781} -\glossaryentry{string.replace@ {\memgloterm{string.replace}}{\memglodesc{(\ref {string.replace})}} {\memgloref{}}|memjustarg}{781} -\glossaryentry{string.copy@ {\memgloterm{string.copy}}{\memglodesc{(\ref {string.copy})}} {\memgloref{}}|memjustarg}{783} -\glossaryentry{string.swap@ {\memgloterm{string.swap}}{\memglodesc{(\ref {string.swap})}} {\memgloref{}}|memjustarg}{783} -\glossaryentry{string.ops@ {\memgloterm{string.ops}}{\memglodesc{(\ref {string.ops})}} {\memgloref{}}|memjustarg}{783} -\glossaryentry{string.accessors@ {\memgloterm{string.accessors}}{\memglodesc{(\ref {string.accessors})}} {\memgloref{}}|memjustarg}{783} -\glossaryentry{string.find@ {\memgloterm{string.find}}{\memglodesc{(\ref {string.find})}} {\memgloref{}}|memjustarg}{784} -\glossaryentry{string.substr@ {\memgloterm{string.substr}}{\memglodesc{(\ref {string.substr})}} {\memgloref{}}|memjustarg}{785} -\glossaryentry{string.compare@ {\memgloterm{string.compare}}{\memglodesc{(\ref {string.compare})}} {\memgloref{}}|memjustarg}{785} -\glossaryentry{string.starts.with@ {\memgloterm{string.starts.with}}{\memglodesc{(\ref {string.starts.with})}} {\memgloref{}}|memjustarg}{786} -\glossaryentry{string.ends.with@ {\memgloterm{string.ends.with}}{\memglodesc{(\ref {string.ends.with})}} {\memgloref{}}|memjustarg}{786} -\glossaryentry{string.nonmembers@ {\memgloterm{string.nonmembers}}{\memglodesc{(\ref {string.nonmembers})}} {\memgloref{}}|memjustarg}{786} -\glossaryentry{string.op.plus@ {\memgloterm{string.op.plus}}{\memglodesc{(\ref {string.op.plus})}} {\memgloref{}}|memjustarg}{786} -\glossaryentry{string.cmp@ {\memgloterm{string.cmp}}{\memglodesc{(\ref {string.cmp})}} {\memgloref{}}|memjustarg}{787} -\glossaryentry{string.special@ {\memgloterm{string.special}}{\memglodesc{(\ref {string.special})}} {\memgloref{}}|memjustarg}{788} -\glossaryentry{string.io@ {\memgloterm{string.io}}{\memglodesc{(\ref {string.io})}} {\memgloref{}}|memjustarg}{788} -\glossaryentry{string.erasure@ {\memgloterm{string.erasure}}{\memglodesc{(\ref {string.erasure})}} {\memgloref{}}|memjustarg}{789} -\glossaryentry{string.conversions@ {\memgloterm{string.conversions}}{\memglodesc{(\ref {string.conversions})}} {\memgloref{}}|memjustarg}{789} -\glossaryentry{basic.string.hash@ {\memgloterm{basic.string.hash}}{\memglodesc{(\ref {basic.string.hash})}} {\memgloref{}}|memjustarg}{791} -\glossaryentry{basic.string.literals@ {\memgloterm{basic.string.literals}}{\memglodesc{(\ref {basic.string.literals})}} {\memgloref{}}|memjustarg}{791} -\glossaryentry{string.view@ {\memgloterm{string.view}}{\memglodesc{(\ref {string.view})}} {\memgloref{}}|memjustarg}{791} -\glossaryentry{string.view.general@ {\memgloterm{string.view.general}}{\memglodesc{(\ref {string.view.general})}} {\memgloref{}}|memjustarg}{791} -\glossaryentry{string.view.synop@ {\memgloterm{string.view.synop}}{\memglodesc{(\ref {string.view.synop})}} {\memgloref{}}|memjustarg}{791} -\glossaryentry{string.view.template@ {\memgloterm{string.view.template}}{\memglodesc{(\ref {string.view.template})}} {\memgloref{}}|memjustarg}{792} -\glossaryentry{string.view.template.general@ {\memgloterm{string.view.template.general}}{\memglodesc{(\ref {string.view.template.general})}} {\memgloref{}}|memjustarg}{792} -\glossaryentry{string.view.cons@ {\memgloterm{string.view.cons}}{\memglodesc{(\ref {string.view.cons})}} {\memgloref{}}|memjustarg}{794} -\glossaryentry{string.view.iterators@ {\memgloterm{string.view.iterators}}{\memglodesc{(\ref {string.view.iterators})}} {\memgloref{}}|memjustarg}{795} -\glossaryentry{string.view.capacity@ {\memgloterm{string.view.capacity}}{\memglodesc{(\ref {string.view.capacity})}} {\memgloref{}}|memjustarg}{795} -\glossaryentry{string.view.access@ {\memgloterm{string.view.access}}{\memglodesc{(\ref {string.view.access})}} {\memgloref{}}|memjustarg}{796} -\glossaryentry{string.view.modifiers@ {\memgloterm{string.view.modifiers}}{\memglodesc{(\ref {string.view.modifiers})}} {\memgloref{}}|memjustarg}{796} -\glossaryentry{string.view.ops@ {\memgloterm{string.view.ops}}{\memglodesc{(\ref {string.view.ops})}} {\memgloref{}}|memjustarg}{796} -\glossaryentry{string.view.find@ {\memgloterm{string.view.find}}{\memglodesc{(\ref {string.view.find})}} {\memgloref{}}|memjustarg}{798} -\glossaryentry{string.view.deduct@ {\memgloterm{string.view.deduct}}{\memglodesc{(\ref {string.view.deduct})}} {\memgloref{}}|memjustarg}{799} -\glossaryentry{string.view.comparison@ {\memgloterm{string.view.comparison}}{\memglodesc{(\ref {string.view.comparison})}} {\memgloref{}}|memjustarg}{799} -\glossaryentry{string.view.io@ {\memgloterm{string.view.io}}{\memglodesc{(\ref {string.view.io})}} {\memgloref{}}|memjustarg}{800} -\glossaryentry{string.view.hash@ {\memgloterm{string.view.hash}}{\memglodesc{(\ref {string.view.hash})}} {\memgloref{}}|memjustarg}{800} -\glossaryentry{string.view.literals@ {\memgloterm{string.view.literals}}{\memglodesc{(\ref {string.view.literals})}} {\memgloref{}}|memjustarg}{800} -\glossaryentry{c.strings@ {\memgloterm{c.strings}}{\memglodesc{(\ref {c.strings})}} {\memgloref{}}|memjustarg}{800} -\glossaryentry{cctype.syn@ {\memgloterm{cctype.syn}}{\memglodesc{(\ref {cctype.syn})}} {\memgloref{}}|memjustarg}{800} -\glossaryentry{cwctype.syn@ {\memgloterm{cwctype.syn}}{\memglodesc{(\ref {cwctype.syn})}} {\memgloref{}}|memjustarg}{801} -\glossaryentry{cstring.syn@ {\memgloterm{cstring.syn}}{\memglodesc{(\ref {cstring.syn})}} {\memgloref{}}|memjustarg}{801} -\glossaryentry{cwchar.syn@ {\memgloterm{cwchar.syn}}{\memglodesc{(\ref {cwchar.syn})}} {\memgloref{}}|memjustarg}{802} -\glossaryentry{cuchar.syn@ {\memgloterm{cuchar.syn}}{\memglodesc{(\ref {cuchar.syn})}} {\memgloref{}}|memjustarg}{803} -\glossaryentry{c.mb.wcs@ {\memgloterm{c.mb.wcs}}{\memglodesc{(\ref {c.mb.wcs})}} {\memgloref{}}|memjustarg}{804} -\glossaryentry{containers@ {\memgloterm{containers}}{\memglodesc{(\ref {containers})}} {\memgloref{}}|memjustarg}{806} -\glossaryentry{containers.general@ {\memgloterm{containers.general}}{\memglodesc{(\ref {containers.general})}} {\memgloref{}}|memjustarg}{806} -\glossaryentry{container.requirements@ {\memgloterm{container.requirements}}{\memglodesc{(\ref {container.requirements})}} {\memgloref{}}|memjustarg}{806} -\glossaryentry{container.requirements.general@ {\memgloterm{container.requirements.general}}{\memglodesc{(\ref {container.requirements.general})}} {\memgloref{}}|memjustarg}{806} -\glossaryentry{container.requirements.dataraces@ {\memgloterm{container.requirements.dataraces}}{\memglodesc{(\ref {container.requirements.dataraces})}} {\memgloref{}}|memjustarg}{812} -\glossaryentry{sequence.reqmts@ {\memgloterm{sequence.reqmts}}{\memglodesc{(\ref {sequence.reqmts})}} {\memgloref{}}|memjustarg}{812} -\glossaryentry{container.node@ {\memgloterm{container.node}}{\memglodesc{(\ref {container.node})}} {\memgloref{}}|memjustarg}{817} -\glossaryentry{container.node.overview@ {\memgloterm{container.node.overview}}{\memglodesc{(\ref {container.node.overview})}} {\memgloref{}}|memjustarg}{817} -\glossaryentry{container.node.cons@ {\memgloterm{container.node.cons}}{\memglodesc{(\ref {container.node.cons})}} {\memgloref{}}|memjustarg}{818} -\glossaryentry{container.node.dtor@ {\memgloterm{container.node.dtor}}{\memglodesc{(\ref {container.node.dtor})}} {\memgloref{}}|memjustarg}{818} -\glossaryentry{container.node.observers@ {\memgloterm{container.node.observers}}{\memglodesc{(\ref {container.node.observers})}} {\memgloref{}}|memjustarg}{818} -\glossaryentry{container.node.modifiers@ {\memgloterm{container.node.modifiers}}{\memglodesc{(\ref {container.node.modifiers})}} {\memgloref{}}|memjustarg}{819} -\glossaryentry{container.insert.return@ {\memgloterm{container.insert.return}}{\memglodesc{(\ref {container.insert.return})}} {\memgloref{}}|memjustarg}{819} -\glossaryentry{associative.reqmts@ {\memgloterm{associative.reqmts}}{\memglodesc{(\ref {associative.reqmts})}} {\memgloref{}}|memjustarg}{819} -\glossaryentry{associative.reqmts.general@ {\memgloterm{associative.reqmts.general}}{\memglodesc{(\ref {associative.reqmts.general})}} {\memgloref{}}|memjustarg}{819} -\glossaryentry{associative.reqmts.except@ {\memgloterm{associative.reqmts.except}}{\memglodesc{(\ref {associative.reqmts.except})}} {\memgloref{}}|memjustarg}{828} -\glossaryentry{unord.req@ {\memgloterm{unord.req}}{\memglodesc{(\ref {unord.req})}} {\memgloref{}}|memjustarg}{828} -\glossaryentry{unord.req.general@ {\memgloterm{unord.req.general}}{\memglodesc{(\ref {unord.req.general})}} {\memgloref{}}|memjustarg}{828} -\glossaryentry{unord.req.except@ {\memgloterm{unord.req.except}}{\memglodesc{(\ref {unord.req.except})}} {\memgloref{}}|memjustarg}{839} -\glossaryentry{sequences@ {\memgloterm{sequences}}{\memglodesc{(\ref {sequences})}} {\memgloref{}}|memjustarg}{840} -\glossaryentry{sequences.general@ {\memgloterm{sequences.general}}{\memglodesc{(\ref {sequences.general})}} {\memgloref{}}|memjustarg}{840} -\glossaryentry{array.syn@ {\memgloterm{array.syn}}{\memglodesc{(\ref {array.syn})}} {\memgloref{}}|memjustarg}{840} -\glossaryentry{deque.syn@ {\memgloterm{deque.syn}}{\memglodesc{(\ref {deque.syn})}} {\memgloref{}}|memjustarg}{840} -\glossaryentry{forward.list.syn@ {\memgloterm{forward.list.syn}}{\memglodesc{(\ref {forward.list.syn})}} {\memgloref{}}|memjustarg}{841} -\glossaryentry{list.syn@ {\memgloterm{list.syn}}{\memglodesc{(\ref {list.syn})}} {\memgloref{}}|memjustarg}{841} -\glossaryentry{vector.syn@ {\memgloterm{vector.syn}}{\memglodesc{(\ref {vector.syn})}} {\memgloref{}}|memjustarg}{842} -\glossaryentry{array@ {\memgloterm{array}}{\memglodesc{(\ref {array})}} {\memgloref{}}|memjustarg}{842} -\glossaryentry{array.overview@ {\memgloterm{array.overview}}{\memglodesc{(\ref {array.overview})}} {\memgloref{}}|memjustarg}{842} -\glossaryentry{array.cons@ {\memgloterm{array.cons}}{\memglodesc{(\ref {array.cons})}} {\memgloref{}}|memjustarg}{844} -\glossaryentry{array.members@ {\memgloterm{array.members}}{\memglodesc{(\ref {array.members})}} {\memgloref{}}|memjustarg}{844} -\glossaryentry{array.special@ {\memgloterm{array.special}}{\memglodesc{(\ref {array.special})}} {\memgloref{}}|memjustarg}{844} -\glossaryentry{array.zero@ {\memgloterm{array.zero}}{\memglodesc{(\ref {array.zero})}} {\memgloref{}}|memjustarg}{844} -\glossaryentry{array.creation@ {\memgloterm{array.creation}}{\memglodesc{(\ref {array.creation})}} {\memgloref{}}|memjustarg}{844} -\glossaryentry{array.tuple@ {\memgloterm{array.tuple}}{\memglodesc{(\ref {array.tuple})}} {\memgloref{}}|memjustarg}{845} -\glossaryentry{deque@ {\memgloterm{deque}}{\memglodesc{(\ref {deque})}} {\memgloref{}}|memjustarg}{845} -\glossaryentry{deque.overview@ {\memgloterm{deque.overview}}{\memglodesc{(\ref {deque.overview})}} {\memgloref{}}|memjustarg}{845} -\glossaryentry{deque.cons@ {\memgloterm{deque.cons}}{\memglodesc{(\ref {deque.cons})}} {\memgloref{}}|memjustarg}{847} -\glossaryentry{deque.capacity@ {\memgloterm{deque.capacity}}{\memglodesc{(\ref {deque.capacity})}} {\memgloref{}}|memjustarg}{847} -\glossaryentry{deque.modifiers@ {\memgloterm{deque.modifiers}}{\memglodesc{(\ref {deque.modifiers})}} {\memgloref{}}|memjustarg}{848} -\glossaryentry{deque.erasure@ {\memgloterm{deque.erasure}}{\memglodesc{(\ref {deque.erasure})}} {\memgloref{}}|memjustarg}{849} -\glossaryentry{forwardlist@ {\memgloterm{forwardlist}}{\memglodesc{(\ref {forwardlist})}} {\memgloref{}}|memjustarg}{849} -\glossaryentry{forwardlist.overview@ {\memgloterm{forwardlist.overview}}{\memglodesc{(\ref {forwardlist.overview})}} {\memgloref{}}|memjustarg}{849} -\glossaryentry{forwardlist.cons@ {\memgloterm{forwardlist.cons}}{\memglodesc{(\ref {forwardlist.cons})}} {\memgloref{}}|memjustarg}{851} -\glossaryentry{forwardlist.iter@ {\memgloterm{forwardlist.iter}}{\memglodesc{(\ref {forwardlist.iter})}} {\memgloref{}}|memjustarg}{852} -\glossaryentry{forwardlist.access@ {\memgloterm{forwardlist.access}}{\memglodesc{(\ref {forwardlist.access})}} {\memgloref{}}|memjustarg}{852} -\glossaryentry{forwardlist.modifiers@ {\memgloterm{forwardlist.modifiers}}{\memglodesc{(\ref {forwardlist.modifiers})}} {\memgloref{}}|memjustarg}{852} -\glossaryentry{forwardlist.ops@ {\memgloterm{forwardlist.ops}}{\memglodesc{(\ref {forwardlist.ops})}} {\memgloref{}}|memjustarg}{853} -\glossaryentry{forward.list.erasure@ {\memgloterm{forward.list.erasure}}{\memglodesc{(\ref {forward.list.erasure})}} {\memgloref{}}|memjustarg}{855} -\glossaryentry{list@ {\memgloterm{list}}{\memglodesc{(\ref {list})}} {\memgloref{}}|memjustarg}{855} -\glossaryentry{list.overview@ {\memgloterm{list.overview}}{\memglodesc{(\ref {list.overview})}} {\memgloref{}}|memjustarg}{855} -\glossaryentry{list.cons@ {\memgloterm{list.cons}}{\memglodesc{(\ref {list.cons})}} {\memgloref{}}|memjustarg}{858} -\glossaryentry{list.capacity@ {\memgloterm{list.capacity}}{\memglodesc{(\ref {list.capacity})}} {\memgloref{}}|memjustarg}{858} -\glossaryentry{list.modifiers@ {\memgloterm{list.modifiers}}{\memglodesc{(\ref {list.modifiers})}} {\memgloref{}}|memjustarg}{858} -\glossaryentry{list.ops@ {\memgloterm{list.ops}}{\memglodesc{(\ref {list.ops})}} {\memgloref{}}|memjustarg}{859} -\glossaryentry{list.erasure@ {\memgloterm{list.erasure}}{\memglodesc{(\ref {list.erasure})}} {\memgloref{}}|memjustarg}{861} -\glossaryentry{vector@ {\memgloterm{vector}}{\memglodesc{(\ref {vector})}} {\memgloref{}}|memjustarg}{861} -\glossaryentry{vector.overview@ {\memgloterm{vector.overview}}{\memglodesc{(\ref {vector.overview})}} {\memgloref{}}|memjustarg}{861} -\glossaryentry{vector.cons@ {\memgloterm{vector.cons}}{\memglodesc{(\ref {vector.cons})}} {\memgloref{}}|memjustarg}{863} -\glossaryentry{vector.capacity@ {\memgloterm{vector.capacity}}{\memglodesc{(\ref {vector.capacity})}} {\memgloref{}}|memjustarg}{864} -\glossaryentry{vector.data@ {\memgloterm{vector.data}}{\memglodesc{(\ref {vector.data})}} {\memgloref{}}|memjustarg}{865} -\glossaryentry{vector.modifiers@ {\memgloterm{vector.modifiers}}{\memglodesc{(\ref {vector.modifiers})}} {\memgloref{}}|memjustarg}{865} -\glossaryentry{vector.erasure@ {\memgloterm{vector.erasure}}{\memglodesc{(\ref {vector.erasure})}} {\memgloref{}}|memjustarg}{865} -\glossaryentry{vector.bool@ {\memgloterm{vector.bool}}{\memglodesc{(\ref {vector.bool})}} {\memgloref{}}|memjustarg}{866} -\glossaryentry{associative@ {\memgloterm{associative}}{\memglodesc{(\ref {associative})}} {\memgloref{}}|memjustarg}{868} -\glossaryentry{associative.general@ {\memgloterm{associative.general}}{\memglodesc{(\ref {associative.general})}} {\memgloref{}}|memjustarg}{868} -\glossaryentry{associative.map.syn@ {\memgloterm{associative.map.syn}}{\memglodesc{(\ref {associative.map.syn})}} {\memgloref{}}|memjustarg}{868} -\glossaryentry{associative.set.syn@ {\memgloterm{associative.set.syn}}{\memglodesc{(\ref {associative.set.syn})}} {\memgloref{}}|memjustarg}{869} -\glossaryentry{map@ {\memgloterm{map}}{\memglodesc{(\ref {map})}} {\memgloref{}}|memjustarg}{870} -\glossaryentry{map.overview@ {\memgloterm{map.overview}}{\memglodesc{(\ref {map.overview})}} {\memgloref{}}|memjustarg}{870} -\glossaryentry{map.cons@ {\memgloterm{map.cons}}{\memglodesc{(\ref {map.cons})}} {\memgloref{}}|memjustarg}{873} -\glossaryentry{map.access@ {\memgloterm{map.access}}{\memglodesc{(\ref {map.access})}} {\memgloref{}}|memjustarg}{873} -\glossaryentry{map.modifiers@ {\memgloterm{map.modifiers}}{\memglodesc{(\ref {map.modifiers})}} {\memgloref{}}|memjustarg}{874} -\glossaryentry{map.erasure@ {\memgloterm{map.erasure}}{\memglodesc{(\ref {map.erasure})}} {\memgloref{}}|memjustarg}{875} -\glossaryentry{multimap@ {\memgloterm{multimap}}{\memglodesc{(\ref {multimap})}} {\memgloref{}}|memjustarg}{875} -\glossaryentry{multimap.overview@ {\memgloterm{multimap.overview}}{\memglodesc{(\ref {multimap.overview})}} {\memgloref{}}|memjustarg}{875} -\glossaryentry{multimap.cons@ {\memgloterm{multimap.cons}}{\memglodesc{(\ref {multimap.cons})}} {\memgloref{}}|memjustarg}{878} -\glossaryentry{multimap.modifiers@ {\memgloterm{multimap.modifiers}}{\memglodesc{(\ref {multimap.modifiers})}} {\memgloref{}}|memjustarg}{878} -\glossaryentry{multimap.erasure@ {\memgloterm{multimap.erasure}}{\memglodesc{(\ref {multimap.erasure})}} {\memgloref{}}|memjustarg}{879} -\glossaryentry{set@ {\memgloterm{set}}{\memglodesc{(\ref {set})}} {\memgloref{}}|memjustarg}{879} -\glossaryentry{set.overview@ {\memgloterm{set.overview}}{\memglodesc{(\ref {set.overview})}} {\memgloref{}}|memjustarg}{879} -\glossaryentry{set.cons@ {\memgloterm{set.cons}}{\memglodesc{(\ref {set.cons})}} {\memgloref{}}|memjustarg}{882} -\glossaryentry{set.erasure@ {\memgloterm{set.erasure}}{\memglodesc{(\ref {set.erasure})}} {\memgloref{}}|memjustarg}{882} -\glossaryentry{multiset@ {\memgloterm{multiset}}{\memglodesc{(\ref {multiset})}} {\memgloref{}}|memjustarg}{882} -\glossaryentry{multiset.overview@ {\memgloterm{multiset.overview}}{\memglodesc{(\ref {multiset.overview})}} {\memgloref{}}|memjustarg}{882} -\glossaryentry{multiset.cons@ {\memgloterm{multiset.cons}}{\memglodesc{(\ref {multiset.cons})}} {\memgloref{}}|memjustarg}{885} -\glossaryentry{multiset.erasure@ {\memgloterm{multiset.erasure}}{\memglodesc{(\ref {multiset.erasure})}} {\memgloref{}}|memjustarg}{885} -\glossaryentry{unord@ {\memgloterm{unord}}{\memglodesc{(\ref {unord})}} {\memgloref{}}|memjustarg}{885} -\glossaryentry{unord.general@ {\memgloterm{unord.general}}{\memglodesc{(\ref {unord.general})}} {\memgloref{}}|memjustarg}{885} -\glossaryentry{unord.map.syn@ {\memgloterm{unord.map.syn}}{\memglodesc{(\ref {unord.map.syn})}} {\memgloref{}}|memjustarg}{885} -\glossaryentry{unord.set.syn@ {\memgloterm{unord.set.syn}}{\memglodesc{(\ref {unord.set.syn})}} {\memgloref{}}|memjustarg}{887} -\glossaryentry{unord.map@ {\memgloterm{unord.map}}{\memglodesc{(\ref {unord.map})}} {\memgloref{}}|memjustarg}{888} -\glossaryentry{unord.map.overview@ {\memgloterm{unord.map.overview}}{\memglodesc{(\ref {unord.map.overview})}} {\memgloref{}}|memjustarg}{888} -\glossaryentry{unord.map.cnstr@ {\memgloterm{unord.map.cnstr}}{\memglodesc{(\ref {unord.map.cnstr})}} {\memgloref{}}|memjustarg}{892} -\glossaryentry{unord.map.elem@ {\memgloterm{unord.map.elem}}{\memglodesc{(\ref {unord.map.elem})}} {\memgloref{}}|memjustarg}{892} -\glossaryentry{unord.map.modifiers@ {\memgloterm{unord.map.modifiers}}{\memglodesc{(\ref {unord.map.modifiers})}} {\memgloref{}}|memjustarg}{892} -\glossaryentry{unord.map.erasure@ {\memgloterm{unord.map.erasure}}{\memglodesc{(\ref {unord.map.erasure})}} {\memgloref{}}|memjustarg}{894} -\glossaryentry{unord.multimap@ {\memgloterm{unord.multimap}}{\memglodesc{(\ref {unord.multimap})}} {\memgloref{}}|memjustarg}{894} -\glossaryentry{unord.multimap.overview@ {\memgloterm{unord.multimap.overview}}{\memglodesc{(\ref {unord.multimap.overview})}} {\memgloref{}}|memjustarg}{894} -\glossaryentry{unord.multimap.cnstr@ {\memgloterm{unord.multimap.cnstr}}{\memglodesc{(\ref {unord.multimap.cnstr})}} {\memgloref{}}|memjustarg}{898} -\glossaryentry{unord.multimap.modifiers@ {\memgloterm{unord.multimap.modifiers}}{\memglodesc{(\ref {unord.multimap.modifiers})}} {\memgloref{}}|memjustarg}{898} -\glossaryentry{unord.multimap.erasure@ {\memgloterm{unord.multimap.erasure}}{\memglodesc{(\ref {unord.multimap.erasure})}} {\memgloref{}}|memjustarg}{898} -\glossaryentry{unord.set@ {\memgloterm{unord.set}}{\memglodesc{(\ref {unord.set})}} {\memgloref{}}|memjustarg}{899} -\glossaryentry{unord.set.overview@ {\memgloterm{unord.set.overview}}{\memglodesc{(\ref {unord.set.overview})}} {\memgloref{}}|memjustarg}{899} -\glossaryentry{unord.set.cnstr@ {\memgloterm{unord.set.cnstr}}{\memglodesc{(\ref {unord.set.cnstr})}} {\memgloref{}}|memjustarg}{902} -\glossaryentry{unord.set.erasure@ {\memgloterm{unord.set.erasure}}{\memglodesc{(\ref {unord.set.erasure})}} {\memgloref{}}|memjustarg}{903} -\glossaryentry{unord.multiset@ {\memgloterm{unord.multiset}}{\memglodesc{(\ref {unord.multiset})}} {\memgloref{}}|memjustarg}{903} -\glossaryentry{unord.multiset.overview@ {\memgloterm{unord.multiset.overview}}{\memglodesc{(\ref {unord.multiset.overview})}} {\memgloref{}}|memjustarg}{903} -\glossaryentry{unord.multiset.cnstr@ {\memgloterm{unord.multiset.cnstr}}{\memglodesc{(\ref {unord.multiset.cnstr})}} {\memgloref{}}|memjustarg}{906} -\glossaryentry{unord.multiset.erasure@ {\memgloterm{unord.multiset.erasure}}{\memglodesc{(\ref {unord.multiset.erasure})}} {\memgloref{}}|memjustarg}{907} -\glossaryentry{container.adaptors@ {\memgloterm{container.adaptors}}{\memglodesc{(\ref {container.adaptors})}} {\memgloref{}}|memjustarg}{907} -\glossaryentry{container.adaptors.general@ {\memgloterm{container.adaptors.general}}{\memglodesc{(\ref {container.adaptors.general})}} {\memgloref{}}|memjustarg}{907} -\glossaryentry{queue.syn@ {\memgloterm{queue.syn}}{\memglodesc{(\ref {queue.syn})}} {\memgloref{}}|memjustarg}{908} -\glossaryentry{stack.syn@ {\memgloterm{stack.syn}}{\memglodesc{(\ref {stack.syn})}} {\memgloref{}}|memjustarg}{908} -\glossaryentry{queue@ {\memgloterm{queue}}{\memglodesc{(\ref {queue})}} {\memgloref{}}|memjustarg}{909} -\glossaryentry{queue.defn@ {\memgloterm{queue.defn}}{\memglodesc{(\ref {queue.defn})}} {\memgloref{}}|memjustarg}{909} -\glossaryentry{queue.cons@ {\memgloterm{queue.cons}}{\memglodesc{(\ref {queue.cons})}} {\memgloref{}}|memjustarg}{910} -\glossaryentry{queue.cons.alloc@ {\memgloterm{queue.cons.alloc}}{\memglodesc{(\ref {queue.cons.alloc})}} {\memgloref{}}|memjustarg}{910} -\glossaryentry{queue.ops@ {\memgloterm{queue.ops}}{\memglodesc{(\ref {queue.ops})}} {\memgloref{}}|memjustarg}{910} -\glossaryentry{queue.special@ {\memgloterm{queue.special}}{\memglodesc{(\ref {queue.special})}} {\memgloref{}}|memjustarg}{911} -\glossaryentry{priority.queue@ {\memgloterm{priority.queue}}{\memglodesc{(\ref {priority.queue})}} {\memgloref{}}|memjustarg}{911} -\glossaryentry{priqueue.overview@ {\memgloterm{priqueue.overview}}{\memglodesc{(\ref {priqueue.overview})}} {\memgloref{}}|memjustarg}{911} -\glossaryentry{priqueue.cons@ {\memgloterm{priqueue.cons}}{\memglodesc{(\ref {priqueue.cons})}} {\memgloref{}}|memjustarg}{912} -\glossaryentry{priqueue.cons.alloc@ {\memgloterm{priqueue.cons.alloc}}{\memglodesc{(\ref {priqueue.cons.alloc})}} {\memgloref{}}|memjustarg}{912} -\glossaryentry{priqueue.members@ {\memgloterm{priqueue.members}}{\memglodesc{(\ref {priqueue.members})}} {\memgloref{}}|memjustarg}{913} -\glossaryentry{priqueue.special@ {\memgloterm{priqueue.special}}{\memglodesc{(\ref {priqueue.special})}} {\memgloref{}}|memjustarg}{913} -\glossaryentry{stack@ {\memgloterm{stack}}{\memglodesc{(\ref {stack})}} {\memgloref{}}|memjustarg}{913} -\glossaryentry{stack.general@ {\memgloterm{stack.general}}{\memglodesc{(\ref {stack.general})}} {\memgloref{}}|memjustarg}{913} -\glossaryentry{stack.defn@ {\memgloterm{stack.defn}}{\memglodesc{(\ref {stack.defn})}} {\memgloref{}}|memjustarg}{913} -\glossaryentry{stack.cons@ {\memgloterm{stack.cons}}{\memglodesc{(\ref {stack.cons})}} {\memgloref{}}|memjustarg}{914} -\glossaryentry{stack.cons.alloc@ {\memgloterm{stack.cons.alloc}}{\memglodesc{(\ref {stack.cons.alloc})}} {\memgloref{}}|memjustarg}{914} -\glossaryentry{stack.ops@ {\memgloterm{stack.ops}}{\memglodesc{(\ref {stack.ops})}} {\memgloref{}}|memjustarg}{915} -\glossaryentry{stack.special@ {\memgloterm{stack.special}}{\memglodesc{(\ref {stack.special})}} {\memgloref{}}|memjustarg}{915} -\glossaryentry{views@ {\memgloterm{views}}{\memglodesc{(\ref {views})}} {\memgloref{}}|memjustarg}{915} -\glossaryentry{views.general@ {\memgloterm{views.general}}{\memglodesc{(\ref {views.general})}} {\memgloref{}}|memjustarg}{915} -\glossaryentry{span.syn@ {\memgloterm{span.syn}}{\memglodesc{(\ref {span.syn})}} {\memgloref{}}|memjustarg}{915} -\glossaryentry{views.span@ {\memgloterm{views.span}}{\memglodesc{(\ref {views.span})}} {\memgloref{}}|memjustarg}{916} -\glossaryentry{span.overview@ {\memgloterm{span.overview}}{\memglodesc{(\ref {span.overview})}} {\memgloref{}}|memjustarg}{916} -\glossaryentry{span.cons@ {\memgloterm{span.cons}}{\memglodesc{(\ref {span.cons})}} {\memgloref{}}|memjustarg}{917} -\glossaryentry{span.deduct@ {\memgloterm{span.deduct}}{\memglodesc{(\ref {span.deduct})}} {\memgloref{}}|memjustarg}{919} -\glossaryentry{span.sub@ {\memgloterm{span.sub}}{\memglodesc{(\ref {span.sub})}} {\memgloref{}}|memjustarg}{919} -\glossaryentry{span.obs@ {\memgloterm{span.obs}}{\memglodesc{(\ref {span.obs})}} {\memgloref{}}|memjustarg}{920} -\glossaryentry{span.elem@ {\memgloterm{span.elem}}{\memglodesc{(\ref {span.elem})}} {\memgloref{}}|memjustarg}{920} -\glossaryentry{span.iterators@ {\memgloterm{span.iterators}}{\memglodesc{(\ref {span.iterators})}} {\memgloref{}}|memjustarg}{921} -\glossaryentry{span.objectrep@ {\memgloterm{span.objectrep}}{\memglodesc{(\ref {span.objectrep})}} {\memgloref{}}|memjustarg}{921} -\glossaryentry{iterators@ {\memgloterm{iterators}}{\memglodesc{(\ref {iterators})}} {\memgloref{}}|memjustarg}{922} -\glossaryentry{iterators.general@ {\memgloterm{iterators.general}}{\memglodesc{(\ref {iterators.general})}} {\memgloref{}}|memjustarg}{922} -\glossaryentry{iterator.synopsis@ {\memgloterm{iterator.synopsis}}{\memglodesc{(\ref {iterator.synopsis})}} {\memgloref{}}|memjustarg}{922} -\glossaryentry{iterator.requirements@ {\memgloterm{iterator.requirements}}{\memglodesc{(\ref {iterator.requirements})}} {\memgloref{}}|memjustarg}{929} -\glossaryentry{iterator.requirements.general@ {\memgloterm{iterator.requirements.general}}{\memglodesc{(\ref {iterator.requirements.general})}} {\memgloref{}}|memjustarg}{929} -\glossaryentry{iterator.assoc.types@ {\memgloterm{iterator.assoc.types}}{\memglodesc{(\ref {iterator.assoc.types})}} {\memgloref{}}|memjustarg}{930} -\glossaryentry{incrementable.traits@ {\memgloterm{incrementable.traits}}{\memglodesc{(\ref {incrementable.traits})}} {\memgloref{}}|memjustarg}{930} -\glossaryentry{readable.traits@ {\memgloterm{readable.traits}}{\memglodesc{(\ref {readable.traits})}} {\memgloref{}}|memjustarg}{931} -\glossaryentry{iterator.traits@ {\memgloterm{iterator.traits}}{\memglodesc{(\ref {iterator.traits})}} {\memgloref{}}|memjustarg}{932} -\glossaryentry{iterator.cust@ {\memgloterm{iterator.cust}}{\memglodesc{(\ref {iterator.cust})}} {\memgloref{}}|memjustarg}{934} -\glossaryentry{iterator.cust.move@ {\memgloterm{iterator.cust.move}}{\memglodesc{(\ref {iterator.cust.move})}} {\memgloref{}}|memjustarg}{934} -\glossaryentry{iterator.cust.swap@ {\memgloterm{iterator.cust.swap}}{\memglodesc{(\ref {iterator.cust.swap})}} {\memgloref{}}|memjustarg}{934} -\glossaryentry{iterator.concepts@ {\memgloterm{iterator.concepts}}{\memglodesc{(\ref {iterator.concepts})}} {\memgloref{}}|memjustarg}{935} -\glossaryentry{iterator.concepts.general@ {\memgloterm{iterator.concepts.general}}{\memglodesc{(\ref {iterator.concepts.general})}} {\memgloref{}}|memjustarg}{935} -\glossaryentry{iterator.concept.readable@ {\memgloterm{iterator.concept.readable}}{\memglodesc{(\ref {iterator.concept.readable})}} {\memgloref{}}|memjustarg}{936} -\glossaryentry{iterator.concept.writable@ {\memgloterm{iterator.concept.writable}}{\memglodesc{(\ref {iterator.concept.writable})}} {\memgloref{}}|memjustarg}{936} -\glossaryentry{iterator.concept.winc@ {\memgloterm{iterator.concept.winc}}{\memglodesc{(\ref {iterator.concept.winc})}} {\memgloref{}}|memjustarg}{936} -\glossaryentry{iterator.concept.inc@ {\memgloterm{iterator.concept.inc}}{\memglodesc{(\ref {iterator.concept.inc})}} {\memgloref{}}|memjustarg}{938} -\glossaryentry{iterator.concept.iterator@ {\memgloterm{iterator.concept.iterator}}{\memglodesc{(\ref {iterator.concept.iterator})}} {\memgloref{}}|memjustarg}{938} -\glossaryentry{iterator.concept.sentinel@ {\memgloterm{iterator.concept.sentinel}}{\memglodesc{(\ref {iterator.concept.sentinel})}} {\memgloref{}}|memjustarg}{938} -\glossaryentry{iterator.concept.sizedsentinel@ {\memgloterm{iterator.concept.sizedsentinel}}{\memglodesc{(\ref {iterator.concept.sizedsentinel})}} {\memgloref{}}|memjustarg}{939} -\glossaryentry{iterator.concept.input@ {\memgloterm{iterator.concept.input}}{\memglodesc{(\ref {iterator.concept.input})}} {\memgloref{}}|memjustarg}{939} -\glossaryentry{iterator.concept.output@ {\memgloterm{iterator.concept.output}}{\memglodesc{(\ref {iterator.concept.output})}} {\memgloref{}}|memjustarg}{939} -\glossaryentry{iterator.concept.forward@ {\memgloterm{iterator.concept.forward}}{\memglodesc{(\ref {iterator.concept.forward})}} {\memgloref{}}|memjustarg}{940} -\glossaryentry{iterator.concept.bidir@ {\memgloterm{iterator.concept.bidir}}{\memglodesc{(\ref {iterator.concept.bidir})}} {\memgloref{}}|memjustarg}{940} -\glossaryentry{iterator.concept.random.access@ {\memgloterm{iterator.concept.random.access}}{\memglodesc{(\ref {iterator.concept.random.access})}} {\memgloref{}}|memjustarg}{941} -\glossaryentry{iterator.concept.contiguous@ {\memgloterm{iterator.concept.contiguous}}{\memglodesc{(\ref {iterator.concept.contiguous})}} {\memgloref{}}|memjustarg}{941} -\glossaryentry{iterator.cpp17@ {\memgloterm{iterator.cpp17}}{\memglodesc{(\ref {iterator.cpp17})}} {\memgloref{}}|memjustarg}{942} -\glossaryentry{iterator.cpp17.general@ {\memgloterm{iterator.cpp17.general}}{\memglodesc{(\ref {iterator.cpp17.general})}} {\memgloref{}}|memjustarg}{942} -\glossaryentry{iterator.iterators@ {\memgloterm{iterator.iterators}}{\memglodesc{(\ref {iterator.iterators})}} {\memgloref{}}|memjustarg}{942} -\glossaryentry{input.iterators@ {\memgloterm{input.iterators}}{\memglodesc{(\ref {input.iterators})}} {\memgloref{}}|memjustarg}{942} -\glossaryentry{output.iterators@ {\memgloterm{output.iterators}}{\memglodesc{(\ref {output.iterators})}} {\memgloref{}}|memjustarg}{943} -\glossaryentry{forward.iterators@ {\memgloterm{forward.iterators}}{\memglodesc{(\ref {forward.iterators})}} {\memgloref{}}|memjustarg}{944} -\glossaryentry{bidirectional.iterators@ {\memgloterm{bidirectional.iterators}}{\memglodesc{(\ref {bidirectional.iterators})}} {\memgloref{}}|memjustarg}{944} -\glossaryentry{random.access.iterators@ {\memgloterm{random.access.iterators}}{\memglodesc{(\ref {random.access.iterators})}} {\memgloref{}}|memjustarg}{944} -\glossaryentry{indirectcallable@ {\memgloterm{indirectcallable}}{\memglodesc{(\ref {indirectcallable})}} {\memgloref{}}|memjustarg}{946} -\glossaryentry{indirectcallable.general@ {\memgloterm{indirectcallable.general}}{\memglodesc{(\ref {indirectcallable.general})}} {\memgloref{}}|memjustarg}{946} -\glossaryentry{indirectcallable.indirectinvocable@ {\memgloterm{indirectcallable.indirectinvocable}}{\memglodesc{(\ref {indirectcallable.indirectinvocable})}} {\memgloref{}}|memjustarg}{946} -\glossaryentry{projected@ {\memgloterm{projected}}{\memglodesc{(\ref {projected})}} {\memgloref{}}|memjustarg}{947} -\glossaryentry{alg.req@ {\memgloterm{alg.req}}{\memglodesc{(\ref {alg.req})}} {\memgloref{}}|memjustarg}{947} -\glossaryentry{alg.req.general@ {\memgloterm{alg.req.general}}{\memglodesc{(\ref {alg.req.general})}} {\memgloref{}}|memjustarg}{947} -\glossaryentry{alg.req.ind.move@ {\memgloterm{alg.req.ind.move}}{\memglodesc{(\ref {alg.req.ind.move})}} {\memgloref{}}|memjustarg}{947} -\glossaryentry{alg.req.ind.copy@ {\memgloterm{alg.req.ind.copy}}{\memglodesc{(\ref {alg.req.ind.copy})}} {\memgloref{}}|memjustarg}{948} -\glossaryentry{alg.req.ind.swap@ {\memgloterm{alg.req.ind.swap}}{\memglodesc{(\ref {alg.req.ind.swap})}} {\memgloref{}}|memjustarg}{948} -\glossaryentry{alg.req.ind.cmp@ {\memgloterm{alg.req.ind.cmp}}{\memglodesc{(\ref {alg.req.ind.cmp})}} {\memgloref{}}|memjustarg}{948} -\glossaryentry{alg.req.permutable@ {\memgloterm{alg.req.permutable}}{\memglodesc{(\ref {alg.req.permutable})}} {\memgloref{}}|memjustarg}{948} -\glossaryentry{alg.req.mergeable@ {\memgloterm{alg.req.mergeable}}{\memglodesc{(\ref {alg.req.mergeable})}} {\memgloref{}}|memjustarg}{949} -\glossaryentry{alg.req.sortable@ {\memgloterm{alg.req.sortable}}{\memglodesc{(\ref {alg.req.sortable})}} {\memgloref{}}|memjustarg}{949} -\glossaryentry{iterator.primitives@ {\memgloterm{iterator.primitives}}{\memglodesc{(\ref {iterator.primitives})}} {\memgloref{}}|memjustarg}{949} -\glossaryentry{iterator.primitives.general@ {\memgloterm{iterator.primitives.general}}{\memglodesc{(\ref {iterator.primitives.general})}} {\memgloref{}}|memjustarg}{949} -\glossaryentry{std.iterator.tags@ {\memgloterm{std.iterator.tags}}{\memglodesc{(\ref {std.iterator.tags})}} {\memgloref{}}|memjustarg}{949} -\glossaryentry{iterator.operations@ {\memgloterm{iterator.operations}}{\memglodesc{(\ref {iterator.operations})}} {\memgloref{}}|memjustarg}{950} -\glossaryentry{range.iter.ops@ {\memgloterm{range.iter.ops}}{\memglodesc{(\ref {range.iter.ops})}} {\memgloref{}}|memjustarg}{950} -\glossaryentry{range.iter.ops.general@ {\memgloterm{range.iter.ops.general}}{\memglodesc{(\ref {range.iter.ops.general})}} {\memgloref{}}|memjustarg}{950} -\glossaryentry{range.iter.op.advance@ {\memgloterm{range.iter.op.advance}}{\memglodesc{(\ref {range.iter.op.advance})}} {\memgloref{}}|memjustarg}{951} -\glossaryentry{range.iter.op.distance@ {\memgloterm{range.iter.op.distance}}{\memglodesc{(\ref {range.iter.op.distance})}} {\memgloref{}}|memjustarg}{952} -\glossaryentry{range.iter.op.next@ {\memgloterm{range.iter.op.next}}{\memglodesc{(\ref {range.iter.op.next})}} {\memgloref{}}|memjustarg}{952} -\glossaryentry{range.iter.op.prev@ {\memgloterm{range.iter.op.prev}}{\memglodesc{(\ref {range.iter.op.prev})}} {\memgloref{}}|memjustarg}{952} -\glossaryentry{predef.iterators@ {\memgloterm{predef.iterators}}{\memglodesc{(\ref {predef.iterators})}} {\memgloref{}}|memjustarg}{952} -\glossaryentry{reverse.iterators@ {\memgloterm{reverse.iterators}}{\memglodesc{(\ref {reverse.iterators})}} {\memgloref{}}|memjustarg}{952} -\glossaryentry{reverse.iterators.general@ {\memgloterm{reverse.iterators.general}}{\memglodesc{(\ref {reverse.iterators.general})}} {\memgloref{}}|memjustarg}{952} -\glossaryentry{reverse.iterator@ {\memgloterm{reverse.iterator}}{\memglodesc{(\ref {reverse.iterator})}} {\memgloref{}}|memjustarg}{953} -\glossaryentry{reverse.iter.requirements@ {\memgloterm{reverse.iter.requirements}}{\memglodesc{(\ref {reverse.iter.requirements})}} {\memgloref{}}|memjustarg}{953} -\glossaryentry{reverse.iter.cons@ {\memgloterm{reverse.iter.cons}}{\memglodesc{(\ref {reverse.iter.cons})}} {\memgloref{}}|memjustarg}{954} -\glossaryentry{reverse.iter.conv@ {\memgloterm{reverse.iter.conv}}{\memglodesc{(\ref {reverse.iter.conv})}} {\memgloref{}}|memjustarg}{954} -\glossaryentry{reverse.iter.elem@ {\memgloterm{reverse.iter.elem}}{\memglodesc{(\ref {reverse.iter.elem})}} {\memgloref{}}|memjustarg}{954} -\glossaryentry{reverse.iter.nav@ {\memgloterm{reverse.iter.nav}}{\memglodesc{(\ref {reverse.iter.nav})}} {\memgloref{}}|memjustarg}{954} -\glossaryentry{reverse.iter.cmp@ {\memgloterm{reverse.iter.cmp}}{\memglodesc{(\ref {reverse.iter.cmp})}} {\memgloref{}}|memjustarg}{955} -\glossaryentry{reverse.iter.nonmember@ {\memgloterm{reverse.iter.nonmember}}{\memglodesc{(\ref {reverse.iter.nonmember})}} {\memgloref{}}|memjustarg}{956} -\glossaryentry{insert.iterators@ {\memgloterm{insert.iterators}}{\memglodesc{(\ref {insert.iterators})}} {\memgloref{}}|memjustarg}{957} -\glossaryentry{insert.iterators.general@ {\memgloterm{insert.iterators.general}}{\memglodesc{(\ref {insert.iterators.general})}} {\memgloref{}}|memjustarg}{957} -\glossaryentry{back.insert.iterator@ {\memgloterm{back.insert.iterator}}{\memglodesc{(\ref {back.insert.iterator})}} {\memgloref{}}|memjustarg}{957} -\glossaryentry{back.insert.iter.ops@ {\memgloterm{back.insert.iter.ops}}{\memglodesc{(\ref {back.insert.iter.ops})}} {\memgloref{}}|memjustarg}{957} -\glossaryentry{back.inserter@ {\memgloterm{back.inserter}}{\memglodesc{(\ref {back.inserter})}} {\memgloref{}}|memjustarg}{958} -\glossaryentry{front.insert.iterator@ {\memgloterm{front.insert.iterator}}{\memglodesc{(\ref {front.insert.iterator})}} {\memgloref{}}|memjustarg}{958} -\glossaryentry{front.insert.iter.ops@ {\memgloterm{front.insert.iter.ops}}{\memglodesc{(\ref {front.insert.iter.ops})}} {\memgloref{}}|memjustarg}{958} -\glossaryentry{front.inserter@ {\memgloterm{front.inserter}}{\memglodesc{(\ref {front.inserter})}} {\memgloref{}}|memjustarg}{958} -\glossaryentry{insert.iterator@ {\memgloterm{insert.iterator}}{\memglodesc{(\ref {insert.iterator})}} {\memgloref{}}|memjustarg}{959} -\glossaryentry{insert.iter.ops@ {\memgloterm{insert.iter.ops}}{\memglodesc{(\ref {insert.iter.ops})}} {\memgloref{}}|memjustarg}{959} -\glossaryentry{inserter@ {\memgloterm{inserter}}{\memglodesc{(\ref {inserter})}} {\memgloref{}}|memjustarg}{959} -\glossaryentry{move.iterators@ {\memgloterm{move.iterators}}{\memglodesc{(\ref {move.iterators})}} {\memgloref{}}|memjustarg}{960} -\glossaryentry{move.iterators.general@ {\memgloterm{move.iterators.general}}{\memglodesc{(\ref {move.iterators.general})}} {\memgloref{}}|memjustarg}{960} -\glossaryentry{move.iterator@ {\memgloterm{move.iterator}}{\memglodesc{(\ref {move.iterator})}} {\memgloref{}}|memjustarg}{960} -\glossaryentry{move.iter.requirements@ {\memgloterm{move.iter.requirements}}{\memglodesc{(\ref {move.iter.requirements})}} {\memgloref{}}|memjustarg}{961} -\glossaryentry{move.iter.cons@ {\memgloterm{move.iter.cons}}{\memglodesc{(\ref {move.iter.cons})}} {\memgloref{}}|memjustarg}{961} -\glossaryentry{move.iter.op.conv@ {\memgloterm{move.iter.op.conv}}{\memglodesc{(\ref {move.iter.op.conv})}} {\memgloref{}}|memjustarg}{961} -\glossaryentry{move.iter.elem@ {\memgloterm{move.iter.elem}}{\memglodesc{(\ref {move.iter.elem})}} {\memgloref{}}|memjustarg}{961} -\glossaryentry{move.iter.nav@ {\memgloterm{move.iter.nav}}{\memglodesc{(\ref {move.iter.nav})}} {\memgloref{}}|memjustarg}{962} -\glossaryentry{move.iter.op.comp@ {\memgloterm{move.iter.op.comp}}{\memglodesc{(\ref {move.iter.op.comp})}} {\memgloref{}}|memjustarg}{962} -\glossaryentry{move.iter.nonmember@ {\memgloterm{move.iter.nonmember}}{\memglodesc{(\ref {move.iter.nonmember})}} {\memgloref{}}|memjustarg}{963} -\glossaryentry{move.sentinel@ {\memgloterm{move.sentinel}}{\memglodesc{(\ref {move.sentinel})}} {\memgloref{}}|memjustarg}{963} -\glossaryentry{move.sent.ops@ {\memgloterm{move.sent.ops}}{\memglodesc{(\ref {move.sent.ops})}} {\memgloref{}}|memjustarg}{964} -\glossaryentry{iterators.common@ {\memgloterm{iterators.common}}{\memglodesc{(\ref {iterators.common})}} {\memgloref{}}|memjustarg}{964} -\glossaryentry{common.iterator@ {\memgloterm{common.iterator}}{\memglodesc{(\ref {common.iterator})}} {\memgloref{}}|memjustarg}{964} -\glossaryentry{common.iter.types@ {\memgloterm{common.iter.types}}{\memglodesc{(\ref {common.iter.types})}} {\memgloref{}}|memjustarg}{966} -\glossaryentry{common.iter.const@ {\memgloterm{common.iter.const}}{\memglodesc{(\ref {common.iter.const})}} {\memgloref{}}|memjustarg}{966} -\glossaryentry{common.iter.access@ {\memgloterm{common.iter.access}}{\memglodesc{(\ref {common.iter.access})}} {\memgloref{}}|memjustarg}{966} -\glossaryentry{common.iter.nav@ {\memgloterm{common.iter.nav}}{\memglodesc{(\ref {common.iter.nav})}} {\memgloref{}}|memjustarg}{967} -\glossaryentry{common.iter.cmp@ {\memgloterm{common.iter.cmp}}{\memglodesc{(\ref {common.iter.cmp})}} {\memgloref{}}|memjustarg}{967} -\glossaryentry{common.iter.cust@ {\memgloterm{common.iter.cust}}{\memglodesc{(\ref {common.iter.cust})}} {\memgloref{}}|memjustarg}{968} -\glossaryentry{default.sentinel@ {\memgloterm{default.sentinel}}{\memglodesc{(\ref {default.sentinel})}} {\memgloref{}}|memjustarg}{968} -\glossaryentry{iterators.counted@ {\memgloterm{iterators.counted}}{\memglodesc{(\ref {iterators.counted})}} {\memgloref{}}|memjustarg}{968} -\glossaryentry{counted.iterator@ {\memgloterm{counted.iterator}}{\memglodesc{(\ref {counted.iterator})}} {\memgloref{}}|memjustarg}{968} -\glossaryentry{counted.iter.const@ {\memgloterm{counted.iter.const}}{\memglodesc{(\ref {counted.iter.const})}} {\memgloref{}}|memjustarg}{970} -\glossaryentry{counted.iter.access@ {\memgloterm{counted.iter.access}}{\memglodesc{(\ref {counted.iter.access})}} {\memgloref{}}|memjustarg}{970} -\glossaryentry{counted.iter.elem@ {\memgloterm{counted.iter.elem}}{\memglodesc{(\ref {counted.iter.elem})}} {\memgloref{}}|memjustarg}{970} -\glossaryentry{counted.iter.nav@ {\memgloterm{counted.iter.nav}}{\memglodesc{(\ref {counted.iter.nav})}} {\memgloref{}}|memjustarg}{971} -\glossaryentry{counted.iter.cmp@ {\memgloterm{counted.iter.cmp}}{\memglodesc{(\ref {counted.iter.cmp})}} {\memgloref{}}|memjustarg}{972} -\glossaryentry{counted.iter.cust@ {\memgloterm{counted.iter.cust}}{\memglodesc{(\ref {counted.iter.cust})}} {\memgloref{}}|memjustarg}{972} -\glossaryentry{unreachable.sentinel@ {\memgloterm{unreachable.sentinel}}{\memglodesc{(\ref {unreachable.sentinel})}} {\memgloref{}}|memjustarg}{973} -\glossaryentry{stream.iterators@ {\memgloterm{stream.iterators}}{\memglodesc{(\ref {stream.iterators})}} {\memgloref{}}|memjustarg}{973} -\glossaryentry{stream.iterators.general@ {\memgloterm{stream.iterators.general}}{\memglodesc{(\ref {stream.iterators.general})}} {\memgloref{}}|memjustarg}{973} -\glossaryentry{istream.iterator@ {\memgloterm{istream.iterator}}{\memglodesc{(\ref {istream.iterator})}} {\memgloref{}}|memjustarg}{973} -\glossaryentry{istream.iterator.general@ {\memgloterm{istream.iterator.general}}{\memglodesc{(\ref {istream.iterator.general})}} {\memgloref{}}|memjustarg}{973} -\glossaryentry{istream.iterator.cons@ {\memgloterm{istream.iterator.cons}}{\memglodesc{(\ref {istream.iterator.cons})}} {\memgloref{}}|memjustarg}{974} -\glossaryentry{istream.iterator.ops@ {\memgloterm{istream.iterator.ops}}{\memglodesc{(\ref {istream.iterator.ops})}} {\memgloref{}}|memjustarg}{974} -\glossaryentry{ostream.iterator@ {\memgloterm{ostream.iterator}}{\memglodesc{(\ref {ostream.iterator})}} {\memgloref{}}|memjustarg}{975} -\glossaryentry{ostream.iterator.general@ {\memgloterm{ostream.iterator.general}}{\memglodesc{(\ref {ostream.iterator.general})}} {\memgloref{}}|memjustarg}{975} -\glossaryentry{ostream.iterator.cons.des@ {\memgloterm{ostream.iterator.cons.des}}{\memglodesc{(\ref {ostream.iterator.cons.des})}} {\memgloref{}}|memjustarg}{975} -\glossaryentry{ostream.iterator.ops@ {\memgloterm{ostream.iterator.ops}}{\memglodesc{(\ref {ostream.iterator.ops})}} {\memgloref{}}|memjustarg}{975} -\glossaryentry{istreambuf.iterator@ {\memgloterm{istreambuf.iterator}}{\memglodesc{(\ref {istreambuf.iterator})}} {\memgloref{}}|memjustarg}{976} -\glossaryentry{istreambuf.iterator.general@ {\memgloterm{istreambuf.iterator.general}}{\memglodesc{(\ref {istreambuf.iterator.general})}} {\memgloref{}}|memjustarg}{976} -\glossaryentry{istreambuf.iterator.proxy@ {\memgloterm{istreambuf.iterator.proxy}}{\memglodesc{(\ref {istreambuf.iterator.proxy})}} {\memgloref{}}|memjustarg}{976} -\glossaryentry{istreambuf.iterator.cons@ {\memgloterm{istreambuf.iterator.cons}}{\memglodesc{(\ref {istreambuf.iterator.cons})}} {\memgloref{}}|memjustarg}{977} -\glossaryentry{istreambuf.iterator.ops@ {\memgloterm{istreambuf.iterator.ops}}{\memglodesc{(\ref {istreambuf.iterator.ops})}} {\memgloref{}}|memjustarg}{977} -\glossaryentry{ostreambuf.iterator@ {\memgloterm{ostreambuf.iterator}}{\memglodesc{(\ref {ostreambuf.iterator})}} {\memgloref{}}|memjustarg}{977} -\glossaryentry{ostreambuf.iterator.general@ {\memgloterm{ostreambuf.iterator.general}}{\memglodesc{(\ref {ostreambuf.iterator.general})}} {\memgloref{}}|memjustarg}{977} -\glossaryentry{ostreambuf.iter.cons@ {\memgloterm{ostreambuf.iter.cons}}{\memglodesc{(\ref {ostreambuf.iter.cons})}} {\memgloref{}}|memjustarg}{978} -\glossaryentry{ostreambuf.iter.ops@ {\memgloterm{ostreambuf.iter.ops}}{\memglodesc{(\ref {ostreambuf.iter.ops})}} {\memgloref{}}|memjustarg}{978} -\glossaryentry{iterator.range@ {\memgloterm{iterator.range}}{\memglodesc{(\ref {iterator.range})}} {\memgloref{}}|memjustarg}{978} -\glossaryentry{ranges@ {\memgloterm{ranges}}{\memglodesc{(\ref {ranges})}} {\memgloref{}}|memjustarg}{981} -\glossaryentry{ranges.general@ {\memgloterm{ranges.general}}{\memglodesc{(\ref {ranges.general})}} {\memgloref{}}|memjustarg}{981} -\glossaryentry{ranges.syn@ {\memgloterm{ranges.syn}}{\memglodesc{(\ref {ranges.syn})}} {\memgloref{}}|memjustarg}{981} -\glossaryentry{range.access@ {\memgloterm{range.access}}{\memglodesc{(\ref {range.access})}} {\memgloref{}}|memjustarg}{986} -\glossaryentry{range.access.general@ {\memgloterm{range.access.general}}{\memglodesc{(\ref {range.access.general})}} {\memgloref{}}|memjustarg}{986} -\glossaryentry{range.access.begin@ {\memgloterm{range.access.begin}}{\memglodesc{(\ref {range.access.begin})}} {\memgloref{}}|memjustarg}{986} -\glossaryentry{range.access.end@ {\memgloterm{range.access.end}}{\memglodesc{(\ref {range.access.end})}} {\memgloref{}}|memjustarg}{986} -\glossaryentry{range.access.cbegin@ {\memgloterm{range.access.cbegin}}{\memglodesc{(\ref {range.access.cbegin})}} {\memgloref{}}|memjustarg}{987} -\glossaryentry{range.access.cend@ {\memgloterm{range.access.cend}}{\memglodesc{(\ref {range.access.cend})}} {\memgloref{}}|memjustarg}{987} -\glossaryentry{range.access.rbegin@ {\memgloterm{range.access.rbegin}}{\memglodesc{(\ref {range.access.rbegin})}} {\memgloref{}}|memjustarg}{987} -\glossaryentry{range.access.rend@ {\memgloterm{range.access.rend}}{\memglodesc{(\ref {range.access.rend})}} {\memgloref{}}|memjustarg}{987} -\glossaryentry{range.access.crbegin@ {\memgloterm{range.access.crbegin}}{\memglodesc{(\ref {range.access.crbegin})}} {\memgloref{}}|memjustarg}{988} -\glossaryentry{range.access.crend@ {\memgloterm{range.access.crend}}{\memglodesc{(\ref {range.access.crend})}} {\memgloref{}}|memjustarg}{988} -\glossaryentry{range.prim.size@ {\memgloterm{range.prim.size}}{\memglodesc{(\ref {range.prim.size})}} {\memgloref{}}|memjustarg}{988} -\glossaryentry{range.prim.ssize@ {\memgloterm{range.prim.ssize}}{\memglodesc{(\ref {range.prim.ssize})}} {\memgloref{}}|memjustarg}{989} -\glossaryentry{range.prim.empty@ {\memgloterm{range.prim.empty}}{\memglodesc{(\ref {range.prim.empty})}} {\memgloref{}}|memjustarg}{989} -\glossaryentry{range.prim.data@ {\memgloterm{range.prim.data}}{\memglodesc{(\ref {range.prim.data})}} {\memgloref{}}|memjustarg}{989} -\glossaryentry{range.prim.cdata@ {\memgloterm{range.prim.cdata}}{\memglodesc{(\ref {range.prim.cdata})}} {\memgloref{}}|memjustarg}{990} -\glossaryentry{range.req@ {\memgloterm{range.req}}{\memglodesc{(\ref {range.req})}} {\memgloref{}}|memjustarg}{990} -\glossaryentry{range.req.general@ {\memgloterm{range.req.general}}{\memglodesc{(\ref {range.req.general})}} {\memgloref{}}|memjustarg}{990} -\glossaryentry{range.range@ {\memgloterm{range.range}}{\memglodesc{(\ref {range.range})}} {\memgloref{}}|memjustarg}{990} -\glossaryentry{range.sized@ {\memgloterm{range.sized}}{\memglodesc{(\ref {range.sized})}} {\memgloref{}}|memjustarg}{991} -\glossaryentry{range.view@ {\memgloterm{range.view}}{\memglodesc{(\ref {range.view})}} {\memgloref{}}|memjustarg}{991} -\glossaryentry{range.refinements@ {\memgloterm{range.refinements}}{\memglodesc{(\ref {range.refinements})}} {\memgloref{}}|memjustarg}{992} -\glossaryentry{range.utility@ {\memgloterm{range.utility}}{\memglodesc{(\ref {range.utility})}} {\memgloref{}}|memjustarg}{993} -\glossaryentry{range.utility.general@ {\memgloterm{range.utility.general}}{\memglodesc{(\ref {range.utility.general})}} {\memgloref{}}|memjustarg}{993} -\glossaryentry{range.utility.helpers@ {\memgloterm{range.utility.helpers}}{\memglodesc{(\ref {range.utility.helpers})}} {\memgloref{}}|memjustarg}{993} -\glossaryentry{view.interface@ {\memgloterm{view.interface}}{\memglodesc{(\ref {view.interface})}} {\memgloref{}}|memjustarg}{993} -\glossaryentry{view.interface.general@ {\memgloterm{view.interface.general}}{\memglodesc{(\ref {view.interface.general})}} {\memgloref{}}|memjustarg}{993} -\glossaryentry{view.interface.members@ {\memgloterm{view.interface.members}}{\memglodesc{(\ref {view.interface.members})}} {\memgloref{}}|memjustarg}{994} -\glossaryentry{range.subrange@ {\memgloterm{range.subrange}}{\memglodesc{(\ref {range.subrange})}} {\memgloref{}}|memjustarg}{994} -\glossaryentry{range.subrange.general@ {\memgloterm{range.subrange.general}}{\memglodesc{(\ref {range.subrange.general})}} {\memgloref{}}|memjustarg}{994} -\glossaryentry{range.subrange.ctor@ {\memgloterm{range.subrange.ctor}}{\memglodesc{(\ref {range.subrange.ctor})}} {\memgloref{}}|memjustarg}{996} -\glossaryentry{range.subrange.access@ {\memgloterm{range.subrange.access}}{\memglodesc{(\ref {range.subrange.access})}} {\memgloref{}}|memjustarg}{997} -\glossaryentry{range.dangling@ {\memgloterm{range.dangling}}{\memglodesc{(\ref {range.dangling})}} {\memgloref{}}|memjustarg}{998} -\glossaryentry{range.factories@ {\memgloterm{range.factories}}{\memglodesc{(\ref {range.factories})}} {\memgloref{}}|memjustarg}{998} -\glossaryentry{range.factories.general@ {\memgloterm{range.factories.general}}{\memglodesc{(\ref {range.factories.general})}} {\memgloref{}}|memjustarg}{998} -\glossaryentry{range.empty@ {\memgloterm{range.empty}}{\memglodesc{(\ref {range.empty})}} {\memgloref{}}|memjustarg}{998} -\glossaryentry{range.empty.overview@ {\memgloterm{range.empty.overview}}{\memglodesc{(\ref {range.empty.overview})}} {\memgloref{}}|memjustarg}{998} -\glossaryentry{range.empty.view@ {\memgloterm{range.empty.view}}{\memglodesc{(\ref {range.empty.view})}} {\memgloref{}}|memjustarg}{999} -\glossaryentry{range.single@ {\memgloterm{range.single}}{\memglodesc{(\ref {range.single})}} {\memgloref{}}|memjustarg}{999} -\glossaryentry{range.single.overview@ {\memgloterm{range.single.overview}}{\memglodesc{(\ref {range.single.overview})}} {\memgloref{}}|memjustarg}{999} -\glossaryentry{range.single.view@ {\memgloterm{range.single.view}}{\memglodesc{(\ref {range.single.view})}} {\memgloref{}}|memjustarg}{999} -\glossaryentry{range.iota@ {\memgloterm{range.iota}}{\memglodesc{(\ref {range.iota})}} {\memgloref{}}|memjustarg}{1000} -\glossaryentry{range.iota.overview@ {\memgloterm{range.iota.overview}}{\memglodesc{(\ref {range.iota.overview})}} {\memgloref{}}|memjustarg}{1000} -\glossaryentry{range.iota.view@ {\memgloterm{range.iota.view}}{\memglodesc{(\ref {range.iota.view})}} {\memgloref{}}|memjustarg}{1000} -\glossaryentry{range.iota.iterator@ {\memgloterm{range.iota.iterator}}{\memglodesc{(\ref {range.iota.iterator})}} {\memgloref{}}|memjustarg}{1002} -\glossaryentry{range.iota.sentinel@ {\memgloterm{range.iota.sentinel}}{\memglodesc{(\ref {range.iota.sentinel})}} {\memgloref{}}|memjustarg}{1005} -\glossaryentry{range.istream@ {\memgloterm{range.istream}}{\memglodesc{(\ref {range.istream})}} {\memgloref{}}|memjustarg}{1006} -\glossaryentry{range.istream.overview@ {\memgloterm{range.istream.overview}}{\memglodesc{(\ref {range.istream.overview})}} {\memgloref{}}|memjustarg}{1006} -\glossaryentry{range.istream.view@ {\memgloterm{range.istream.view}}{\memglodesc{(\ref {range.istream.view})}} {\memgloref{}}|memjustarg}{1006} -\glossaryentry{range.istream.iterator@ {\memgloterm{range.istream.iterator}}{\memglodesc{(\ref {range.istream.iterator})}} {\memgloref{}}|memjustarg}{1007} -\glossaryentry{range.adaptors@ {\memgloterm{range.adaptors}}{\memglodesc{(\ref {range.adaptors})}} {\memgloref{}}|memjustarg}{1008} -\glossaryentry{range.adaptors.general@ {\memgloterm{range.adaptors.general}}{\memglodesc{(\ref {range.adaptors.general})}} {\memgloref{}}|memjustarg}{1008} -\glossaryentry{range.adaptor.object@ {\memgloterm{range.adaptor.object}}{\memglodesc{(\ref {range.adaptor.object})}} {\memgloref{}}|memjustarg}{1008} -\glossaryentry{range.semi.wrap@ {\memgloterm{range.semi.wrap}}{\memglodesc{(\ref {range.semi.wrap})}} {\memgloref{}}|memjustarg}{1008} -\glossaryentry{range.all@ {\memgloterm{range.all}}{\memglodesc{(\ref {range.all})}} {\memgloref{}}|memjustarg}{1009} -\glossaryentry{range.all.general@ {\memgloterm{range.all.general}}{\memglodesc{(\ref {range.all.general})}} {\memgloref{}}|memjustarg}{1009} -\glossaryentry{range.ref.view@ {\memgloterm{range.ref.view}}{\memglodesc{(\ref {range.ref.view})}} {\memgloref{}}|memjustarg}{1009} -\glossaryentry{range.filter@ {\memgloterm{range.filter}}{\memglodesc{(\ref {range.filter})}} {\memgloref{}}|memjustarg}{1010} -\glossaryentry{range.filter.overview@ {\memgloterm{range.filter.overview}}{\memglodesc{(\ref {range.filter.overview})}} {\memgloref{}}|memjustarg}{1010} -\glossaryentry{range.filter.view@ {\memgloterm{range.filter.view}}{\memglodesc{(\ref {range.filter.view})}} {\memgloref{}}|memjustarg}{1010} -\glossaryentry{range.filter.iterator@ {\memgloterm{range.filter.iterator}}{\memglodesc{(\ref {range.filter.iterator})}} {\memgloref{}}|memjustarg}{1011} -\glossaryentry{range.filter.sentinel@ {\memgloterm{range.filter.sentinel}}{\memglodesc{(\ref {range.filter.sentinel})}} {\memgloref{}}|memjustarg}{1013} -\glossaryentry{range.transform@ {\memgloterm{range.transform}}{\memglodesc{(\ref {range.transform})}} {\memgloref{}}|memjustarg}{1013} -\glossaryentry{range.transform.overview@ {\memgloterm{range.transform.overview}}{\memglodesc{(\ref {range.transform.overview})}} {\memgloref{}}|memjustarg}{1013} -\glossaryentry{range.transform.view@ {\memgloterm{range.transform.view}}{\memglodesc{(\ref {range.transform.view})}} {\memgloref{}}|memjustarg}{1013} -\glossaryentry{range.transform.iterator@ {\memgloterm{range.transform.iterator}}{\memglodesc{(\ref {range.transform.iterator})}} {\memgloref{}}|memjustarg}{1015} -\glossaryentry{range.transform.sentinel@ {\memgloterm{range.transform.sentinel}}{\memglodesc{(\ref {range.transform.sentinel})}} {\memgloref{}}|memjustarg}{1018} -\glossaryentry{range.take@ {\memgloterm{range.take}}{\memglodesc{(\ref {range.take})}} {\memgloref{}}|memjustarg}{1019} -\glossaryentry{range.take.overview@ {\memgloterm{range.take.overview}}{\memglodesc{(\ref {range.take.overview})}} {\memgloref{}}|memjustarg}{1019} -\glossaryentry{range.take.view@ {\memgloterm{range.take.view}}{\memglodesc{(\ref {range.take.view})}} {\memgloref{}}|memjustarg}{1019} -\glossaryentry{range.take.sentinel@ {\memgloterm{range.take.sentinel}}{\memglodesc{(\ref {range.take.sentinel})}} {\memgloref{}}|memjustarg}{1021} -\glossaryentry{range.take.while@ {\memgloterm{range.take.while}}{\memglodesc{(\ref {range.take.while})}} {\memgloref{}}|memjustarg}{1021} -\glossaryentry{range.take.while.overview@ {\memgloterm{range.take.while.overview}}{\memglodesc{(\ref {range.take.while.overview})}} {\memgloref{}}|memjustarg}{1021} -\glossaryentry{range.take.while.view@ {\memgloterm{range.take.while.view}}{\memglodesc{(\ref {range.take.while.view})}} {\memgloref{}}|memjustarg}{1021} -\glossaryentry{range.take.while.sentinel@ {\memgloterm{range.take.while.sentinel}}{\memglodesc{(\ref {range.take.while.sentinel})}} {\memgloref{}}|memjustarg}{1022} -\glossaryentry{range.drop@ {\memgloterm{range.drop}}{\memglodesc{(\ref {range.drop})}} {\memgloref{}}|memjustarg}{1023} -\glossaryentry{range.drop.overview@ {\memgloterm{range.drop.overview}}{\memglodesc{(\ref {range.drop.overview})}} {\memgloref{}}|memjustarg}{1023} -\glossaryentry{range.drop.view@ {\memgloterm{range.drop.view}}{\memglodesc{(\ref {range.drop.view})}} {\memgloref{}}|memjustarg}{1023} -\glossaryentry{range.drop.while@ {\memgloterm{range.drop.while}}{\memglodesc{(\ref {range.drop.while})}} {\memgloref{}}|memjustarg}{1024} -\glossaryentry{range.drop.while.overview@ {\memgloterm{range.drop.while.overview}}{\memglodesc{(\ref {range.drop.while.overview})}} {\memgloref{}}|memjustarg}{1024} -\glossaryentry{range.drop.while.view@ {\memgloterm{range.drop.while.view}}{\memglodesc{(\ref {range.drop.while.view})}} {\memgloref{}}|memjustarg}{1024} -\glossaryentry{range.join@ {\memgloterm{range.join}}{\memglodesc{(\ref {range.join})}} {\memgloref{}}|memjustarg}{1025} -\glossaryentry{range.join.overview@ {\memgloterm{range.join.overview}}{\memglodesc{(\ref {range.join.overview})}} {\memgloref{}}|memjustarg}{1025} -\glossaryentry{range.join.view@ {\memgloterm{range.join.view}}{\memglodesc{(\ref {range.join.view})}} {\memgloref{}}|memjustarg}{1025} -\glossaryentry{range.join.iterator@ {\memgloterm{range.join.iterator}}{\memglodesc{(\ref {range.join.iterator})}} {\memgloref{}}|memjustarg}{1026} -\glossaryentry{range.join.sentinel@ {\memgloterm{range.join.sentinel}}{\memglodesc{(\ref {range.join.sentinel})}} {\memgloref{}}|memjustarg}{1030} -\glossaryentry{range.split@ {\memgloterm{range.split}}{\memglodesc{(\ref {range.split})}} {\memgloref{}}|memjustarg}{1030} -\glossaryentry{range.split.overview@ {\memgloterm{range.split.overview}}{\memglodesc{(\ref {range.split.overview})}} {\memgloref{}}|memjustarg}{1030} -\glossaryentry{range.split.view@ {\memgloterm{range.split.view}}{\memglodesc{(\ref {range.split.view})}} {\memgloref{}}|memjustarg}{1030} -\glossaryentry{range.split.outer@ {\memgloterm{range.split.outer}}{\memglodesc{(\ref {range.split.outer})}} {\memgloref{}}|memjustarg}{1032} -\glossaryentry{range.split.outer.value@ {\memgloterm{range.split.outer.value}}{\memglodesc{(\ref {range.split.outer.value})}} {\memgloref{}}|memjustarg}{1033} -\glossaryentry{range.split.inner@ {\memgloterm{range.split.inner}}{\memglodesc{(\ref {range.split.inner})}} {\memgloref{}}|memjustarg}{1034} -\glossaryentry{range.counted@ {\memgloterm{range.counted}}{\memglodesc{(\ref {range.counted})}} {\memgloref{}}|memjustarg}{1035} -\glossaryentry{range.common@ {\memgloterm{range.common}}{\memglodesc{(\ref {range.common})}} {\memgloref{}}|memjustarg}{1036} -\glossaryentry{range.common.overview@ {\memgloterm{range.common.overview}}{\memglodesc{(\ref {range.common.overview})}} {\memgloref{}}|memjustarg}{1036} -\glossaryentry{range.common.view@ {\memgloterm{range.common.view}}{\memglodesc{(\ref {range.common.view})}} {\memgloref{}}|memjustarg}{1036} -\glossaryentry{range.reverse@ {\memgloterm{range.reverse}}{\memglodesc{(\ref {range.reverse})}} {\memgloref{}}|memjustarg}{1037} -\glossaryentry{range.reverse.overview@ {\memgloterm{range.reverse.overview}}{\memglodesc{(\ref {range.reverse.overview})}} {\memgloref{}}|memjustarg}{1037} -\glossaryentry{range.reverse.view@ {\memgloterm{range.reverse.view}}{\memglodesc{(\ref {range.reverse.view})}} {\memgloref{}}|memjustarg}{1038} -\glossaryentry{range.elements@ {\memgloterm{range.elements}}{\memglodesc{(\ref {range.elements})}} {\memgloref{}}|memjustarg}{1038} -\glossaryentry{range.elements.overview@ {\memgloterm{range.elements.overview}}{\memglodesc{(\ref {range.elements.overview})}} {\memgloref{}}|memjustarg}{1038} -\glossaryentry{range.elements.view@ {\memgloterm{range.elements.view}}{\memglodesc{(\ref {range.elements.view})}} {\memgloref{}}|memjustarg}{1039} -\glossaryentry{range.elements.iterator@ {\memgloterm{range.elements.iterator}}{\memglodesc{(\ref {range.elements.iterator})}} {\memgloref{}}|memjustarg}{1040} -\glossaryentry{range.elements.sentinel@ {\memgloterm{range.elements.sentinel}}{\memglodesc{(\ref {range.elements.sentinel})}} {\memgloref{}}|memjustarg}{1043} -\glossaryentry{algorithms@ {\memgloterm{algorithms}}{\memglodesc{(\ref {algorithms})}} {\memgloref{}}|memjustarg}{1044} -\glossaryentry{algorithms.general@ {\memgloterm{algorithms.general}}{\memglodesc{(\ref {algorithms.general})}} {\memgloref{}}|memjustarg}{1044} -\glossaryentry{algorithms.requirements@ {\memgloterm{algorithms.requirements}}{\memglodesc{(\ref {algorithms.requirements})}} {\memgloref{}}|memjustarg}{1044} -\glossaryentry{algorithms.parallel@ {\memgloterm{algorithms.parallel}}{\memglodesc{(\ref {algorithms.parallel})}} {\memgloref{}}|memjustarg}{1046} -\glossaryentry{algorithms.parallel.defns@ {\memgloterm{algorithms.parallel.defns}}{\memglodesc{(\ref {algorithms.parallel.defns})}} {\memgloref{}}|memjustarg}{1046} -\glossaryentry{algorithms.parallel.user@ {\memgloterm{algorithms.parallel.user}}{\memglodesc{(\ref {algorithms.parallel.user})}} {\memgloref{}}|memjustarg}{1047} -\glossaryentry{algorithms.parallel.exec@ {\memgloterm{algorithms.parallel.exec}}{\memglodesc{(\ref {algorithms.parallel.exec})}} {\memgloref{}}|memjustarg}{1047} -\glossaryentry{algorithms.parallel.exceptions@ {\memgloterm{algorithms.parallel.exceptions}}{\memglodesc{(\ref {algorithms.parallel.exceptions})}} {\memgloref{}}|memjustarg}{1048} -\glossaryentry{algorithms.parallel.overloads@ {\memgloterm{algorithms.parallel.overloads}}{\memglodesc{(\ref {algorithms.parallel.overloads})}} {\memgloref{}}|memjustarg}{1049} -\glossaryentry{algorithm.syn@ {\memgloterm{algorithm.syn}}{\memglodesc{(\ref {algorithm.syn})}} {\memgloref{}}|memjustarg}{1049} -\glossaryentry{algorithms.results@ {\memgloterm{algorithms.results}}{\memglodesc{(\ref {algorithms.results})}} {\memgloref{}}|memjustarg}{1084} -\glossaryentry{alg.nonmodifying@ {\memgloterm{alg.nonmodifying}}{\memglodesc{(\ref {alg.nonmodifying})}} {\memgloref{}}|memjustarg}{1087} -\glossaryentry{alg.all.of@ {\memgloterm{alg.all.of}}{\memglodesc{(\ref {alg.all.of})}} {\memgloref{}}|memjustarg}{1087} -\glossaryentry{alg.any.of@ {\memgloterm{alg.any.of}}{\memglodesc{(\ref {alg.any.of})}} {\memgloref{}}|memjustarg}{1087} -\glossaryentry{alg.none.of@ {\memgloterm{alg.none.of}}{\memglodesc{(\ref {alg.none.of})}} {\memgloref{}}|memjustarg}{1087} -\glossaryentry{alg.foreach@ {\memgloterm{alg.foreach}}{\memglodesc{(\ref {alg.foreach})}} {\memgloref{}}|memjustarg}{1088} -\glossaryentry{alg.find@ {\memgloterm{alg.find}}{\memglodesc{(\ref {alg.find})}} {\memgloref{}}|memjustarg}{1089} -\glossaryentry{alg.find.end@ {\memgloterm{alg.find.end}}{\memglodesc{(\ref {alg.find.end})}} {\memgloref{}}|memjustarg}{1090} -\glossaryentry{alg.find.first.of@ {\memgloterm{alg.find.first.of}}{\memglodesc{(\ref {alg.find.first.of})}} {\memgloref{}}|memjustarg}{1091} -\glossaryentry{alg.adjacent.find@ {\memgloterm{alg.adjacent.find}}{\memglodesc{(\ref {alg.adjacent.find})}} {\memgloref{}}|memjustarg}{1092} -\glossaryentry{alg.count@ {\memgloterm{alg.count}}{\memglodesc{(\ref {alg.count})}} {\memgloref{}}|memjustarg}{1093} -\glossaryentry{mismatch@ {\memgloterm{mismatch}}{\memglodesc{(\ref {mismatch})}} {\memgloref{}}|memjustarg}{1093} -\glossaryentry{alg.equal@ {\memgloterm{alg.equal}}{\memglodesc{(\ref {alg.equal})}} {\memgloref{}}|memjustarg}{1095} -\glossaryentry{alg.is.permutation@ {\memgloterm{alg.is.permutation}}{\memglodesc{(\ref {alg.is.permutation})}} {\memgloref{}}|memjustarg}{1096} -\glossaryentry{alg.search@ {\memgloterm{alg.search}}{\memglodesc{(\ref {alg.search})}} {\memgloref{}}|memjustarg}{1097} -\glossaryentry{alg.modifying.operations@ {\memgloterm{alg.modifying.operations}}{\memglodesc{(\ref {alg.modifying.operations})}} {\memgloref{}}|memjustarg}{1099} -\glossaryentry{alg.copy@ {\memgloterm{alg.copy}}{\memglodesc{(\ref {alg.copy})}} {\memgloref{}}|memjustarg}{1099} -\glossaryentry{alg.move@ {\memgloterm{alg.move}}{\memglodesc{(\ref {alg.move})}} {\memgloref{}}|memjustarg}{1101} -\glossaryentry{alg.swap@ {\memgloterm{alg.swap}}{\memglodesc{(\ref {alg.swap})}} {\memgloref{}}|memjustarg}{1102} -\glossaryentry{alg.transform@ {\memgloterm{alg.transform}}{\memglodesc{(\ref {alg.transform})}} {\memgloref{}}|memjustarg}{1103} -\glossaryentry{alg.replace@ {\memgloterm{alg.replace}}{\memglodesc{(\ref {alg.replace})}} {\memgloref{}}|memjustarg}{1104} -\glossaryentry{alg.fill@ {\memgloterm{alg.fill}}{\memglodesc{(\ref {alg.fill})}} {\memgloref{}}|memjustarg}{1106} -\glossaryentry{alg.generate@ {\memgloterm{alg.generate}}{\memglodesc{(\ref {alg.generate})}} {\memgloref{}}|memjustarg}{1107} -\glossaryentry{alg.remove@ {\memgloterm{alg.remove}}{\memglodesc{(\ref {alg.remove})}} {\memgloref{}}|memjustarg}{1107} -\glossaryentry{alg.unique@ {\memgloterm{alg.unique}}{\memglodesc{(\ref {alg.unique})}} {\memgloref{}}|memjustarg}{1109} -\glossaryentry{alg.reverse@ {\memgloterm{alg.reverse}}{\memglodesc{(\ref {alg.reverse})}} {\memgloref{}}|memjustarg}{1111} -\glossaryentry{alg.rotate@ {\memgloterm{alg.rotate}}{\memglodesc{(\ref {alg.rotate})}} {\memgloref{}}|memjustarg}{1112} -\glossaryentry{alg.random.sample@ {\memgloterm{alg.random.sample}}{\memglodesc{(\ref {alg.random.sample})}} {\memgloref{}}|memjustarg}{1113} -\glossaryentry{alg.random.shuffle@ {\memgloterm{alg.random.shuffle}}{\memglodesc{(\ref {alg.random.shuffle})}} {\memgloref{}}|memjustarg}{1114} -\glossaryentry{alg.shift@ {\memgloterm{alg.shift}}{\memglodesc{(\ref {alg.shift})}} {\memgloref{}}|memjustarg}{1114} -\glossaryentry{alg.sorting@ {\memgloterm{alg.sorting}}{\memglodesc{(\ref {alg.sorting})}} {\memgloref{}}|memjustarg}{1115} -\glossaryentry{alg.sorting.general@ {\memgloterm{alg.sorting.general}}{\memglodesc{(\ref {alg.sorting.general})}} {\memgloref{}}|memjustarg}{1115} -\glossaryentry{alg.sort@ {\memgloterm{alg.sort}}{\memglodesc{(\ref {alg.sort})}} {\memgloref{}}|memjustarg}{1115} -\glossaryentry{sort@ {\memgloterm{sort}}{\memglodesc{(\ref {sort})}} {\memgloref{}}|memjustarg}{1115} -\glossaryentry{stable.sort@ {\memgloterm{stable.sort}}{\memglodesc{(\ref {stable.sort})}} {\memgloref{}}|memjustarg}{1116} -\glossaryentry{partial.sort@ {\memgloterm{partial.sort}}{\memglodesc{(\ref {partial.sort})}} {\memgloref{}}|memjustarg}{1117} -\glossaryentry{partial.sort.copy@ {\memgloterm{partial.sort.copy}}{\memglodesc{(\ref {partial.sort.copy})}} {\memgloref{}}|memjustarg}{1117} -\glossaryentry{is.sorted@ {\memgloterm{is.sorted}}{\memglodesc{(\ref {is.sorted})}} {\memgloref{}}|memjustarg}{1119} -\glossaryentry{alg.nth.element@ {\memgloterm{alg.nth.element}}{\memglodesc{(\ref {alg.nth.element})}} {\memgloref{}}|memjustarg}{1120} -\glossaryentry{alg.binary.search@ {\memgloterm{alg.binary.search}}{\memglodesc{(\ref {alg.binary.search})}} {\memgloref{}}|memjustarg}{1120} -\glossaryentry{alg.binary.search.general@ {\memgloterm{alg.binary.search.general}}{\memglodesc{(\ref {alg.binary.search.general})}} {\memgloref{}}|memjustarg}{1120} -\glossaryentry{lower.bound@ {\memgloterm{lower.bound}}{\memglodesc{(\ref {lower.bound})}} {\memgloref{}}|memjustarg}{1121} -\glossaryentry{upper.bound@ {\memgloterm{upper.bound}}{\memglodesc{(\ref {upper.bound})}} {\memgloref{}}|memjustarg}{1121} -\glossaryentry{equal.range@ {\memgloterm{equal.range}}{\memglodesc{(\ref {equal.range})}} {\memgloref{}}|memjustarg}{1121} -\glossaryentry{binary.search@ {\memgloterm{binary.search}}{\memglodesc{(\ref {binary.search})}} {\memgloref{}}|memjustarg}{1122} -\glossaryentry{alg.partitions@ {\memgloterm{alg.partitions}}{\memglodesc{(\ref {alg.partitions})}} {\memgloref{}}|memjustarg}{1123} -\glossaryentry{alg.merge@ {\memgloterm{alg.merge}}{\memglodesc{(\ref {alg.merge})}} {\memgloref{}}|memjustarg}{1125} -\glossaryentry{alg.set.operations@ {\memgloterm{alg.set.operations}}{\memglodesc{(\ref {alg.set.operations})}} {\memgloref{}}|memjustarg}{1127} -\glossaryentry{alg.set.operations.general@ {\memgloterm{alg.set.operations.general}}{\memglodesc{(\ref {alg.set.operations.general})}} {\memgloref{}}|memjustarg}{1127} -\glossaryentry{includes@ {\memgloterm{includes}}{\memglodesc{(\ref {includes})}} {\memgloref{}}|memjustarg}{1127} -\glossaryentry{set.union@ {\memgloterm{set.union}}{\memglodesc{(\ref {set.union})}} {\memgloref{}}|memjustarg}{1128} -\glossaryentry{set.intersection@ {\memgloterm{set.intersection}}{\memglodesc{(\ref {set.intersection})}} {\memgloref{}}|memjustarg}{1129} -\glossaryentry{set.difference@ {\memgloterm{set.difference}}{\memglodesc{(\ref {set.difference})}} {\memgloref{}}|memjustarg}{1130} -\glossaryentry{set.symmetric.difference@ {\memgloterm{set.symmetric.difference}}{\memglodesc{(\ref {set.symmetric.difference})}} {\memgloref{}}|memjustarg}{1131} -\glossaryentry{alg.heap.operations@ {\memgloterm{alg.heap.operations}}{\memglodesc{(\ref {alg.heap.operations})}} {\memgloref{}}|memjustarg}{1132} -\glossaryentry{alg.heap.operations.general@ {\memgloterm{alg.heap.operations.general}}{\memglodesc{(\ref {alg.heap.operations.general})}} {\memgloref{}}|memjustarg}{1132} -\glossaryentry{push.heap@ {\memgloterm{push.heap}}{\memglodesc{(\ref {push.heap})}} {\memgloref{}}|memjustarg}{1132} -\glossaryentry{pop.heap@ {\memgloterm{pop.heap}}{\memglodesc{(\ref {pop.heap})}} {\memgloref{}}|memjustarg}{1133} -\glossaryentry{make.heap@ {\memgloterm{make.heap}}{\memglodesc{(\ref {make.heap})}} {\memgloref{}}|memjustarg}{1133} -\glossaryentry{sort.heap@ {\memgloterm{sort.heap}}{\memglodesc{(\ref {sort.heap})}} {\memgloref{}}|memjustarg}{1133} -\glossaryentry{is.heap@ {\memgloterm{is.heap}}{\memglodesc{(\ref {is.heap})}} {\memgloref{}}|memjustarg}{1134} -\glossaryentry{alg.min.max@ {\memgloterm{alg.min.max}}{\memglodesc{(\ref {alg.min.max})}} {\memgloref{}}|memjustarg}{1135} -\glossaryentry{alg.clamp@ {\memgloterm{alg.clamp}}{\memglodesc{(\ref {alg.clamp})}} {\memgloref{}}|memjustarg}{1138} -\glossaryentry{alg.lex.comparison@ {\memgloterm{alg.lex.comparison}}{\memglodesc{(\ref {alg.lex.comparison})}} {\memgloref{}}|memjustarg}{1139} -\glossaryentry{alg.three.way@ {\memgloterm{alg.three.way}}{\memglodesc{(\ref {alg.three.way})}} {\memgloref{}}|memjustarg}{1140} -\glossaryentry{alg.permutation.generators@ {\memgloterm{alg.permutation.generators}}{\memglodesc{(\ref {alg.permutation.generators})}} {\memgloref{}}|memjustarg}{1140} -\glossaryentry{numeric.ops.overview@ {\memgloterm{numeric.ops.overview}}{\memglodesc{(\ref {numeric.ops.overview})}} {\memgloref{}}|memjustarg}{1141} -\glossaryentry{numeric.ops@ {\memgloterm{numeric.ops}}{\memglodesc{(\ref {numeric.ops})}} {\memgloref{}}|memjustarg}{1145} -\glossaryentry{numeric.ops.general@ {\memgloterm{numeric.ops.general}}{\memglodesc{(\ref {numeric.ops.general})}} {\memgloref{}}|memjustarg}{1145} -\glossaryentry{numerics.defns@ {\memgloterm{numerics.defns}}{\memglodesc{(\ref {numerics.defns})}} {\memgloref{}}|memjustarg}{1145} -\glossaryentry{accumulate@ {\memgloterm{accumulate}}{\memglodesc{(\ref {accumulate})}} {\memgloref{}}|memjustarg}{1145} -\glossaryentry{reduce@ {\memgloterm{reduce}}{\memglodesc{(\ref {reduce})}} {\memgloref{}}|memjustarg}{1145} -\glossaryentry{inner.product@ {\memgloterm{inner.product}}{\memglodesc{(\ref {inner.product})}} {\memgloref{}}|memjustarg}{1146} -\glossaryentry{transform.reduce@ {\memgloterm{transform.reduce}}{\memglodesc{(\ref {transform.reduce})}} {\memgloref{}}|memjustarg}{1146} -\glossaryentry{partial.sum@ {\memgloterm{partial.sum}}{\memglodesc{(\ref {partial.sum})}} {\memgloref{}}|memjustarg}{1148} -\glossaryentry{exclusive.scan@ {\memgloterm{exclusive.scan}}{\memglodesc{(\ref {exclusive.scan})}} {\memgloref{}}|memjustarg}{1148} -\glossaryentry{inclusive.scan@ {\memgloterm{inclusive.scan}}{\memglodesc{(\ref {inclusive.scan})}} {\memgloref{}}|memjustarg}{1149} -\glossaryentry{transform.exclusive.scan@ {\memgloterm{transform.exclusive.scan}}{\memglodesc{(\ref {transform.exclusive.scan})}} {\memgloref{}}|memjustarg}{1150} -\glossaryentry{transform.inclusive.scan@ {\memgloterm{transform.inclusive.scan}}{\memglodesc{(\ref {transform.inclusive.scan})}} {\memgloref{}}|memjustarg}{1151} -\glossaryentry{adjacent.difference@ {\memgloterm{adjacent.difference}}{\memglodesc{(\ref {adjacent.difference})}} {\memgloref{}}|memjustarg}{1152} -\glossaryentry{numeric.iota@ {\memgloterm{numeric.iota}}{\memglodesc{(\ref {numeric.iota})}} {\memgloref{}}|memjustarg}{1153} -\glossaryentry{numeric.ops.gcd@ {\memgloterm{numeric.ops.gcd}}{\memglodesc{(\ref {numeric.ops.gcd})}} {\memgloref{}}|memjustarg}{1153} -\glossaryentry{numeric.ops.lcm@ {\memgloterm{numeric.ops.lcm}}{\memglodesc{(\ref {numeric.ops.lcm})}} {\memgloref{}}|memjustarg}{1153} -\glossaryentry{numeric.ops.midpoint@ {\memgloterm{numeric.ops.midpoint}}{\memglodesc{(\ref {numeric.ops.midpoint})}} {\memgloref{}}|memjustarg}{1154} -\glossaryentry{specialized.algorithms@ {\memgloterm{specialized.algorithms}}{\memglodesc{(\ref {specialized.algorithms})}} {\memgloref{}}|memjustarg}{1154} -\glossaryentry{specialized.algorithms.general@ {\memgloterm{specialized.algorithms.general}}{\memglodesc{(\ref {specialized.algorithms.general})}} {\memgloref{}}|memjustarg}{1154} -\glossaryentry{special.mem.concepts@ {\memgloterm{special.mem.concepts}}{\memglodesc{(\ref {special.mem.concepts})}} {\memgloref{}}|memjustarg}{1154} -\glossaryentry{uninitialized.construct.default@ {\memgloterm{uninitialized.construct.default}}{\memglodesc{(\ref {uninitialized.construct.default})}} {\memgloref{}}|memjustarg}{1155} -\glossaryentry{uninitialized.construct.value@ {\memgloterm{uninitialized.construct.value}}{\memglodesc{(\ref {uninitialized.construct.value})}} {\memgloref{}}|memjustarg}{1156} -\glossaryentry{uninitialized.copy@ {\memgloterm{uninitialized.copy}}{\memglodesc{(\ref {uninitialized.copy})}} {\memgloref{}}|memjustarg}{1156} -\glossaryentry{uninitialized.move@ {\memgloterm{uninitialized.move}}{\memglodesc{(\ref {uninitialized.move})}} {\memgloref{}}|memjustarg}{1157} -\glossaryentry{uninitialized.fill@ {\memgloterm{uninitialized.fill}}{\memglodesc{(\ref {uninitialized.fill})}} {\memgloref{}}|memjustarg}{1158} -\glossaryentry{specialized.construct@ {\memgloterm{specialized.construct}}{\memglodesc{(\ref {specialized.construct})}} {\memgloref{}}|memjustarg}{1159} -\glossaryentry{specialized.destroy@ {\memgloterm{specialized.destroy}}{\memglodesc{(\ref {specialized.destroy})}} {\memgloref{}}|memjustarg}{1159} -\glossaryentry{alg.c.library@ {\memgloterm{alg.c.library}}{\memglodesc{(\ref {alg.c.library})}} {\memgloref{}}|memjustarg}{1160} -\glossaryentry{numerics@ {\memgloterm{numerics}}{\memglodesc{(\ref {numerics})}} {\memgloref{}}|memjustarg}{1161} -\glossaryentry{numerics.general@ {\memgloterm{numerics.general}}{\memglodesc{(\ref {numerics.general})}} {\memgloref{}}|memjustarg}{1161} -\glossaryentry{numeric.requirements@ {\memgloterm{numeric.requirements}}{\memglodesc{(\ref {numeric.requirements})}} {\memgloref{}}|memjustarg}{1161} -\glossaryentry{cfenv@ {\memgloterm{cfenv}}{\memglodesc{(\ref {cfenv})}} {\memgloref{}}|memjustarg}{1161} -\glossaryentry{cfenv.syn@ {\memgloterm{cfenv.syn}}{\memglodesc{(\ref {cfenv.syn})}} {\memgloref{}}|memjustarg}{1161} -\glossaryentry{cfenv.thread@ {\memgloterm{cfenv.thread}}{\memglodesc{(\ref {cfenv.thread})}} {\memgloref{}}|memjustarg}{1162} -\glossaryentry{complex.numbers@ {\memgloterm{complex.numbers}}{\memglodesc{(\ref {complex.numbers})}} {\memgloref{}}|memjustarg}{1162} -\glossaryentry{complex.numbers.general@ {\memgloterm{complex.numbers.general}}{\memglodesc{(\ref {complex.numbers.general})}} {\memgloref{}}|memjustarg}{1162} -\glossaryentry{complex.syn@ {\memgloterm{complex.syn}}{\memglodesc{(\ref {complex.syn})}} {\memgloref{}}|memjustarg}{1163} -\glossaryentry{complex@ {\memgloterm{complex}}{\memglodesc{(\ref {complex})}} {\memgloref{}}|memjustarg}{1164} -\glossaryentry{complex.special@ {\memgloterm{complex.special}}{\memglodesc{(\ref {complex.special})}} {\memgloref{}}|memjustarg}{1164} -\glossaryentry{complex.members@ {\memgloterm{complex.members}}{\memglodesc{(\ref {complex.members})}} {\memgloref{}}|memjustarg}{1166} -\glossaryentry{complex.member.ops@ {\memgloterm{complex.member.ops}}{\memglodesc{(\ref {complex.member.ops})}} {\memgloref{}}|memjustarg}{1166} -\glossaryentry{complex.ops@ {\memgloterm{complex.ops}}{\memglodesc{(\ref {complex.ops})}} {\memgloref{}}|memjustarg}{1167} -\glossaryentry{complex.value.ops@ {\memgloterm{complex.value.ops}}{\memglodesc{(\ref {complex.value.ops})}} {\memgloref{}}|memjustarg}{1168} -\glossaryentry{complex.transcendentals@ {\memgloterm{complex.transcendentals}}{\memglodesc{(\ref {complex.transcendentals})}} {\memgloref{}}|memjustarg}{1168} -\glossaryentry{cmplx.over@ {\memgloterm{cmplx.over}}{\memglodesc{(\ref {cmplx.over})}} {\memgloref{}}|memjustarg}{1170} -\glossaryentry{complex.literals@ {\memgloterm{complex.literals}}{\memglodesc{(\ref {complex.literals})}} {\memgloref{}}|memjustarg}{1170} -\glossaryentry{bit@ {\memgloterm{bit}}{\memglodesc{(\ref {bit})}} {\memgloref{}}|memjustarg}{1170} -\glossaryentry{bit.general@ {\memgloterm{bit.general}}{\memglodesc{(\ref {bit.general})}} {\memgloref{}}|memjustarg}{1170} -\glossaryentry{bit.syn@ {\memgloterm{bit.syn}}{\memglodesc{(\ref {bit.syn})}} {\memgloref{}}|memjustarg}{1170} -\glossaryentry{bit.cast@ {\memgloterm{bit.cast}}{\memglodesc{(\ref {bit.cast})}} {\memgloref{}}|memjustarg}{1171} -\glossaryentry{bit.pow.two@ {\memgloterm{bit.pow.two}}{\memglodesc{(\ref {bit.pow.two})}} {\memgloref{}}|memjustarg}{1171} -\glossaryentry{bit.rotate@ {\memgloterm{bit.rotate}}{\memglodesc{(\ref {bit.rotate})}} {\memgloref{}}|memjustarg}{1172} -\glossaryentry{bit.count@ {\memgloterm{bit.count}}{\memglodesc{(\ref {bit.count})}} {\memgloref{}}|memjustarg}{1172} -\glossaryentry{bit.endian@ {\memgloterm{bit.endian}}{\memglodesc{(\ref {bit.endian})}} {\memgloref{}}|memjustarg}{1173} -\glossaryentry{rand@ {\memgloterm{rand}}{\memglodesc{(\ref {rand})}} {\memgloref{}}|memjustarg}{1173} -\glossaryentry{rand.general@ {\memgloterm{rand.general}}{\memglodesc{(\ref {rand.general})}} {\memgloref{}}|memjustarg}{1173} -\glossaryentry{rand.synopsis@ {\memgloterm{rand.synopsis}}{\memglodesc{(\ref {rand.synopsis})}} {\memgloref{}}|memjustarg}{1174} -\glossaryentry{rand.req@ {\memgloterm{rand.req}}{\memglodesc{(\ref {rand.req})}} {\memgloref{}}|memjustarg}{1176} -\glossaryentry{rand.req.genl@ {\memgloterm{rand.req.genl}}{\memglodesc{(\ref {rand.req.genl})}} {\memgloref{}}|memjustarg}{1176} -\glossaryentry{rand.req.seedseq@ {\memgloterm{rand.req.seedseq}}{\memglodesc{(\ref {rand.req.seedseq})}} {\memgloref{}}|memjustarg}{1176} -\glossaryentry{rand.req.urng@ {\memgloterm{rand.req.urng}}{\memglodesc{(\ref {rand.req.urng})}} {\memgloref{}}|memjustarg}{1177} -\glossaryentry{rand.req.eng@ {\memgloterm{rand.req.eng}}{\memglodesc{(\ref {rand.req.eng})}} {\memgloref{}}|memjustarg}{1178} -\glossaryentry{rand.req.adapt@ {\memgloterm{rand.req.adapt}}{\memglodesc{(\ref {rand.req.adapt})}} {\memgloref{}}|memjustarg}{1179} -\glossaryentry{rand.req.dist@ {\memgloterm{rand.req.dist}}{\memglodesc{(\ref {rand.req.dist})}} {\memgloref{}}|memjustarg}{1180} -\glossaryentry{rand.eng@ {\memgloterm{rand.eng}}{\memglodesc{(\ref {rand.eng})}} {\memgloref{}}|memjustarg}{1182} -\glossaryentry{rand.eng.general@ {\memgloterm{rand.eng.general}}{\memglodesc{(\ref {rand.eng.general})}} {\memgloref{}}|memjustarg}{1182} -\glossaryentry{rand.eng.lcong@ {\memgloterm{rand.eng.lcong}}{\memglodesc{(\ref {rand.eng.lcong})}} {\memgloref{}}|memjustarg}{1183} -\glossaryentry{rand.eng.mers@ {\memgloterm{rand.eng.mers}}{\memglodesc{(\ref {rand.eng.mers})}} {\memgloref{}}|memjustarg}{1184} -\glossaryentry{rand.eng.sub@ {\memgloterm{rand.eng.sub}}{\memglodesc{(\ref {rand.eng.sub})}} {\memgloref{}}|memjustarg}{1185} -\glossaryentry{rand.adapt@ {\memgloterm{rand.adapt}}{\memglodesc{(\ref {rand.adapt})}} {\memgloref{}}|memjustarg}{1186} -\glossaryentry{rand.adapt.general@ {\memgloterm{rand.adapt.general}}{\memglodesc{(\ref {rand.adapt.general})}} {\memgloref{}}|memjustarg}{1186} -\glossaryentry{rand.adapt.disc@ {\memgloterm{rand.adapt.disc}}{\memglodesc{(\ref {rand.adapt.disc})}} {\memgloref{}}|memjustarg}{1186} -\glossaryentry{rand.adapt.ibits@ {\memgloterm{rand.adapt.ibits}}{\memglodesc{(\ref {rand.adapt.ibits})}} {\memgloref{}}|memjustarg}{1187} -\glossaryentry{rand.adapt.shuf@ {\memgloterm{rand.adapt.shuf}}{\memglodesc{(\ref {rand.adapt.shuf})}} {\memgloref{}}|memjustarg}{1188} -\glossaryentry{rand.predef@ {\memgloterm{rand.predef}}{\memglodesc{(\ref {rand.predef})}} {\memgloref{}}|memjustarg}{1189} -\glossaryentry{rand.device@ {\memgloterm{rand.device}}{\memglodesc{(\ref {rand.device})}} {\memgloref{}}|memjustarg}{1190} -\glossaryentry{rand.util@ {\memgloterm{rand.util}}{\memglodesc{(\ref {rand.util})}} {\memgloref{}}|memjustarg}{1191} -\glossaryentry{rand.util.seedseq@ {\memgloterm{rand.util.seedseq}}{\memglodesc{(\ref {rand.util.seedseq})}} {\memgloref{}}|memjustarg}{1191} -\glossaryentry{rand.util.canonical@ {\memgloterm{rand.util.canonical}}{\memglodesc{(\ref {rand.util.canonical})}} {\memgloref{}}|memjustarg}{1193} -\glossaryentry{rand.dist@ {\memgloterm{rand.dist}}{\memglodesc{(\ref {rand.dist})}} {\memgloref{}}|memjustarg}{1193} -\glossaryentry{rand.dist.general@ {\memgloterm{rand.dist.general}}{\memglodesc{(\ref {rand.dist.general})}} {\memgloref{}}|memjustarg}{1193} -\glossaryentry{rand.dist.uni@ {\memgloterm{rand.dist.uni}}{\memglodesc{(\ref {rand.dist.uni})}} {\memgloref{}}|memjustarg}{1193} -\glossaryentry{rand.dist.uni.int@ {\memgloterm{rand.dist.uni.int}}{\memglodesc{(\ref {rand.dist.uni.int})}} {\memgloref{}}|memjustarg}{1193} -\glossaryentry{rand.dist.uni.real@ {\memgloterm{rand.dist.uni.real}}{\memglodesc{(\ref {rand.dist.uni.real})}} {\memgloref{}}|memjustarg}{1194} -\glossaryentry{rand.dist.bern@ {\memgloterm{rand.dist.bern}}{\memglodesc{(\ref {rand.dist.bern})}} {\memgloref{}}|memjustarg}{1195} -\glossaryentry{rand.dist.bern.bernoulli@ {\memgloterm{rand.dist.bern.bernoulli}}{\memglodesc{(\ref {rand.dist.bern.bernoulli})}} {\memgloref{}}|memjustarg}{1195} -\glossaryentry{rand.dist.bern.bin@ {\memgloterm{rand.dist.bern.bin}}{\memglodesc{(\ref {rand.dist.bern.bin})}} {\memgloref{}}|memjustarg}{1195} -\glossaryentry{rand.dist.bern.geo@ {\memgloterm{rand.dist.bern.geo}}{\memglodesc{(\ref {rand.dist.bern.geo})}} {\memgloref{}}|memjustarg}{1196} -\glossaryentry{rand.dist.bern.negbin@ {\memgloterm{rand.dist.bern.negbin}}{\memglodesc{(\ref {rand.dist.bern.negbin})}} {\memgloref{}}|memjustarg}{1197} -\glossaryentry{rand.dist.pois@ {\memgloterm{rand.dist.pois}}{\memglodesc{(\ref {rand.dist.pois})}} {\memgloref{}}|memjustarg}{1197} -\glossaryentry{rand.dist.pois.poisson@ {\memgloterm{rand.dist.pois.poisson}}{\memglodesc{(\ref {rand.dist.pois.poisson})}} {\memgloref{}}|memjustarg}{1197} -\glossaryentry{rand.dist.pois.exp@ {\memgloterm{rand.dist.pois.exp}}{\memglodesc{(\ref {rand.dist.pois.exp})}} {\memgloref{}}|memjustarg}{1198} -\glossaryentry{rand.dist.pois.gamma@ {\memgloterm{rand.dist.pois.gamma}}{\memglodesc{(\ref {rand.dist.pois.gamma})}} {\memgloref{}}|memjustarg}{1199} -\glossaryentry{rand.dist.pois.weibull@ {\memgloterm{rand.dist.pois.weibull}}{\memglodesc{(\ref {rand.dist.pois.weibull})}} {\memgloref{}}|memjustarg}{1200} -\glossaryentry{rand.dist.pois.extreme@ {\memgloterm{rand.dist.pois.extreme}}{\memglodesc{(\ref {rand.dist.pois.extreme})}} {\memgloref{}}|memjustarg}{1200} -\glossaryentry{rand.dist.norm@ {\memgloterm{rand.dist.norm}}{\memglodesc{(\ref {rand.dist.norm})}} {\memgloref{}}|memjustarg}{1201} -\glossaryentry{rand.dist.norm.normal@ {\memgloterm{rand.dist.norm.normal}}{\memglodesc{(\ref {rand.dist.norm.normal})}} {\memgloref{}}|memjustarg}{1201} -\glossaryentry{rand.dist.norm.lognormal@ {\memgloterm{rand.dist.norm.lognormal}}{\memglodesc{(\ref {rand.dist.norm.lognormal})}} {\memgloref{}}|memjustarg}{1202} -\glossaryentry{rand.dist.norm.chisq@ {\memgloterm{rand.dist.norm.chisq}}{\memglodesc{(\ref {rand.dist.norm.chisq})}} {\memgloref{}}|memjustarg}{1203} -\glossaryentry{rand.dist.norm.cauchy@ {\memgloterm{rand.dist.norm.cauchy}}{\memglodesc{(\ref {rand.dist.norm.cauchy})}} {\memgloref{}}|memjustarg}{1203} -\glossaryentry{rand.dist.norm.f@ {\memgloterm{rand.dist.norm.f}}{\memglodesc{(\ref {rand.dist.norm.f})}} {\memgloref{}}|memjustarg}{1204} -\glossaryentry{rand.dist.norm.t@ {\memgloterm{rand.dist.norm.t}}{\memglodesc{(\ref {rand.dist.norm.t})}} {\memgloref{}}|memjustarg}{1205} -\glossaryentry{rand.dist.samp@ {\memgloterm{rand.dist.samp}}{\memglodesc{(\ref {rand.dist.samp})}} {\memgloref{}}|memjustarg}{1205} -\glossaryentry{rand.dist.samp.discrete@ {\memgloterm{rand.dist.samp.discrete}}{\memglodesc{(\ref {rand.dist.samp.discrete})}} {\memgloref{}}|memjustarg}{1205} -\glossaryentry{rand.dist.samp.pconst@ {\memgloterm{rand.dist.samp.pconst}}{\memglodesc{(\ref {rand.dist.samp.pconst})}} {\memgloref{}}|memjustarg}{1207} -\glossaryentry{rand.dist.samp.plinear@ {\memgloterm{rand.dist.samp.plinear}}{\memglodesc{(\ref {rand.dist.samp.plinear})}} {\memgloref{}}|memjustarg}{1208} -\glossaryentry{c.math.rand@ {\memgloterm{c.math.rand}}{\memglodesc{(\ref {c.math.rand})}} {\memgloref{}}|memjustarg}{1210} -\glossaryentry{numarray@ {\memgloterm{numarray}}{\memglodesc{(\ref {numarray})}} {\memgloref{}}|memjustarg}{1210} -\glossaryentry{valarray.syn@ {\memgloterm{valarray.syn}}{\memglodesc{(\ref {valarray.syn})}} {\memgloref{}}|memjustarg}{1210} -\glossaryentry{template.valarray@ {\memgloterm{template.valarray}}{\memglodesc{(\ref {template.valarray})}} {\memgloref{}}|memjustarg}{1213} -\glossaryentry{template.valarray.overview@ {\memgloterm{template.valarray.overview}}{\memglodesc{(\ref {template.valarray.overview})}} {\memgloref{}}|memjustarg}{1213} -\glossaryentry{valarray.cons@ {\memgloterm{valarray.cons}}{\memglodesc{(\ref {valarray.cons})}} {\memgloref{}}|memjustarg}{1214} -\glossaryentry{valarray.assign@ {\memgloterm{valarray.assign}}{\memglodesc{(\ref {valarray.assign})}} {\memgloref{}}|memjustarg}{1215} -\glossaryentry{valarray.access@ {\memgloterm{valarray.access}}{\memglodesc{(\ref {valarray.access})}} {\memgloref{}}|memjustarg}{1216} -\glossaryentry{valarray.sub@ {\memgloterm{valarray.sub}}{\memglodesc{(\ref {valarray.sub})}} {\memgloref{}}|memjustarg}{1216} -\glossaryentry{valarray.unary@ {\memgloterm{valarray.unary}}{\memglodesc{(\ref {valarray.unary})}} {\memgloref{}}|memjustarg}{1217} -\glossaryentry{valarray.cassign@ {\memgloterm{valarray.cassign}}{\memglodesc{(\ref {valarray.cassign})}} {\memgloref{}}|memjustarg}{1218} -\glossaryentry{valarray.members@ {\memgloterm{valarray.members}}{\memglodesc{(\ref {valarray.members})}} {\memgloref{}}|memjustarg}{1218} -\glossaryentry{valarray.nonmembers@ {\memgloterm{valarray.nonmembers}}{\memglodesc{(\ref {valarray.nonmembers})}} {\memgloref{}}|memjustarg}{1219} -\glossaryentry{valarray.binary@ {\memgloterm{valarray.binary}}{\memglodesc{(\ref {valarray.binary})}} {\memgloref{}}|memjustarg}{1219} -\glossaryentry{valarray.comparison@ {\memgloterm{valarray.comparison}}{\memglodesc{(\ref {valarray.comparison})}} {\memgloref{}}|memjustarg}{1220} -\glossaryentry{valarray.transcend@ {\memgloterm{valarray.transcend}}{\memglodesc{(\ref {valarray.transcend})}} {\memgloref{}}|memjustarg}{1221} -\glossaryentry{valarray.special@ {\memgloterm{valarray.special}}{\memglodesc{(\ref {valarray.special})}} {\memgloref{}}|memjustarg}{1222} -\glossaryentry{class.slice@ {\memgloterm{class.slice}}{\memglodesc{(\ref {class.slice})}} {\memgloref{}}|memjustarg}{1222} -\glossaryentry{class.slice.overview@ {\memgloterm{class.slice.overview}}{\memglodesc{(\ref {class.slice.overview})}} {\memgloref{}}|memjustarg}{1222} -\glossaryentry{cons.slice@ {\memgloterm{cons.slice}}{\memglodesc{(\ref {cons.slice})}} {\memgloref{}}|memjustarg}{1222} -\glossaryentry{slice.access@ {\memgloterm{slice.access}}{\memglodesc{(\ref {slice.access})}} {\memgloref{}}|memjustarg}{1222} -\glossaryentry{slice.ops@ {\memgloterm{slice.ops}}{\memglodesc{(\ref {slice.ops})}} {\memgloref{}}|memjustarg}{1222} -\glossaryentry{template.slice.array@ {\memgloterm{template.slice.array}}{\memglodesc{(\ref {template.slice.array})}} {\memgloref{}}|memjustarg}{1223} -\glossaryentry{template.slice.array.overview@ {\memgloterm{template.slice.array.overview}}{\memglodesc{(\ref {template.slice.array.overview})}} {\memgloref{}}|memjustarg}{1223} -\glossaryentry{slice.arr.assign@ {\memgloterm{slice.arr.assign}}{\memglodesc{(\ref {slice.arr.assign})}} {\memgloref{}}|memjustarg}{1223} -\glossaryentry{slice.arr.comp.assign@ {\memgloterm{slice.arr.comp.assign}}{\memglodesc{(\ref {slice.arr.comp.assign})}} {\memgloref{}}|memjustarg}{1223} -\glossaryentry{slice.arr.fill@ {\memgloterm{slice.arr.fill}}{\memglodesc{(\ref {slice.arr.fill})}} {\memgloref{}}|memjustarg}{1223} -\glossaryentry{class.gslice@ {\memgloterm{class.gslice}}{\memglodesc{(\ref {class.gslice})}} {\memgloref{}}|memjustarg}{1224} -\glossaryentry{class.gslice.overview@ {\memgloterm{class.gslice.overview}}{\memglodesc{(\ref {class.gslice.overview})}} {\memgloref{}}|memjustarg}{1224} -\glossaryentry{gslice.cons@ {\memgloterm{gslice.cons}}{\memglodesc{(\ref {gslice.cons})}} {\memgloref{}}|memjustarg}{1225} -\glossaryentry{gslice.access@ {\memgloterm{gslice.access}}{\memglodesc{(\ref {gslice.access})}} {\memgloref{}}|memjustarg}{1225} -\glossaryentry{template.gslice.array@ {\memgloterm{template.gslice.array}}{\memglodesc{(\ref {template.gslice.array})}} {\memgloref{}}|memjustarg}{1225} -\glossaryentry{template.gslice.array.overview@ {\memgloterm{template.gslice.array.overview}}{\memglodesc{(\ref {template.gslice.array.overview})}} {\memgloref{}}|memjustarg}{1225} -\glossaryentry{gslice.array.assign@ {\memgloterm{gslice.array.assign}}{\memglodesc{(\ref {gslice.array.assign})}} {\memgloref{}}|memjustarg}{1226} -\glossaryentry{gslice.array.comp.assign@ {\memgloterm{gslice.array.comp.assign}}{\memglodesc{(\ref {gslice.array.comp.assign})}} {\memgloref{}}|memjustarg}{1226} -\glossaryentry{gslice.array.fill@ {\memgloterm{gslice.array.fill}}{\memglodesc{(\ref {gslice.array.fill})}} {\memgloref{}}|memjustarg}{1226} -\glossaryentry{template.mask.array@ {\memgloterm{template.mask.array}}{\memglodesc{(\ref {template.mask.array})}} {\memgloref{}}|memjustarg}{1226} -\glossaryentry{template.mask.array.overview@ {\memgloterm{template.mask.array.overview}}{\memglodesc{(\ref {template.mask.array.overview})}} {\memgloref{}}|memjustarg}{1226} -\glossaryentry{mask.array.assign@ {\memgloterm{mask.array.assign}}{\memglodesc{(\ref {mask.array.assign})}} {\memgloref{}}|memjustarg}{1227} -\glossaryentry{mask.array.comp.assign@ {\memgloterm{mask.array.comp.assign}}{\memglodesc{(\ref {mask.array.comp.assign})}} {\memgloref{}}|memjustarg}{1227} -\glossaryentry{mask.array.fill@ {\memgloterm{mask.array.fill}}{\memglodesc{(\ref {mask.array.fill})}} {\memgloref{}}|memjustarg}{1227} -\glossaryentry{template.indirect.array@ {\memgloterm{template.indirect.array}}{\memglodesc{(\ref {template.indirect.array})}} {\memgloref{}}|memjustarg}{1227} -\glossaryentry{template.indirect.array.overview@ {\memgloterm{template.indirect.array.overview}}{\memglodesc{(\ref {template.indirect.array.overview})}} {\memgloref{}}|memjustarg}{1227} -\glossaryentry{indirect.array.assign@ {\memgloterm{indirect.array.assign}}{\memglodesc{(\ref {indirect.array.assign})}} {\memgloref{}}|memjustarg}{1228} -\glossaryentry{indirect.array.comp.assign@ {\memgloterm{indirect.array.comp.assign}}{\memglodesc{(\ref {indirect.array.comp.assign})}} {\memgloref{}}|memjustarg}{1228} -\glossaryentry{indirect.array.fill@ {\memgloterm{indirect.array.fill}}{\memglodesc{(\ref {indirect.array.fill})}} {\memgloref{}}|memjustarg}{1228} -\glossaryentry{valarray.range@ {\memgloterm{valarray.range}}{\memglodesc{(\ref {valarray.range})}} {\memgloref{}}|memjustarg}{1228} -\glossaryentry{c.math@ {\memgloterm{c.math}}{\memglodesc{(\ref {c.math})}} {\memgloref{}}|memjustarg}{1229} -\glossaryentry{cmath.syn@ {\memgloterm{cmath.syn}}{\memglodesc{(\ref {cmath.syn})}} {\memgloref{}}|memjustarg}{1229} -\glossaryentry{c.math.abs@ {\memgloterm{c.math.abs}}{\memglodesc{(\ref {c.math.abs})}} {\memgloref{}}|memjustarg}{1237} -\glossaryentry{c.math.hypot3@ {\memgloterm{c.math.hypot3}}{\memglodesc{(\ref {c.math.hypot3})}} {\memgloref{}}|memjustarg}{1238} -\glossaryentry{c.math.lerp@ {\memgloterm{c.math.lerp}}{\memglodesc{(\ref {c.math.lerp})}} {\memgloref{}}|memjustarg}{1238} -\glossaryentry{c.math.fpclass@ {\memgloterm{c.math.fpclass}}{\memglodesc{(\ref {c.math.fpclass})}} {\memgloref{}}|memjustarg}{1238} -\glossaryentry{sf.cmath@ {\memgloterm{sf.cmath}}{\memglodesc{(\ref {sf.cmath})}} {\memgloref{}}|memjustarg}{1238} -\glossaryentry{sf.cmath.general@ {\memgloterm{sf.cmath.general}}{\memglodesc{(\ref {sf.cmath.general})}} {\memgloref{}}|memjustarg}{1238} -\glossaryentry{sf.cmath.assoc.laguerre@ {\memgloterm{sf.cmath.assoc.laguerre}}{\memglodesc{(\ref {sf.cmath.assoc.laguerre})}} {\memgloref{}}|memjustarg}{1238} -\glossaryentry{sf.cmath.assoc.legendre@ {\memgloterm{sf.cmath.assoc.legendre}}{\memglodesc{(\ref {sf.cmath.assoc.legendre})}} {\memgloref{}}|memjustarg}{1239} -\glossaryentry{sf.cmath.beta@ {\memgloterm{sf.cmath.beta}}{\memglodesc{(\ref {sf.cmath.beta})}} {\memgloref{}}|memjustarg}{1239} -\glossaryentry{sf.cmath.comp.ellint.1@ {\memgloterm{sf.cmath.comp.ellint.1}}{\memglodesc{(\ref {sf.cmath.comp.ellint.1})}} {\memgloref{}}|memjustarg}{1239} -\glossaryentry{sf.cmath.comp.ellint.2@ {\memgloterm{sf.cmath.comp.ellint.2}}{\memglodesc{(\ref {sf.cmath.comp.ellint.2})}} {\memgloref{}}|memjustarg}{1239} -\glossaryentry{sf.cmath.comp.ellint.3@ {\memgloterm{sf.cmath.comp.ellint.3}}{\memglodesc{(\ref {sf.cmath.comp.ellint.3})}} {\memgloref{}}|memjustarg}{1240} -\glossaryentry{sf.cmath.cyl.bessel.i@ {\memgloterm{sf.cmath.cyl.bessel.i}}{\memglodesc{(\ref {sf.cmath.cyl.bessel.i})}} {\memgloref{}}|memjustarg}{1240} -\glossaryentry{sf.cmath.cyl.bessel.j@ {\memgloterm{sf.cmath.cyl.bessel.j}}{\memglodesc{(\ref {sf.cmath.cyl.bessel.j})}} {\memgloref{}}|memjustarg}{1240} -\glossaryentry{sf.cmath.cyl.bessel.k@ {\memgloterm{sf.cmath.cyl.bessel.k}}{\memglodesc{(\ref {sf.cmath.cyl.bessel.k})}} {\memgloref{}}|memjustarg}{1240} -\glossaryentry{sf.cmath.cyl.neumann@ {\memgloterm{sf.cmath.cyl.neumann}}{\memglodesc{(\ref {sf.cmath.cyl.neumann})}} {\memgloref{}}|memjustarg}{1241} -\glossaryentry{sf.cmath.ellint.1@ {\memgloterm{sf.cmath.ellint.1}}{\memglodesc{(\ref {sf.cmath.ellint.1})}} {\memgloref{}}|memjustarg}{1241} -\glossaryentry{sf.cmath.ellint.2@ {\memgloterm{sf.cmath.ellint.2}}{\memglodesc{(\ref {sf.cmath.ellint.2})}} {\memgloref{}}|memjustarg}{1241} -\glossaryentry{sf.cmath.ellint.3@ {\memgloterm{sf.cmath.ellint.3}}{\memglodesc{(\ref {sf.cmath.ellint.3})}} {\memgloref{}}|memjustarg}{1241} -\glossaryentry{sf.cmath.expint@ {\memgloterm{sf.cmath.expint}}{\memglodesc{(\ref {sf.cmath.expint})}} {\memgloref{}}|memjustarg}{1242} -\glossaryentry{sf.cmath.hermite@ {\memgloterm{sf.cmath.hermite}}{\memglodesc{(\ref {sf.cmath.hermite})}} {\memgloref{}}|memjustarg}{1242} -\glossaryentry{sf.cmath.laguerre@ {\memgloterm{sf.cmath.laguerre}}{\memglodesc{(\ref {sf.cmath.laguerre})}} {\memgloref{}}|memjustarg}{1242} -\glossaryentry{sf.cmath.legendre@ {\memgloterm{sf.cmath.legendre}}{\memglodesc{(\ref {sf.cmath.legendre})}} {\memgloref{}}|memjustarg}{1242} -\glossaryentry{sf.cmath.riemann.zeta@ {\memgloterm{sf.cmath.riemann.zeta}}{\memglodesc{(\ref {sf.cmath.riemann.zeta})}} {\memgloref{}}|memjustarg}{1242} -\glossaryentry{sf.cmath.sph.bessel@ {\memgloterm{sf.cmath.sph.bessel}}{\memglodesc{(\ref {sf.cmath.sph.bessel})}} {\memgloref{}}|memjustarg}{1243} -\glossaryentry{sf.cmath.sph.legendre@ {\memgloterm{sf.cmath.sph.legendre}}{\memglodesc{(\ref {sf.cmath.sph.legendre})}} {\memgloref{}}|memjustarg}{1243} -\glossaryentry{sf.cmath.sph.neumann@ {\memgloterm{sf.cmath.sph.neumann}}{\memglodesc{(\ref {sf.cmath.sph.neumann})}} {\memgloref{}}|memjustarg}{1243} -\glossaryentry{numbers@ {\memgloterm{numbers}}{\memglodesc{(\ref {numbers})}} {\memgloref{}}|memjustarg}{1244} -\glossaryentry{numbers.syn@ {\memgloterm{numbers.syn}}{\memglodesc{(\ref {numbers.syn})}} {\memgloref{}}|memjustarg}{1244} -\glossaryentry{math.constants@ {\memgloterm{math.constants}}{\memglodesc{(\ref {math.constants})}} {\memgloref{}}|memjustarg}{1244} -\glossaryentry{time@ {\memgloterm{time}}{\memglodesc{(\ref {time})}} {\memgloref{}}|memjustarg}{1245} -\glossaryentry{time.general@ {\memgloterm{time.general}}{\memglodesc{(\ref {time.general})}} {\memgloref{}}|memjustarg}{1245} -\glossaryentry{time.syn@ {\memgloterm{time.syn}}{\memglodesc{(\ref {time.syn})}} {\memgloref{}}|memjustarg}{1245} -\glossaryentry{time.clock.req@ {\memgloterm{time.clock.req}}{\memglodesc{(\ref {time.clock.req})}} {\memgloref{}}|memjustarg}{1259} -\glossaryentry{time.traits@ {\memgloterm{time.traits}}{\memglodesc{(\ref {time.traits})}} {\memgloref{}}|memjustarg}{1259} -\glossaryentry{time.traits.is.fp@ {\memgloterm{time.traits.is.fp}}{\memglodesc{(\ref {time.traits.is.fp})}} {\memgloref{}}|memjustarg}{1259} -\glossaryentry{time.traits.duration.values@ {\memgloterm{time.traits.duration.values}}{\memglodesc{(\ref {time.traits.duration.values})}} {\memgloref{}}|memjustarg}{1260} -\glossaryentry{time.traits.specializations@ {\memgloterm{time.traits.specializations}}{\memglodesc{(\ref {time.traits.specializations})}} {\memgloref{}}|memjustarg}{1260} -\glossaryentry{time.traits.is.clock@ {\memgloterm{time.traits.is.clock}}{\memglodesc{(\ref {time.traits.is.clock})}} {\memgloref{}}|memjustarg}{1260} -\glossaryentry{time.duration@ {\memgloterm{time.duration}}{\memglodesc{(\ref {time.duration})}} {\memgloref{}}|memjustarg}{1261} -\glossaryentry{time.duration.general@ {\memgloterm{time.duration.general}}{\memglodesc{(\ref {time.duration.general})}} {\memgloref{}}|memjustarg}{1261} -\glossaryentry{time.duration.cons@ {\memgloterm{time.duration.cons}}{\memglodesc{(\ref {time.duration.cons})}} {\memgloref{}}|memjustarg}{1262} -\glossaryentry{time.duration.observer@ {\memgloterm{time.duration.observer}}{\memglodesc{(\ref {time.duration.observer})}} {\memgloref{}}|memjustarg}{1262} -\glossaryentry{time.duration.arithmetic@ {\memgloterm{time.duration.arithmetic}}{\memglodesc{(\ref {time.duration.arithmetic})}} {\memgloref{}}|memjustarg}{1262} -\glossaryentry{time.duration.special@ {\memgloterm{time.duration.special}}{\memglodesc{(\ref {time.duration.special})}} {\memgloref{}}|memjustarg}{1263} -\glossaryentry{time.duration.nonmember@ {\memgloterm{time.duration.nonmember}}{\memglodesc{(\ref {time.duration.nonmember})}} {\memgloref{}}|memjustarg}{1263} -\glossaryentry{time.duration.comparisons@ {\memgloterm{time.duration.comparisons}}{\memglodesc{(\ref {time.duration.comparisons})}} {\memgloref{}}|memjustarg}{1264} -\glossaryentry{time.duration.cast@ {\memgloterm{time.duration.cast}}{\memglodesc{(\ref {time.duration.cast})}} {\memgloref{}}|memjustarg}{1265} -\glossaryentry{time.duration.literals@ {\memgloterm{time.duration.literals}}{\memglodesc{(\ref {time.duration.literals})}} {\memgloref{}}|memjustarg}{1266} -\glossaryentry{time.duration.alg@ {\memgloterm{time.duration.alg}}{\memglodesc{(\ref {time.duration.alg})}} {\memgloref{}}|memjustarg}{1266} -\glossaryentry{time.duration.io@ {\memgloterm{time.duration.io}}{\memglodesc{(\ref {time.duration.io})}} {\memgloref{}}|memjustarg}{1267} -\glossaryentry{time.point@ {\memgloterm{time.point}}{\memglodesc{(\ref {time.point})}} {\memgloref{}}|memjustarg}{1268} -\glossaryentry{time.point.general@ {\memgloterm{time.point.general}}{\memglodesc{(\ref {time.point.general})}} {\memgloref{}}|memjustarg}{1268} -\glossaryentry{time.point.cons@ {\memgloterm{time.point.cons}}{\memglodesc{(\ref {time.point.cons})}} {\memgloref{}}|memjustarg}{1268} -\glossaryentry{time.point.observer@ {\memgloterm{time.point.observer}}{\memglodesc{(\ref {time.point.observer})}} {\memgloref{}}|memjustarg}{1269} -\glossaryentry{time.point.arithmetic@ {\memgloterm{time.point.arithmetic}}{\memglodesc{(\ref {time.point.arithmetic})}} {\memgloref{}}|memjustarg}{1269} -\glossaryentry{time.point.special@ {\memgloterm{time.point.special}}{\memglodesc{(\ref {time.point.special})}} {\memgloref{}}|memjustarg}{1269} -\glossaryentry{time.point.nonmember@ {\memgloterm{time.point.nonmember}}{\memglodesc{(\ref {time.point.nonmember})}} {\memgloref{}}|memjustarg}{1269} -\glossaryentry{time.point.comparisons@ {\memgloterm{time.point.comparisons}}{\memglodesc{(\ref {time.point.comparisons})}} {\memgloref{}}|memjustarg}{1270} -\glossaryentry{time.point.cast@ {\memgloterm{time.point.cast}}{\memglodesc{(\ref {time.point.cast})}} {\memgloref{}}|memjustarg}{1270} -\glossaryentry{time.clock@ {\memgloterm{time.clock}}{\memglodesc{(\ref {time.clock})}} {\memgloref{}}|memjustarg}{1271} -\glossaryentry{time.clock.general@ {\memgloterm{time.clock.general}}{\memglodesc{(\ref {time.clock.general})}} {\memgloref{}}|memjustarg}{1271} -\glossaryentry{time.clock.system@ {\memgloterm{time.clock.system}}{\memglodesc{(\ref {time.clock.system})}} {\memgloref{}}|memjustarg}{1271} -\glossaryentry{time.clock.system.overview@ {\memgloterm{time.clock.system.overview}}{\memglodesc{(\ref {time.clock.system.overview})}} {\memgloref{}}|memjustarg}{1271} -\glossaryentry{time.clock.system.members@ {\memgloterm{time.clock.system.members}}{\memglodesc{(\ref {time.clock.system.members})}} {\memgloref{}}|memjustarg}{1271} -\glossaryentry{time.clock.system.nonmembers@ {\memgloterm{time.clock.system.nonmembers}}{\memglodesc{(\ref {time.clock.system.nonmembers})}} {\memgloref{}}|memjustarg}{1271} -\glossaryentry{time.clock.utc@ {\memgloterm{time.clock.utc}}{\memglodesc{(\ref {time.clock.utc})}} {\memgloref{}}|memjustarg}{1272} -\glossaryentry{time.clock.utc.overview@ {\memgloterm{time.clock.utc.overview}}{\memglodesc{(\ref {time.clock.utc.overview})}} {\memgloref{}}|memjustarg}{1272} -\glossaryentry{time.clock.utc.members@ {\memgloterm{time.clock.utc.members}}{\memglodesc{(\ref {time.clock.utc.members})}} {\memgloref{}}|memjustarg}{1273} -\glossaryentry{time.clock.utc.nonmembers@ {\memgloterm{time.clock.utc.nonmembers}}{\memglodesc{(\ref {time.clock.utc.nonmembers})}} {\memgloref{}}|memjustarg}{1273} -\glossaryentry{time.clock.tai@ {\memgloterm{time.clock.tai}}{\memglodesc{(\ref {time.clock.tai})}} {\memgloref{}}|memjustarg}{1274} -\glossaryentry{time.clock.tai.overview@ {\memgloterm{time.clock.tai.overview}}{\memglodesc{(\ref {time.clock.tai.overview})}} {\memgloref{}}|memjustarg}{1274} -\glossaryentry{time.clock.tai.members@ {\memgloterm{time.clock.tai.members}}{\memglodesc{(\ref {time.clock.tai.members})}} {\memgloref{}}|memjustarg}{1275} -\glossaryentry{time.clock.tai.nonmembers@ {\memgloterm{time.clock.tai.nonmembers}}{\memglodesc{(\ref {time.clock.tai.nonmembers})}} {\memgloref{}}|memjustarg}{1275} -\glossaryentry{time.clock.gps@ {\memgloterm{time.clock.gps}}{\memglodesc{(\ref {time.clock.gps})}} {\memgloref{}}|memjustarg}{1275} -\glossaryentry{time.clock.gps.overview@ {\memgloterm{time.clock.gps.overview}}{\memglodesc{(\ref {time.clock.gps.overview})}} {\memgloref{}}|memjustarg}{1275} -\glossaryentry{time.clock.gps.members@ {\memgloterm{time.clock.gps.members}}{\memglodesc{(\ref {time.clock.gps.members})}} {\memgloref{}}|memjustarg}{1276} -\glossaryentry{time.clock.gps.nonmembers@ {\memgloterm{time.clock.gps.nonmembers}}{\memglodesc{(\ref {time.clock.gps.nonmembers})}} {\memgloref{}}|memjustarg}{1276} -\glossaryentry{time.clock.file@ {\memgloterm{time.clock.file}}{\memglodesc{(\ref {time.clock.file})}} {\memgloref{}}|memjustarg}{1277} -\glossaryentry{time.clock.file.overview@ {\memgloterm{time.clock.file.overview}}{\memglodesc{(\ref {time.clock.file.overview})}} {\memgloref{}}|memjustarg}{1277} -\glossaryentry{time.clock.file.members@ {\memgloterm{time.clock.file.members}}{\memglodesc{(\ref {time.clock.file.members})}} {\memgloref{}}|memjustarg}{1277} -\glossaryentry{time.clock.file.nonmembers@ {\memgloterm{time.clock.file.nonmembers}}{\memglodesc{(\ref {time.clock.file.nonmembers})}} {\memgloref{}}|memjustarg}{1277} -\glossaryentry{time.clock.steady@ {\memgloterm{time.clock.steady}}{\memglodesc{(\ref {time.clock.steady})}} {\memgloref{}}|memjustarg}{1278} -\glossaryentry{time.clock.hires@ {\memgloterm{time.clock.hires}}{\memglodesc{(\ref {time.clock.hires})}} {\memgloref{}}|memjustarg}{1278} -\glossaryentry{time.clock.local@ {\memgloterm{time.clock.local}}{\memglodesc{(\ref {time.clock.local})}} {\memgloref{}}|memjustarg}{1278} -\glossaryentry{time.clock.cast@ {\memgloterm{time.clock.cast}}{\memglodesc{(\ref {time.clock.cast})}} {\memgloref{}}|memjustarg}{1279} -\glossaryentry{time.clock.conv@ {\memgloterm{time.clock.conv}}{\memglodesc{(\ref {time.clock.conv})}} {\memgloref{}}|memjustarg}{1279} -\glossaryentry{time.clock.cast.id@ {\memgloterm{time.clock.cast.id}}{\memglodesc{(\ref {time.clock.cast.id})}} {\memgloref{}}|memjustarg}{1279} -\glossaryentry{time.clock.cast.sys.utc@ {\memgloterm{time.clock.cast.sys.utc}}{\memglodesc{(\ref {time.clock.cast.sys.utc})}} {\memgloref{}}|memjustarg}{1280} -\glossaryentry{time.clock.cast.sys@ {\memgloterm{time.clock.cast.sys}}{\memglodesc{(\ref {time.clock.cast.sys})}} {\memgloref{}}|memjustarg}{1280} -\glossaryentry{time.clock.cast.utc@ {\memgloterm{time.clock.cast.utc}}{\memglodesc{(\ref {time.clock.cast.utc})}} {\memgloref{}}|memjustarg}{1281} -\glossaryentry{time.clock.cast.fn@ {\memgloterm{time.clock.cast.fn}}{\memglodesc{(\ref {time.clock.cast.fn})}} {\memgloref{}}|memjustarg}{1281} -\glossaryentry{time.cal@ {\memgloterm{time.cal}}{\memglodesc{(\ref {time.cal})}} {\memgloref{}}|memjustarg}{1281} -\glossaryentry{time.cal.general@ {\memgloterm{time.cal.general}}{\memglodesc{(\ref {time.cal.general})}} {\memgloref{}}|memjustarg}{1281} -\glossaryentry{time.cal.last@ {\memgloterm{time.cal.last}}{\memglodesc{(\ref {time.cal.last})}} {\memgloref{}}|memjustarg}{1282} -\glossaryentry{time.cal.day@ {\memgloterm{time.cal.day}}{\memglodesc{(\ref {time.cal.day})}} {\memgloref{}}|memjustarg}{1282} -\glossaryentry{time.cal.day.overview@ {\memgloterm{time.cal.day.overview}}{\memglodesc{(\ref {time.cal.day.overview})}} {\memgloref{}}|memjustarg}{1282} -\glossaryentry{time.cal.day.members@ {\memgloterm{time.cal.day.members}}{\memglodesc{(\ref {time.cal.day.members})}} {\memgloref{}}|memjustarg}{1282} -\glossaryentry{time.cal.day.nonmembers@ {\memgloterm{time.cal.day.nonmembers}}{\memglodesc{(\ref {time.cal.day.nonmembers})}} {\memgloref{}}|memjustarg}{1283} -\glossaryentry{time.cal.month@ {\memgloterm{time.cal.month}}{\memglodesc{(\ref {time.cal.month})}} {\memgloref{}}|memjustarg}{1284} -\glossaryentry{time.cal.month.overview@ {\memgloterm{time.cal.month.overview}}{\memglodesc{(\ref {time.cal.month.overview})}} {\memgloref{}}|memjustarg}{1284} -\glossaryentry{time.cal.month.members@ {\memgloterm{time.cal.month.members}}{\memglodesc{(\ref {time.cal.month.members})}} {\memgloref{}}|memjustarg}{1284} -\glossaryentry{time.cal.month.nonmembers@ {\memgloterm{time.cal.month.nonmembers}}{\memglodesc{(\ref {time.cal.month.nonmembers})}} {\memgloref{}}|memjustarg}{1285} -\glossaryentry{time.cal.year@ {\memgloterm{time.cal.year}}{\memglodesc{(\ref {time.cal.year})}} {\memgloref{}}|memjustarg}{1286} -\glossaryentry{time.cal.year.overview@ {\memgloterm{time.cal.year.overview}}{\memglodesc{(\ref {time.cal.year.overview})}} {\memgloref{}}|memjustarg}{1286} -\glossaryentry{time.cal.year.members@ {\memgloterm{time.cal.year.members}}{\memglodesc{(\ref {time.cal.year.members})}} {\memgloref{}}|memjustarg}{1286} -\glossaryentry{time.cal.year.nonmembers@ {\memgloterm{time.cal.year.nonmembers}}{\memglodesc{(\ref {time.cal.year.nonmembers})}} {\memgloref{}}|memjustarg}{1287} -\glossaryentry{time.cal.wd@ {\memgloterm{time.cal.wd}}{\memglodesc{(\ref {time.cal.wd})}} {\memgloref{}}|memjustarg}{1288} -\glossaryentry{time.cal.wd.overview@ {\memgloterm{time.cal.wd.overview}}{\memglodesc{(\ref {time.cal.wd.overview})}} {\memgloref{}}|memjustarg}{1288} -\glossaryentry{time.cal.wd.members@ {\memgloterm{time.cal.wd.members}}{\memglodesc{(\ref {time.cal.wd.members})}} {\memgloref{}}|memjustarg}{1288} -\glossaryentry{time.cal.wd.nonmembers@ {\memgloterm{time.cal.wd.nonmembers}}{\memglodesc{(\ref {time.cal.wd.nonmembers})}} {\memgloref{}}|memjustarg}{1289} -\glossaryentry{time.cal.wdidx@ {\memgloterm{time.cal.wdidx}}{\memglodesc{(\ref {time.cal.wdidx})}} {\memgloref{}}|memjustarg}{1290} -\glossaryentry{time.cal.wdidx.overview@ {\memgloterm{time.cal.wdidx.overview}}{\memglodesc{(\ref {time.cal.wdidx.overview})}} {\memgloref{}}|memjustarg}{1290} -\glossaryentry{time.cal.wdidx.members@ {\memgloterm{time.cal.wdidx.members}}{\memglodesc{(\ref {time.cal.wdidx.members})}} {\memgloref{}}|memjustarg}{1291} -\glossaryentry{time.cal.wdidx.nonmembers@ {\memgloterm{time.cal.wdidx.nonmembers}}{\memglodesc{(\ref {time.cal.wdidx.nonmembers})}} {\memgloref{}}|memjustarg}{1291} -\glossaryentry{time.cal.wdlast@ {\memgloterm{time.cal.wdlast}}{\memglodesc{(\ref {time.cal.wdlast})}} {\memgloref{}}|memjustarg}{1291} -\glossaryentry{time.cal.wdlast.overview@ {\memgloterm{time.cal.wdlast.overview}}{\memglodesc{(\ref {time.cal.wdlast.overview})}} {\memgloref{}}|memjustarg}{1291} -\glossaryentry{time.cal.wdlast.members@ {\memgloterm{time.cal.wdlast.members}}{\memglodesc{(\ref {time.cal.wdlast.members})}} {\memgloref{}}|memjustarg}{1292} -\glossaryentry{time.cal.wdlast.nonmembers@ {\memgloterm{time.cal.wdlast.nonmembers}}{\memglodesc{(\ref {time.cal.wdlast.nonmembers})}} {\memgloref{}}|memjustarg}{1292} -\glossaryentry{time.cal.md@ {\memgloterm{time.cal.md}}{\memglodesc{(\ref {time.cal.md})}} {\memgloref{}}|memjustarg}{1292} -\glossaryentry{time.cal.md.overview@ {\memgloterm{time.cal.md.overview}}{\memglodesc{(\ref {time.cal.md.overview})}} {\memgloref{}}|memjustarg}{1292} -\glossaryentry{time.cal.md.members@ {\memgloterm{time.cal.md.members}}{\memglodesc{(\ref {time.cal.md.members})}} {\memgloref{}}|memjustarg}{1292} -\glossaryentry{time.cal.md.nonmembers@ {\memgloterm{time.cal.md.nonmembers}}{\memglodesc{(\ref {time.cal.md.nonmembers})}} {\memgloref{}}|memjustarg}{1293} -\glossaryentry{time.cal.mdlast@ {\memgloterm{time.cal.mdlast}}{\memglodesc{(\ref {time.cal.mdlast})}} {\memgloref{}}|memjustarg}{1293} -\glossaryentry{time.cal.mwd@ {\memgloterm{time.cal.mwd}}{\memglodesc{(\ref {time.cal.mwd})}} {\memgloref{}}|memjustarg}{1294} -\glossaryentry{time.cal.mwd.overview@ {\memgloterm{time.cal.mwd.overview}}{\memglodesc{(\ref {time.cal.mwd.overview})}} {\memgloref{}}|memjustarg}{1294} -\glossaryentry{time.cal.mwd.members@ {\memgloterm{time.cal.mwd.members}}{\memglodesc{(\ref {time.cal.mwd.members})}} {\memgloref{}}|memjustarg}{1294} -\glossaryentry{time.cal.mwd.nonmembers@ {\memgloterm{time.cal.mwd.nonmembers}}{\memglodesc{(\ref {time.cal.mwd.nonmembers})}} {\memgloref{}}|memjustarg}{1294} -\glossaryentry{time.cal.mwdlast@ {\memgloterm{time.cal.mwdlast}}{\memglodesc{(\ref {time.cal.mwdlast})}} {\memgloref{}}|memjustarg}{1295} -\glossaryentry{time.cal.mwdlast.overview@ {\memgloterm{time.cal.mwdlast.overview}}{\memglodesc{(\ref {time.cal.mwdlast.overview})}} {\memgloref{}}|memjustarg}{1295} -\glossaryentry{time.cal.mwdlast.members@ {\memgloterm{time.cal.mwdlast.members}}{\memglodesc{(\ref {time.cal.mwdlast.members})}} {\memgloref{}}|memjustarg}{1295} -\glossaryentry{time.cal.mwdlast.nonmembers@ {\memgloterm{time.cal.mwdlast.nonmembers}}{\memglodesc{(\ref {time.cal.mwdlast.nonmembers})}} {\memgloref{}}|memjustarg}{1295} -\glossaryentry{time.cal.ym@ {\memgloterm{time.cal.ym}}{\memglodesc{(\ref {time.cal.ym})}} {\memgloref{}}|memjustarg}{1296} -\glossaryentry{time.cal.ym.overview@ {\memgloterm{time.cal.ym.overview}}{\memglodesc{(\ref {time.cal.ym.overview})}} {\memgloref{}}|memjustarg}{1296} -\glossaryentry{time.cal.ym.members@ {\memgloterm{time.cal.ym.members}}{\memglodesc{(\ref {time.cal.ym.members})}} {\memgloref{}}|memjustarg}{1296} -\glossaryentry{time.cal.ym.nonmembers@ {\memgloterm{time.cal.ym.nonmembers}}{\memglodesc{(\ref {time.cal.ym.nonmembers})}} {\memgloref{}}|memjustarg}{1297} -\glossaryentry{time.cal.ymd@ {\memgloterm{time.cal.ymd}}{\memglodesc{(\ref {time.cal.ymd})}} {\memgloref{}}|memjustarg}{1298} -\glossaryentry{time.cal.ymd.overview@ {\memgloterm{time.cal.ymd.overview}}{\memglodesc{(\ref {time.cal.ymd.overview})}} {\memgloref{}}|memjustarg}{1298} -\glossaryentry{time.cal.ymd.members@ {\memgloterm{time.cal.ymd.members}}{\memglodesc{(\ref {time.cal.ymd.members})}} {\memgloref{}}|memjustarg}{1298} -\glossaryentry{time.cal.ymd.nonmembers@ {\memgloterm{time.cal.ymd.nonmembers}}{\memglodesc{(\ref {time.cal.ymd.nonmembers})}} {\memgloref{}}|memjustarg}{1300} -\glossaryentry{time.cal.ymdlast@ {\memgloterm{time.cal.ymdlast}}{\memglodesc{(\ref {time.cal.ymdlast})}} {\memgloref{}}|memjustarg}{1301} -\glossaryentry{time.cal.ymdlast.overview@ {\memgloterm{time.cal.ymdlast.overview}}{\memglodesc{(\ref {time.cal.ymdlast.overview})}} {\memgloref{}}|memjustarg}{1301} -\glossaryentry{time.cal.ymdlast.members@ {\memgloterm{time.cal.ymdlast.members}}{\memglodesc{(\ref {time.cal.ymdlast.members})}} {\memgloref{}}|memjustarg}{1301} -\glossaryentry{time.cal.ymdlast.nonmembers@ {\memgloterm{time.cal.ymdlast.nonmembers}}{\memglodesc{(\ref {time.cal.ymdlast.nonmembers})}} {\memgloref{}}|memjustarg}{1302} -\glossaryentry{time.cal.ymwd@ {\memgloterm{time.cal.ymwd}}{\memglodesc{(\ref {time.cal.ymwd})}} {\memgloref{}}|memjustarg}{1303} -\glossaryentry{time.cal.ymwd.overview@ {\memgloterm{time.cal.ymwd.overview}}{\memglodesc{(\ref {time.cal.ymwd.overview})}} {\memgloref{}}|memjustarg}{1303} -\glossaryentry{time.cal.ymwd.members@ {\memgloterm{time.cal.ymwd.members}}{\memglodesc{(\ref {time.cal.ymwd.members})}} {\memgloref{}}|memjustarg}{1304} -\glossaryentry{time.cal.ymwd.nonmembers@ {\memgloterm{time.cal.ymwd.nonmembers}}{\memglodesc{(\ref {time.cal.ymwd.nonmembers})}} {\memgloref{}}|memjustarg}{1305} -\glossaryentry{time.cal.ymwdlast@ {\memgloterm{time.cal.ymwdlast}}{\memglodesc{(\ref {time.cal.ymwdlast})}} {\memgloref{}}|memjustarg}{1305} -\glossaryentry{time.cal.ymwdlast.overview@ {\memgloterm{time.cal.ymwdlast.overview}}{\memglodesc{(\ref {time.cal.ymwdlast.overview})}} {\memgloref{}}|memjustarg}{1305} -\glossaryentry{time.cal.ymwdlast.members@ {\memgloterm{time.cal.ymwdlast.members}}{\memglodesc{(\ref {time.cal.ymwdlast.members})}} {\memgloref{}}|memjustarg}{1306} -\glossaryentry{time.cal.ymwdlast.nonmembers@ {\memgloterm{time.cal.ymwdlast.nonmembers}}{\memglodesc{(\ref {time.cal.ymwdlast.nonmembers})}} {\memgloref{}}|memjustarg}{1307} -\glossaryentry{time.cal.operators@ {\memgloterm{time.cal.operators}}{\memglodesc{(\ref {time.cal.operators})}} {\memgloref{}}|memjustarg}{1308} -\glossaryentry{time.hms@ {\memgloterm{time.hms}}{\memglodesc{(\ref {time.hms})}} {\memgloref{}}|memjustarg}{1311} -\glossaryentry{time.hms.overview@ {\memgloterm{time.hms.overview}}{\memglodesc{(\ref {time.hms.overview})}} {\memgloref{}}|memjustarg}{1311} -\glossaryentry{time.hms.members@ {\memgloterm{time.hms.members}}{\memglodesc{(\ref {time.hms.members})}} {\memgloref{}}|memjustarg}{1311} -\glossaryentry{time.hms.nonmembers@ {\memgloterm{time.hms.nonmembers}}{\memglodesc{(\ref {time.hms.nonmembers})}} {\memgloref{}}|memjustarg}{1313} -\glossaryentry{time.12@ {\memgloterm{time.12}}{\memglodesc{(\ref {time.12})}} {\memgloref{}}|memjustarg}{1313} -\glossaryentry{time.zone@ {\memgloterm{time.zone}}{\memglodesc{(\ref {time.zone})}} {\memgloref{}}|memjustarg}{1313} -\glossaryentry{time.zone.general@ {\memgloterm{time.zone.general}}{\memglodesc{(\ref {time.zone.general})}} {\memgloref{}}|memjustarg}{1313} -\glossaryentry{time.zone.db@ {\memgloterm{time.zone.db}}{\memglodesc{(\ref {time.zone.db})}} {\memgloref{}}|memjustarg}{1313} -\glossaryentry{time.zone.db.tzdb@ {\memgloterm{time.zone.db.tzdb}}{\memglodesc{(\ref {time.zone.db.tzdb})}} {\memgloref{}}|memjustarg}{1313} -\glossaryentry{time.zone.db.list@ {\memgloterm{time.zone.db.list}}{\memglodesc{(\ref {time.zone.db.list})}} {\memgloref{}}|memjustarg}{1314} -\glossaryentry{time.zone.db.access@ {\memgloterm{time.zone.db.access}}{\memglodesc{(\ref {time.zone.db.access})}} {\memgloref{}}|memjustarg}{1315} -\glossaryentry{time.zone.db.remote@ {\memgloterm{time.zone.db.remote}}{\memglodesc{(\ref {time.zone.db.remote})}} {\memgloref{}}|memjustarg}{1315} -\glossaryentry{time.zone.exception@ {\memgloterm{time.zone.exception}}{\memglodesc{(\ref {time.zone.exception})}} {\memgloref{}}|memjustarg}{1316} -\glossaryentry{time.zone.exception.nonexist@ {\memgloterm{time.zone.exception.nonexist}}{\memglodesc{(\ref {time.zone.exception.nonexist})}} {\memgloref{}}|memjustarg}{1316} -\glossaryentry{time.zone.exception.ambig@ {\memgloterm{time.zone.exception.ambig}}{\memglodesc{(\ref {time.zone.exception.ambig})}} {\memgloref{}}|memjustarg}{1316} -\glossaryentry{time.zone.info@ {\memgloterm{time.zone.info}}{\memglodesc{(\ref {time.zone.info})}} {\memgloref{}}|memjustarg}{1317} -\glossaryentry{time.zone.info.sys@ {\memgloterm{time.zone.info.sys}}{\memglodesc{(\ref {time.zone.info.sys})}} {\memgloref{}}|memjustarg}{1317} -\glossaryentry{time.zone.info.local@ {\memgloterm{time.zone.info.local}}{\memglodesc{(\ref {time.zone.info.local})}} {\memgloref{}}|memjustarg}{1318} -\glossaryentry{time.zone.timezone@ {\memgloterm{time.zone.timezone}}{\memglodesc{(\ref {time.zone.timezone})}} {\memgloref{}}|memjustarg}{1318} -\glossaryentry{time.zone.overview@ {\memgloterm{time.zone.overview}}{\memglodesc{(\ref {time.zone.overview})}} {\memgloref{}}|memjustarg}{1318} -\glossaryentry{time.zone.members@ {\memgloterm{time.zone.members}}{\memglodesc{(\ref {time.zone.members})}} {\memgloref{}}|memjustarg}{1319} -\glossaryentry{time.zone.nonmembers@ {\memgloterm{time.zone.nonmembers}}{\memglodesc{(\ref {time.zone.nonmembers})}} {\memgloref{}}|memjustarg}{1320} -\glossaryentry{time.zone.zonedtraits@ {\memgloterm{time.zone.zonedtraits}}{\memglodesc{(\ref {time.zone.zonedtraits})}} {\memgloref{}}|memjustarg}{1320} -\glossaryentry{time.zone.zonedtime@ {\memgloterm{time.zone.zonedtime}}{\memglodesc{(\ref {time.zone.zonedtime})}} {\memgloref{}}|memjustarg}{1320} -\glossaryentry{time.zone.zonedtime.overview@ {\memgloterm{time.zone.zonedtime.overview}}{\memglodesc{(\ref {time.zone.zonedtime.overview})}} {\memgloref{}}|memjustarg}{1320} -\glossaryentry{time.zone.zonedtime.ctor@ {\memgloterm{time.zone.zonedtime.ctor}}{\memglodesc{(\ref {time.zone.zonedtime.ctor})}} {\memgloref{}}|memjustarg}{1322} -\glossaryentry{time.zone.zonedtime.members@ {\memgloterm{time.zone.zonedtime.members}}{\memglodesc{(\ref {time.zone.zonedtime.members})}} {\memgloref{}}|memjustarg}{1323} -\glossaryentry{time.zone.zonedtime.nonmembers@ {\memgloterm{time.zone.zonedtime.nonmembers}}{\memglodesc{(\ref {time.zone.zonedtime.nonmembers})}} {\memgloref{}}|memjustarg}{1324} -\glossaryentry{time.zone.leap@ {\memgloterm{time.zone.leap}}{\memglodesc{(\ref {time.zone.leap})}} {\memgloref{}}|memjustarg}{1324} -\glossaryentry{time.zone.leap.overview@ {\memgloterm{time.zone.leap.overview}}{\memglodesc{(\ref {time.zone.leap.overview})}} {\memgloref{}}|memjustarg}{1324} -\glossaryentry{time.zone.leap.members@ {\memgloterm{time.zone.leap.members}}{\memglodesc{(\ref {time.zone.leap.members})}} {\memgloref{}}|memjustarg}{1325} -\glossaryentry{time.zone.leap.nonmembers@ {\memgloterm{time.zone.leap.nonmembers}}{\memglodesc{(\ref {time.zone.leap.nonmembers})}} {\memgloref{}}|memjustarg}{1325} -\glossaryentry{time.zone.link@ {\memgloterm{time.zone.link}}{\memglodesc{(\ref {time.zone.link})}} {\memgloref{}}|memjustarg}{1326} -\glossaryentry{time.zone.link.overview@ {\memgloterm{time.zone.link.overview}}{\memglodesc{(\ref {time.zone.link.overview})}} {\memgloref{}}|memjustarg}{1326} -\glossaryentry{time.zone.link.members@ {\memgloterm{time.zone.link.members}}{\memglodesc{(\ref {time.zone.link.members})}} {\memgloref{}}|memjustarg}{1326} -\glossaryentry{time.zone.link.nonmembers@ {\memgloterm{time.zone.link.nonmembers}}{\memglodesc{(\ref {time.zone.link.nonmembers})}} {\memgloref{}}|memjustarg}{1326} -\glossaryentry{time.format@ {\memgloterm{time.format}}{\memglodesc{(\ref {time.format})}} {\memgloref{}}|memjustarg}{1326} -\glossaryentry{time.parse@ {\memgloterm{time.parse}}{\memglodesc{(\ref {time.parse})}} {\memgloref{}}|memjustarg}{1330} -\glossaryentry{ctime.syn@ {\memgloterm{ctime.syn}}{\memglodesc{(\ref {ctime.syn})}} {\memgloref{}}|memjustarg}{1334} -\glossaryentry{localization@ {\memgloterm{localization}}{\memglodesc{(\ref {localization})}} {\memgloref{}}|memjustarg}{1335} -\glossaryentry{localization.general@ {\memgloterm{localization.general}}{\memglodesc{(\ref {localization.general})}} {\memgloref{}}|memjustarg}{1335} -\glossaryentry{locale.syn@ {\memgloterm{locale.syn}}{\memglodesc{(\ref {locale.syn})}} {\memgloref{}}|memjustarg}{1335} -\glossaryentry{locales@ {\memgloterm{locales}}{\memglodesc{(\ref {locales})}} {\memgloref{}}|memjustarg}{1336} -\glossaryentry{locale@ {\memgloterm{locale}}{\memglodesc{(\ref {locale})}} {\memgloref{}}|memjustarg}{1336} -\glossaryentry{locale.general@ {\memgloterm{locale.general}}{\memglodesc{(\ref {locale.general})}} {\memgloref{}}|memjustarg}{1336} -\glossaryentry{locale.types@ {\memgloterm{locale.types}}{\memglodesc{(\ref {locale.types})}} {\memgloref{}}|memjustarg}{1338} -\glossaryentry{locale.category@ {\memgloterm{locale.category}}{\memglodesc{(\ref {locale.category})}} {\memgloref{}}|memjustarg}{1338} -\glossaryentry{locale.facet@ {\memgloterm{locale.facet}}{\memglodesc{(\ref {locale.facet})}} {\memgloref{}}|memjustarg}{1339} -\glossaryentry{locale.id@ {\memgloterm{locale.id}}{\memglodesc{(\ref {locale.id})}} {\memgloref{}}|memjustarg}{1340} -\glossaryentry{locale.cons@ {\memgloterm{locale.cons}}{\memglodesc{(\ref {locale.cons})}} {\memgloref{}}|memjustarg}{1340} -\glossaryentry{locale.members@ {\memgloterm{locale.members}}{\memglodesc{(\ref {locale.members})}} {\memgloref{}}|memjustarg}{1341} -\glossaryentry{locale.operators@ {\memgloterm{locale.operators}}{\memglodesc{(\ref {locale.operators})}} {\memgloref{}}|memjustarg}{1341} -\glossaryentry{locale.statics@ {\memgloterm{locale.statics}}{\memglodesc{(\ref {locale.statics})}} {\memgloref{}}|memjustarg}{1341} -\glossaryentry{locale.global.templates@ {\memgloterm{locale.global.templates}}{\memglodesc{(\ref {locale.global.templates})}} {\memgloref{}}|memjustarg}{1342} -\glossaryentry{locale.convenience@ {\memgloterm{locale.convenience}}{\memglodesc{(\ref {locale.convenience})}} {\memgloref{}}|memjustarg}{1342} -\glossaryentry{classification@ {\memgloterm{classification}}{\memglodesc{(\ref {classification})}} {\memgloref{}}|memjustarg}{1342} -\glossaryentry{conversions.character@ {\memgloterm{conversions.character}}{\memglodesc{(\ref {conversions.character})}} {\memgloref{}}|memjustarg}{1342} -\glossaryentry{locale.categories@ {\memgloterm{locale.categories}}{\memglodesc{(\ref {locale.categories})}} {\memgloref{}}|memjustarg}{1342} -\glossaryentry{locale.categories.general@ {\memgloterm{locale.categories.general}}{\memglodesc{(\ref {locale.categories.general})}} {\memgloref{}}|memjustarg}{1342} -\glossaryentry{category.ctype@ {\memgloterm{category.ctype}}{\memglodesc{(\ref {category.ctype})}} {\memgloref{}}|memjustarg}{1343} -\glossaryentry{category.ctype.general@ {\memgloterm{category.ctype.general}}{\memglodesc{(\ref {category.ctype.general})}} {\memgloref{}}|memjustarg}{1343} -\glossaryentry{locale.ctype@ {\memgloterm{locale.ctype}}{\memglodesc{(\ref {locale.ctype})}} {\memgloref{}}|memjustarg}{1343} -\glossaryentry{locale.ctype.general@ {\memgloterm{locale.ctype.general}}{\memglodesc{(\ref {locale.ctype.general})}} {\memgloref{}}|memjustarg}{1343} -\glossaryentry{locale.ctype.members@ {\memgloterm{locale.ctype.members}}{\memglodesc{(\ref {locale.ctype.members})}} {\memgloref{}}|memjustarg}{1344} -\glossaryentry{locale.ctype.virtuals@ {\memgloterm{locale.ctype.virtuals}}{\memglodesc{(\ref {locale.ctype.virtuals})}} {\memgloref{}}|memjustarg}{1344} -\glossaryentry{locale.ctype.byname@ {\memgloterm{locale.ctype.byname}}{\memglodesc{(\ref {locale.ctype.byname})}} {\memgloref{}}|memjustarg}{1345} -\glossaryentry{facet.ctype.special@ {\memgloterm{facet.ctype.special}}{\memglodesc{(\ref {facet.ctype.special})}} {\memgloref{}}|memjustarg}{1346} -\glossaryentry{facet.ctype.special.general@ {\memgloterm{facet.ctype.special.general}}{\memglodesc{(\ref {facet.ctype.special.general})}} {\memgloref{}}|memjustarg}{1346} -\glossaryentry{facet.ctype.char.dtor@ {\memgloterm{facet.ctype.char.dtor}}{\memglodesc{(\ref {facet.ctype.char.dtor})}} {\memgloref{}}|memjustarg}{1346} -\glossaryentry{facet.ctype.char.members@ {\memgloterm{facet.ctype.char.members}}{\memglodesc{(\ref {facet.ctype.char.members})}} {\memgloref{}}|memjustarg}{1347} -\glossaryentry{facet.ctype.char.statics@ {\memgloterm{facet.ctype.char.statics}}{\memglodesc{(\ref {facet.ctype.char.statics})}} {\memgloref{}}|memjustarg}{1347} -\glossaryentry{facet.ctype.char.virtuals@ {\memgloterm{facet.ctype.char.virtuals}}{\memglodesc{(\ref {facet.ctype.char.virtuals})}} {\memgloref{}}|memjustarg}{1347} -\glossaryentry{locale.codecvt@ {\memgloterm{locale.codecvt}}{\memglodesc{(\ref {locale.codecvt})}} {\memgloref{}}|memjustarg}{1348} -\glossaryentry{locale.codecvt.general@ {\memgloterm{locale.codecvt.general}}{\memglodesc{(\ref {locale.codecvt.general})}} {\memgloref{}}|memjustarg}{1348} -\glossaryentry{locale.codecvt.members@ {\memgloterm{locale.codecvt.members}}{\memglodesc{(\ref {locale.codecvt.members})}} {\memgloref{}}|memjustarg}{1349} -\glossaryentry{locale.codecvt.virtuals@ {\memgloterm{locale.codecvt.virtuals}}{\memglodesc{(\ref {locale.codecvt.virtuals})}} {\memgloref{}}|memjustarg}{1349} -\glossaryentry{locale.codecvt.byname@ {\memgloterm{locale.codecvt.byname}}{\memglodesc{(\ref {locale.codecvt.byname})}} {\memgloref{}}|memjustarg}{1351} -\glossaryentry{category.numeric@ {\memgloterm{category.numeric}}{\memglodesc{(\ref {category.numeric})}} {\memgloref{}}|memjustarg}{1351} -\glossaryentry{category.numeric.general@ {\memgloterm{category.numeric.general}}{\memglodesc{(\ref {category.numeric.general})}} {\memgloref{}}|memjustarg}{1351} -\glossaryentry{locale.num.get@ {\memgloterm{locale.num.get}}{\memglodesc{(\ref {locale.num.get})}} {\memgloref{}}|memjustarg}{1352} -\glossaryentry{locale.num.get.general@ {\memgloterm{locale.num.get.general}}{\memglodesc{(\ref {locale.num.get.general})}} {\memgloref{}}|memjustarg}{1352} -\glossaryentry{facet.num.get.members@ {\memgloterm{facet.num.get.members}}{\memglodesc{(\ref {facet.num.get.members})}} {\memgloref{}}|memjustarg}{1353} -\glossaryentry{facet.num.get.virtuals@ {\memgloterm{facet.num.get.virtuals}}{\memglodesc{(\ref {facet.num.get.virtuals})}} {\memgloref{}}|memjustarg}{1353} -\glossaryentry{locale.nm.put@ {\memgloterm{locale.nm.put}}{\memglodesc{(\ref {locale.nm.put})}} {\memgloref{}}|memjustarg}{1355} -\glossaryentry{locale.nm.put.general@ {\memgloterm{locale.nm.put.general}}{\memglodesc{(\ref {locale.nm.put.general})}} {\memgloref{}}|memjustarg}{1355} -\glossaryentry{facet.num.put.members@ {\memgloterm{facet.num.put.members}}{\memglodesc{(\ref {facet.num.put.members})}} {\memgloref{}}|memjustarg}{1356} -\glossaryentry{facet.num.put.virtuals@ {\memgloterm{facet.num.put.virtuals}}{\memglodesc{(\ref {facet.num.put.virtuals})}} {\memgloref{}}|memjustarg}{1356} -\glossaryentry{facet.numpunct@ {\memgloterm{facet.numpunct}}{\memglodesc{(\ref {facet.numpunct})}} {\memgloref{}}|memjustarg}{1359} -\glossaryentry{locale.numpunct@ {\memgloterm{locale.numpunct}}{\memglodesc{(\ref {locale.numpunct})}} {\memgloref{}}|memjustarg}{1359} -\glossaryentry{locale.numpunct.general@ {\memgloterm{locale.numpunct.general}}{\memglodesc{(\ref {locale.numpunct.general})}} {\memgloref{}}|memjustarg}{1359} -\glossaryentry{facet.numpunct.members@ {\memgloterm{facet.numpunct.members}}{\memglodesc{(\ref {facet.numpunct.members})}} {\memgloref{}}|memjustarg}{1360} -\glossaryentry{facet.numpunct.virtuals@ {\memgloterm{facet.numpunct.virtuals}}{\memglodesc{(\ref {facet.numpunct.virtuals})}} {\memgloref{}}|memjustarg}{1360} -\glossaryentry{locale.numpunct.byname@ {\memgloterm{locale.numpunct.byname}}{\memglodesc{(\ref {locale.numpunct.byname})}} {\memgloref{}}|memjustarg}{1360} -\glossaryentry{category.collate@ {\memgloterm{category.collate}}{\memglodesc{(\ref {category.collate})}} {\memgloref{}}|memjustarg}{1361} -\glossaryentry{locale.collate@ {\memgloterm{locale.collate}}{\memglodesc{(\ref {locale.collate})}} {\memgloref{}}|memjustarg}{1361} -\glossaryentry{locale.collate.general@ {\memgloterm{locale.collate.general}}{\memglodesc{(\ref {locale.collate.general})}} {\memgloref{}}|memjustarg}{1361} -\glossaryentry{locale.collate.members@ {\memgloterm{locale.collate.members}}{\memglodesc{(\ref {locale.collate.members})}} {\memgloref{}}|memjustarg}{1361} -\glossaryentry{locale.collate.virtuals@ {\memgloterm{locale.collate.virtuals}}{\memglodesc{(\ref {locale.collate.virtuals})}} {\memgloref{}}|memjustarg}{1361} -\glossaryentry{locale.collate.byname@ {\memgloterm{locale.collate.byname}}{\memglodesc{(\ref {locale.collate.byname})}} {\memgloref{}}|memjustarg}{1362} -\glossaryentry{category.time@ {\memgloterm{category.time}}{\memglodesc{(\ref {category.time})}} {\memgloref{}}|memjustarg}{1362} -\glossaryentry{category.time.general@ {\memgloterm{category.time.general}}{\memglodesc{(\ref {category.time.general})}} {\memgloref{}}|memjustarg}{1362} -\glossaryentry{locale.time.get@ {\memgloterm{locale.time.get}}{\memglodesc{(\ref {locale.time.get})}} {\memgloref{}}|memjustarg}{1362} -\glossaryentry{locale.time.get.general@ {\memgloterm{locale.time.get.general}}{\memglodesc{(\ref {locale.time.get.general})}} {\memgloref{}}|memjustarg}{1362} -\glossaryentry{locale.time.get.members@ {\memgloterm{locale.time.get.members}}{\memglodesc{(\ref {locale.time.get.members})}} {\memgloref{}}|memjustarg}{1363} -\glossaryentry{locale.time.get.virtuals@ {\memgloterm{locale.time.get.virtuals}}{\memglodesc{(\ref {locale.time.get.virtuals})}} {\memgloref{}}|memjustarg}{1364} -\glossaryentry{locale.time.get.byname@ {\memgloterm{locale.time.get.byname}}{\memglodesc{(\ref {locale.time.get.byname})}} {\memgloref{}}|memjustarg}{1365} -\glossaryentry{locale.time.put@ {\memgloterm{locale.time.put}}{\memglodesc{(\ref {locale.time.put})}} {\memgloref{}}|memjustarg}{1366} -\glossaryentry{locale.time.put.members@ {\memgloterm{locale.time.put.members}}{\memglodesc{(\ref {locale.time.put.members})}} {\memgloref{}}|memjustarg}{1366} -\glossaryentry{locale.time.put.virtuals@ {\memgloterm{locale.time.put.virtuals}}{\memglodesc{(\ref {locale.time.put.virtuals})}} {\memgloref{}}|memjustarg}{1366} -\glossaryentry{locale.time.put.byname@ {\memgloterm{locale.time.put.byname}}{\memglodesc{(\ref {locale.time.put.byname})}} {\memgloref{}}|memjustarg}{1367} -\glossaryentry{category.monetary@ {\memgloterm{category.monetary}}{\memglodesc{(\ref {category.monetary})}} {\memgloref{}}|memjustarg}{1367} -\glossaryentry{category.monetary.general@ {\memgloterm{category.monetary.general}}{\memglodesc{(\ref {category.monetary.general})}} {\memgloref{}}|memjustarg}{1367} -\glossaryentry{locale.money.get@ {\memgloterm{locale.money.get}}{\memglodesc{(\ref {locale.money.get})}} {\memgloref{}}|memjustarg}{1367} -\glossaryentry{locale.money.get.members@ {\memgloterm{locale.money.get.members}}{\memglodesc{(\ref {locale.money.get.members})}} {\memgloref{}}|memjustarg}{1368} -\glossaryentry{locale.money.get.virtuals@ {\memgloterm{locale.money.get.virtuals}}{\memglodesc{(\ref {locale.money.get.virtuals})}} {\memgloref{}}|memjustarg}{1368} -\glossaryentry{locale.money.put@ {\memgloterm{locale.money.put}}{\memglodesc{(\ref {locale.money.put})}} {\memgloref{}}|memjustarg}{1369} -\glossaryentry{locale.money.put.members@ {\memgloterm{locale.money.put.members}}{\memglodesc{(\ref {locale.money.put.members})}} {\memgloref{}}|memjustarg}{1369} -\glossaryentry{locale.money.put.virtuals@ {\memgloterm{locale.money.put.virtuals}}{\memglodesc{(\ref {locale.money.put.virtuals})}} {\memgloref{}}|memjustarg}{1369} -\glossaryentry{locale.moneypunct@ {\memgloterm{locale.moneypunct}}{\memglodesc{(\ref {locale.moneypunct})}} {\memgloref{}}|memjustarg}{1370} -\glossaryentry{locale.moneypunct.general@ {\memgloterm{locale.moneypunct.general}}{\memglodesc{(\ref {locale.moneypunct.general})}} {\memgloref{}}|memjustarg}{1370} -\glossaryentry{locale.moneypunct.members@ {\memgloterm{locale.moneypunct.members}}{\memglodesc{(\ref {locale.moneypunct.members})}} {\memgloref{}}|memjustarg}{1371} -\glossaryentry{locale.moneypunct.virtuals@ {\memgloterm{locale.moneypunct.virtuals}}{\memglodesc{(\ref {locale.moneypunct.virtuals})}} {\memgloref{}}|memjustarg}{1371} -\glossaryentry{locale.moneypunct.byname@ {\memgloterm{locale.moneypunct.byname}}{\memglodesc{(\ref {locale.moneypunct.byname})}} {\memgloref{}}|memjustarg}{1372} -\glossaryentry{category.messages@ {\memgloterm{category.messages}}{\memglodesc{(\ref {category.messages})}} {\memgloref{}}|memjustarg}{1372} -\glossaryentry{category.messages.general@ {\memgloterm{category.messages.general}}{\memglodesc{(\ref {category.messages.general})}} {\memgloref{}}|memjustarg}{1372} -\glossaryentry{locale.messages@ {\memgloterm{locale.messages}}{\memglodesc{(\ref {locale.messages})}} {\memgloref{}}|memjustarg}{1372} -\glossaryentry{locale.messages.general@ {\memgloterm{locale.messages.general}}{\memglodesc{(\ref {locale.messages.general})}} {\memgloref{}}|memjustarg}{1372} -\glossaryentry{locale.messages.members@ {\memgloterm{locale.messages.members}}{\memglodesc{(\ref {locale.messages.members})}} {\memgloref{}}|memjustarg}{1373} -\glossaryentry{locale.messages.virtuals@ {\memgloterm{locale.messages.virtuals}}{\memglodesc{(\ref {locale.messages.virtuals})}} {\memgloref{}}|memjustarg}{1373} -\glossaryentry{locale.messages.byname@ {\memgloterm{locale.messages.byname}}{\memglodesc{(\ref {locale.messages.byname})}} {\memgloref{}}|memjustarg}{1374} -\glossaryentry{c.locales@ {\memgloterm{c.locales}}{\memglodesc{(\ref {c.locales})}} {\memgloref{}}|memjustarg}{1374} -\glossaryentry{clocale.syn@ {\memgloterm{clocale.syn}}{\memglodesc{(\ref {clocale.syn})}} {\memgloref{}}|memjustarg}{1374} -\glossaryentry{clocale.data.races@ {\memgloterm{clocale.data.races}}{\memglodesc{(\ref {clocale.data.races})}} {\memgloref{}}|memjustarg}{1374} -\glossaryentry{input.output@ {\memgloterm{input.output}}{\memglodesc{(\ref {input.output})}} {\memgloref{}}|memjustarg}{1375} -\glossaryentry{input.output.general@ {\memgloterm{input.output.general}}{\memglodesc{(\ref {input.output.general})}} {\memgloref{}}|memjustarg}{1375} -\glossaryentry{iostreams.requirements@ {\memgloterm{iostreams.requirements}}{\memglodesc{(\ref {iostreams.requirements})}} {\memgloref{}}|memjustarg}{1375} -\glossaryentry{iostream.limits.imbue@ {\memgloterm{iostream.limits.imbue}}{\memglodesc{(\ref {iostream.limits.imbue})}} {\memgloref{}}|memjustarg}{1375} -\glossaryentry{iostreams.limits.pos@ {\memgloterm{iostreams.limits.pos}}{\memglodesc{(\ref {iostreams.limits.pos})}} {\memgloref{}}|memjustarg}{1376} -\glossaryentry{iostreams.threadsafety@ {\memgloterm{iostreams.threadsafety}}{\memglodesc{(\ref {iostreams.threadsafety})}} {\memgloref{}}|memjustarg}{1376} -\glossaryentry{iostream.forward@ {\memgloterm{iostream.forward}}{\memglodesc{(\ref {iostream.forward})}} {\memgloref{}}|memjustarg}{1376} -\glossaryentry{iosfwd.syn@ {\memgloterm{iosfwd.syn}}{\memglodesc{(\ref {iosfwd.syn})}} {\memgloref{}}|memjustarg}{1376} -\glossaryentry{iostream.forward.overview@ {\memgloterm{iostream.forward.overview}}{\memglodesc{(\ref {iostream.forward.overview})}} {\memgloref{}}|memjustarg}{1378} -\glossaryentry{iostream.objects@ {\memgloterm{iostream.objects}}{\memglodesc{(\ref {iostream.objects})}} {\memgloref{}}|memjustarg}{1378} -\glossaryentry{iostream.syn@ {\memgloterm{iostream.syn}}{\memglodesc{(\ref {iostream.syn})}} {\memgloref{}}|memjustarg}{1378} -\glossaryentry{iostream.objects.overview@ {\memgloterm{iostream.objects.overview}}{\memglodesc{(\ref {iostream.objects.overview})}} {\memgloref{}}|memjustarg}{1378} -\glossaryentry{narrow.stream.objects@ {\memgloterm{narrow.stream.objects}}{\memglodesc{(\ref {narrow.stream.objects})}} {\memgloref{}}|memjustarg}{1379} -\glossaryentry{wide.stream.objects@ {\memgloterm{wide.stream.objects}}{\memglodesc{(\ref {wide.stream.objects})}} {\memgloref{}}|memjustarg}{1379} -\glossaryentry{iostreams.base@ {\memgloterm{iostreams.base}}{\memglodesc{(\ref {iostreams.base})}} {\memgloref{}}|memjustarg}{1379} -\glossaryentry{ios.syn@ {\memgloterm{ios.syn}}{\memglodesc{(\ref {ios.syn})}} {\memgloref{}}|memjustarg}{1379} -\glossaryentry{stream.types@ {\memgloterm{stream.types}}{\memglodesc{(\ref {stream.types})}} {\memgloref{}}|memjustarg}{1380} -\glossaryentry{ios.base@ {\memgloterm{ios.base}}{\memglodesc{(\ref {ios.base})}} {\memgloref{}}|memjustarg}{1381} -\glossaryentry{ios.base.general@ {\memgloterm{ios.base.general}}{\memglodesc{(\ref {ios.base.general})}} {\memgloref{}}|memjustarg}{1381} -\glossaryentry{ios.types@ {\memgloterm{ios.types}}{\memglodesc{(\ref {ios.types})}} {\memgloref{}}|memjustarg}{1383} -\glossaryentry{ios.failure@ {\memgloterm{ios.failure}}{\memglodesc{(\ref {ios.failure})}} {\memgloref{}}|memjustarg}{1383} -\glossaryentry{ios.fmtflags@ {\memgloterm{ios.fmtflags}}{\memglodesc{(\ref {ios.fmtflags})}} {\memgloref{}}|memjustarg}{1383} -\glossaryentry{ios.iostate@ {\memgloterm{ios.iostate}}{\memglodesc{(\ref {ios.iostate})}} {\memgloref{}}|memjustarg}{1383} -\glossaryentry{ios.openmode@ {\memgloterm{ios.openmode}}{\memglodesc{(\ref {ios.openmode})}} {\memgloref{}}|memjustarg}{1383} -\glossaryentry{ios.seekdir@ {\memgloterm{ios.seekdir}}{\memglodesc{(\ref {ios.seekdir})}} {\memgloref{}}|memjustarg}{1383} -\glossaryentry{ios.init@ {\memgloterm{ios.init}}{\memglodesc{(\ref {ios.init})}} {\memgloref{}}|memjustarg}{1385} -\glossaryentry{fmtflags.state@ {\memgloterm{fmtflags.state}}{\memglodesc{(\ref {fmtflags.state})}} {\memgloref{}}|memjustarg}{1385} -\glossaryentry{ios.base.locales@ {\memgloterm{ios.base.locales}}{\memglodesc{(\ref {ios.base.locales})}} {\memgloref{}}|memjustarg}{1386} -\glossaryentry{ios.members.static@ {\memgloterm{ios.members.static}}{\memglodesc{(\ref {ios.members.static})}} {\memgloref{}}|memjustarg}{1386} -\glossaryentry{ios.base.storage@ {\memgloterm{ios.base.storage}}{\memglodesc{(\ref {ios.base.storage})}} {\memgloref{}}|memjustarg}{1386} -\glossaryentry{ios.base.callback@ {\memgloterm{ios.base.callback}}{\memglodesc{(\ref {ios.base.callback})}} {\memgloref{}}|memjustarg}{1387} -\glossaryentry{ios.base.cons@ {\memgloterm{ios.base.cons}}{\memglodesc{(\ref {ios.base.cons})}} {\memgloref{}}|memjustarg}{1387} -\glossaryentry{fpos@ {\memgloterm{fpos}}{\memglodesc{(\ref {fpos})}} {\memgloref{}}|memjustarg}{1387} -\glossaryentry{fpos.members@ {\memgloterm{fpos.members}}{\memglodesc{(\ref {fpos.members})}} {\memgloref{}}|memjustarg}{1388} -\glossaryentry{fpos.operations@ {\memgloterm{fpos.operations}}{\memglodesc{(\ref {fpos.operations})}} {\memgloref{}}|memjustarg}{1388} -\glossaryentry{ios@ {\memgloterm{ios}}{\memglodesc{(\ref {ios})}} {\memgloref{}}|memjustarg}{1388} -\glossaryentry{ios.overview@ {\memgloterm{ios.overview}}{\memglodesc{(\ref {ios.overview})}} {\memgloref{}}|memjustarg}{1388} -\glossaryentry{basic.ios.cons@ {\memgloterm{basic.ios.cons}}{\memglodesc{(\ref {basic.ios.cons})}} {\memgloref{}}|memjustarg}{1389} -\glossaryentry{basic.ios.members@ {\memgloterm{basic.ios.members}}{\memglodesc{(\ref {basic.ios.members})}} {\memgloref{}}|memjustarg}{1390} -\glossaryentry{iostate.flags@ {\memgloterm{iostate.flags}}{\memglodesc{(\ref {iostate.flags})}} {\memgloref{}}|memjustarg}{1392} -\glossaryentry{std.ios.manip@ {\memgloterm{std.ios.manip}}{\memglodesc{(\ref {std.ios.manip})}} {\memgloref{}}|memjustarg}{1392} -\glossaryentry{fmtflags.manip@ {\memgloterm{fmtflags.manip}}{\memglodesc{(\ref {fmtflags.manip})}} {\memgloref{}}|memjustarg}{1392} -\glossaryentry{adjustfield.manip@ {\memgloterm{adjustfield.manip}}{\memglodesc{(\ref {adjustfield.manip})}} {\memgloref{}}|memjustarg}{1394} -\glossaryentry{basefield.manip@ {\memgloterm{basefield.manip}}{\memglodesc{(\ref {basefield.manip})}} {\memgloref{}}|memjustarg}{1394} -\glossaryentry{floatfield.manip@ {\memgloterm{floatfield.manip}}{\memglodesc{(\ref {floatfield.manip})}} {\memgloref{}}|memjustarg}{1394} -\glossaryentry{error.reporting@ {\memgloterm{error.reporting}}{\memglodesc{(\ref {error.reporting})}} {\memgloref{}}|memjustarg}{1395} -\glossaryentry{stream.buffers@ {\memgloterm{stream.buffers}}{\memglodesc{(\ref {stream.buffers})}} {\memgloref{}}|memjustarg}{1395} -\glossaryentry{streambuf.syn@ {\memgloterm{streambuf.syn}}{\memglodesc{(\ref {streambuf.syn})}} {\memgloref{}}|memjustarg}{1395} -\glossaryentry{streambuf.reqts@ {\memgloterm{streambuf.reqts}}{\memglodesc{(\ref {streambuf.reqts})}} {\memgloref{}}|memjustarg}{1395} -\glossaryentry{streambuf@ {\memgloterm{streambuf}}{\memglodesc{(\ref {streambuf})}} {\memgloref{}}|memjustarg}{1396} -\glossaryentry{streambuf.general@ {\memgloterm{streambuf.general}}{\memglodesc{(\ref {streambuf.general})}} {\memgloref{}}|memjustarg}{1396} -\glossaryentry{streambuf.cons@ {\memgloterm{streambuf.cons}}{\memglodesc{(\ref {streambuf.cons})}} {\memgloref{}}|memjustarg}{1397} -\glossaryentry{streambuf.members@ {\memgloterm{streambuf.members}}{\memglodesc{(\ref {streambuf.members})}} {\memgloref{}}|memjustarg}{1398} -\glossaryentry{streambuf.locales@ {\memgloterm{streambuf.locales}}{\memglodesc{(\ref {streambuf.locales})}} {\memgloref{}}|memjustarg}{1398} -\glossaryentry{streambuf.buffer@ {\memgloterm{streambuf.buffer}}{\memglodesc{(\ref {streambuf.buffer})}} {\memgloref{}}|memjustarg}{1398} -\glossaryentry{streambuf.pub.get@ {\memgloterm{streambuf.pub.get}}{\memglodesc{(\ref {streambuf.pub.get})}} {\memgloref{}}|memjustarg}{1398} -\glossaryentry{streambuf.pub.pback@ {\memgloterm{streambuf.pub.pback}}{\memglodesc{(\ref {streambuf.pub.pback})}} {\memgloref{}}|memjustarg}{1399} -\glossaryentry{streambuf.pub.put@ {\memgloterm{streambuf.pub.put}}{\memglodesc{(\ref {streambuf.pub.put})}} {\memgloref{}}|memjustarg}{1399} -\glossaryentry{streambuf.protected@ {\memgloterm{streambuf.protected}}{\memglodesc{(\ref {streambuf.protected})}} {\memgloref{}}|memjustarg}{1399} -\glossaryentry{streambuf.assign@ {\memgloterm{streambuf.assign}}{\memglodesc{(\ref {streambuf.assign})}} {\memgloref{}}|memjustarg}{1399} -\glossaryentry{streambuf.get.area@ {\memgloterm{streambuf.get.area}}{\memglodesc{(\ref {streambuf.get.area})}} {\memgloref{}}|memjustarg}{1399} -\glossaryentry{streambuf.put.area@ {\memgloterm{streambuf.put.area}}{\memglodesc{(\ref {streambuf.put.area})}} {\memgloref{}}|memjustarg}{1400} -\glossaryentry{streambuf.virtuals@ {\memgloterm{streambuf.virtuals}}{\memglodesc{(\ref {streambuf.virtuals})}} {\memgloref{}}|memjustarg}{1400} -\glossaryentry{streambuf.virt.locales@ {\memgloterm{streambuf.virt.locales}}{\memglodesc{(\ref {streambuf.virt.locales})}} {\memgloref{}}|memjustarg}{1400} -\glossaryentry{streambuf.virt.buffer@ {\memgloterm{streambuf.virt.buffer}}{\memglodesc{(\ref {streambuf.virt.buffer})}} {\memgloref{}}|memjustarg}{1400} -\glossaryentry{streambuf.virt.get@ {\memgloterm{streambuf.virt.get}}{\memglodesc{(\ref {streambuf.virt.get})}} {\memgloref{}}|memjustarg}{1401} -\glossaryentry{streambuf.virt.pback@ {\memgloterm{streambuf.virt.pback}}{\memglodesc{(\ref {streambuf.virt.pback})}} {\memgloref{}}|memjustarg}{1402} -\glossaryentry{streambuf.virt.put@ {\memgloterm{streambuf.virt.put}}{\memglodesc{(\ref {streambuf.virt.put})}} {\memgloref{}}|memjustarg}{1402} -\glossaryentry{iostream.format@ {\memgloterm{iostream.format}}{\memglodesc{(\ref {iostream.format})}} {\memgloref{}}|memjustarg}{1403} -\glossaryentry{istream.syn@ {\memgloterm{istream.syn}}{\memglodesc{(\ref {istream.syn})}} {\memgloref{}}|memjustarg}{1403} -\glossaryentry{ostream.syn@ {\memgloterm{ostream.syn}}{\memglodesc{(\ref {ostream.syn})}} {\memgloref{}}|memjustarg}{1403} -\glossaryentry{iomanip.syn@ {\memgloterm{iomanip.syn}}{\memglodesc{(\ref {iomanip.syn})}} {\memgloref{}}|memjustarg}{1403} -\glossaryentry{input.streams@ {\memgloterm{input.streams}}{\memglodesc{(\ref {input.streams})}} {\memgloref{}}|memjustarg}{1404} -\glossaryentry{input.streams.general@ {\memgloterm{input.streams.general}}{\memglodesc{(\ref {input.streams.general})}} {\memgloref{}}|memjustarg}{1404} -\glossaryentry{istream@ {\memgloterm{istream}}{\memglodesc{(\ref {istream})}} {\memgloref{}}|memjustarg}{1404} -\glossaryentry{istream.general@ {\memgloterm{istream.general}}{\memglodesc{(\ref {istream.general})}} {\memgloref{}}|memjustarg}{1404} -\glossaryentry{istream.cons@ {\memgloterm{istream.cons}}{\memglodesc{(\ref {istream.cons})}} {\memgloref{}}|memjustarg}{1406} -\glossaryentry{istream.assign@ {\memgloterm{istream.assign}}{\memglodesc{(\ref {istream.assign})}} {\memgloref{}}|memjustarg}{1406} -\glossaryentry{istream.sentry@ {\memgloterm{istream.sentry}}{\memglodesc{(\ref {istream.sentry})}} {\memgloref{}}|memjustarg}{1406} -\glossaryentry{istream.formatted@ {\memgloterm{istream.formatted}}{\memglodesc{(\ref {istream.formatted})}} {\memgloref{}}|memjustarg}{1407} -\glossaryentry{istream.formatted.reqmts@ {\memgloterm{istream.formatted.reqmts}}{\memglodesc{(\ref {istream.formatted.reqmts})}} {\memgloref{}}|memjustarg}{1407} -\glossaryentry{istream.formatted.arithmetic@ {\memgloterm{istream.formatted.arithmetic}}{\memglodesc{(\ref {istream.formatted.arithmetic})}} {\memgloref{}}|memjustarg}{1407} -\glossaryentry{istream.extractors@ {\memgloterm{istream.extractors}}{\memglodesc{(\ref {istream.extractors})}} {\memgloref{}}|memjustarg}{1408} -\glossaryentry{istream.unformatted@ {\memgloterm{istream.unformatted}}{\memglodesc{(\ref {istream.unformatted})}} {\memgloref{}}|memjustarg}{1409} -\glossaryentry{istream.manip@ {\memgloterm{istream.manip}}{\memglodesc{(\ref {istream.manip})}} {\memgloref{}}|memjustarg}{1413} -\glossaryentry{istream.rvalue@ {\memgloterm{istream.rvalue}}{\memglodesc{(\ref {istream.rvalue})}} {\memgloref{}}|memjustarg}{1413} -\glossaryentry{iostreamclass@ {\memgloterm{iostreamclass}}{\memglodesc{(\ref {iostreamclass})}} {\memgloref{}}|memjustarg}{1414} -\glossaryentry{iostreamclass.general@ {\memgloterm{iostreamclass.general}}{\memglodesc{(\ref {iostreamclass.general})}} {\memgloref{}}|memjustarg}{1414} -\glossaryentry{iostream.cons@ {\memgloterm{iostream.cons}}{\memglodesc{(\ref {iostream.cons})}} {\memgloref{}}|memjustarg}{1414} -\glossaryentry{iostream.dest@ {\memgloterm{iostream.dest}}{\memglodesc{(\ref {iostream.dest})}} {\memgloref{}}|memjustarg}{1414} -\glossaryentry{iostream.assign@ {\memgloterm{iostream.assign}}{\memglodesc{(\ref {iostream.assign})}} {\memgloref{}}|memjustarg}{1414} -\glossaryentry{output.streams@ {\memgloterm{output.streams}}{\memglodesc{(\ref {output.streams})}} {\memgloref{}}|memjustarg}{1415} -\glossaryentry{output.streams.general@ {\memgloterm{output.streams.general}}{\memglodesc{(\ref {output.streams.general})}} {\memgloref{}}|memjustarg}{1415} -\glossaryentry{ostream@ {\memgloterm{ostream}}{\memglodesc{(\ref {ostream})}} {\memgloref{}}|memjustarg}{1415} -\glossaryentry{ostream.general@ {\memgloterm{ostream.general}}{\memglodesc{(\ref {ostream.general})}} {\memgloref{}}|memjustarg}{1415} -\glossaryentry{ostream.cons@ {\memgloterm{ostream.cons}}{\memglodesc{(\ref {ostream.cons})}} {\memgloref{}}|memjustarg}{1417} -\glossaryentry{ostream.assign@ {\memgloterm{ostream.assign}}{\memglodesc{(\ref {ostream.assign})}} {\memgloref{}}|memjustarg}{1417} -\glossaryentry{ostream.sentry@ {\memgloterm{ostream.sentry}}{\memglodesc{(\ref {ostream.sentry})}} {\memgloref{}}|memjustarg}{1417} -\glossaryentry{ostream.seeks@ {\memgloterm{ostream.seeks}}{\memglodesc{(\ref {ostream.seeks})}} {\memgloref{}}|memjustarg}{1418} -\glossaryentry{ostream.formatted@ {\memgloterm{ostream.formatted}}{\memglodesc{(\ref {ostream.formatted})}} {\memgloref{}}|memjustarg}{1418} -\glossaryentry{ostream.formatted.reqmts@ {\memgloterm{ostream.formatted.reqmts}}{\memglodesc{(\ref {ostream.formatted.reqmts})}} {\memgloref{}}|memjustarg}{1418} -\glossaryentry{ostream.inserters.arithmetic@ {\memgloterm{ostream.inserters.arithmetic}}{\memglodesc{(\ref {ostream.inserters.arithmetic})}} {\memgloref{}}|memjustarg}{1419} -\glossaryentry{ostream.inserters@ {\memgloterm{ostream.inserters}}{\memglodesc{(\ref {ostream.inserters})}} {\memgloref{}}|memjustarg}{1420} -\glossaryentry{ostream.inserters.character@ {\memgloterm{ostream.inserters.character}}{\memglodesc{(\ref {ostream.inserters.character})}} {\memgloref{}}|memjustarg}{1420} -\glossaryentry{ostream.unformatted@ {\memgloterm{ostream.unformatted}}{\memglodesc{(\ref {ostream.unformatted})}} {\memgloref{}}|memjustarg}{1421} -\glossaryentry{ostream.manip@ {\memgloterm{ostream.manip}}{\memglodesc{(\ref {ostream.manip})}} {\memgloref{}}|memjustarg}{1422} -\glossaryentry{ostream.rvalue@ {\memgloterm{ostream.rvalue}}{\memglodesc{(\ref {ostream.rvalue})}} {\memgloref{}}|memjustarg}{1422} -\glossaryentry{std.manip@ {\memgloterm{std.manip}}{\memglodesc{(\ref {std.manip})}} {\memgloref{}}|memjustarg}{1423} -\glossaryentry{ext.manip@ {\memgloterm{ext.manip}}{\memglodesc{(\ref {ext.manip})}} {\memgloref{}}|memjustarg}{1424} -\glossaryentry{quoted.manip@ {\memgloterm{quoted.manip}}{\memglodesc{(\ref {quoted.manip})}} {\memgloref{}}|memjustarg}{1426} -\glossaryentry{string.streams@ {\memgloterm{string.streams}}{\memglodesc{(\ref {string.streams})}} {\memgloref{}}|memjustarg}{1427} -\glossaryentry{sstream.syn@ {\memgloterm{sstream.syn}}{\memglodesc{(\ref {sstream.syn})}} {\memgloref{}}|memjustarg}{1427} -\glossaryentry{stringbuf@ {\memgloterm{stringbuf}}{\memglodesc{(\ref {stringbuf})}} {\memgloref{}}|memjustarg}{1427} -\glossaryentry{stringbuf.general@ {\memgloterm{stringbuf.general}}{\memglodesc{(\ref {stringbuf.general})}} {\memgloref{}}|memjustarg}{1427} -\glossaryentry{stringbuf.cons@ {\memgloterm{stringbuf.cons}}{\memglodesc{(\ref {stringbuf.cons})}} {\memgloref{}}|memjustarg}{1429} -\glossaryentry{stringbuf.assign@ {\memgloterm{stringbuf.assign}}{\memglodesc{(\ref {stringbuf.assign})}} {\memgloref{}}|memjustarg}{1430} -\glossaryentry{stringbuf.members@ {\memgloterm{stringbuf.members}}{\memglodesc{(\ref {stringbuf.members})}} {\memgloref{}}|memjustarg}{1430} -\glossaryentry{stringbuf.virtuals@ {\memgloterm{stringbuf.virtuals}}{\memglodesc{(\ref {stringbuf.virtuals})}} {\memgloref{}}|memjustarg}{1432} -\glossaryentry{istringstream@ {\memgloterm{istringstream}}{\memglodesc{(\ref {istringstream})}} {\memgloref{}}|memjustarg}{1433} -\glossaryentry{istringstream.general@ {\memgloterm{istringstream.general}}{\memglodesc{(\ref {istringstream.general})}} {\memgloref{}}|memjustarg}{1433} -\glossaryentry{istringstream.cons@ {\memgloterm{istringstream.cons}}{\memglodesc{(\ref {istringstream.cons})}} {\memgloref{}}|memjustarg}{1434} -\glossaryentry{istringstream.assign@ {\memgloterm{istringstream.assign}}{\memglodesc{(\ref {istringstream.assign})}} {\memgloref{}}|memjustarg}{1435} -\glossaryentry{istringstream.members@ {\memgloterm{istringstream.members}}{\memglodesc{(\ref {istringstream.members})}} {\memgloref{}}|memjustarg}{1435} -\glossaryentry{ostringstream@ {\memgloterm{ostringstream}}{\memglodesc{(\ref {ostringstream})}} {\memgloref{}}|memjustarg}{1436} -\glossaryentry{ostringstream.general@ {\memgloterm{ostringstream.general}}{\memglodesc{(\ref {ostringstream.general})}} {\memgloref{}}|memjustarg}{1436} -\glossaryentry{ostringstream.cons@ {\memgloterm{ostringstream.cons}}{\memglodesc{(\ref {ostringstream.cons})}} {\memgloref{}}|memjustarg}{1437} -\glossaryentry{ostringstream.assign@ {\memgloterm{ostringstream.assign}}{\memglodesc{(\ref {ostringstream.assign})}} {\memgloref{}}|memjustarg}{1438} -\glossaryentry{ostringstream.members@ {\memgloterm{ostringstream.members}}{\memglodesc{(\ref {ostringstream.members})}} {\memgloref{}}|memjustarg}{1438} -\glossaryentry{stringstream@ {\memgloterm{stringstream}}{\memglodesc{(\ref {stringstream})}} {\memgloref{}}|memjustarg}{1438} -\glossaryentry{stringstream.general@ {\memgloterm{stringstream.general}}{\memglodesc{(\ref {stringstream.general})}} {\memgloref{}}|memjustarg}{1438} -\glossaryentry{stringstream.cons@ {\memgloterm{stringstream.cons}}{\memglodesc{(\ref {stringstream.cons})}} {\memgloref{}}|memjustarg}{1439} -\glossaryentry{stringstream.assign@ {\memgloterm{stringstream.assign}}{\memglodesc{(\ref {stringstream.assign})}} {\memgloref{}}|memjustarg}{1440} -\glossaryentry{stringstream.members@ {\memgloterm{stringstream.members}}{\memglodesc{(\ref {stringstream.members})}} {\memgloref{}}|memjustarg}{1440} -\glossaryentry{file.streams@ {\memgloterm{file.streams}}{\memglodesc{(\ref {file.streams})}} {\memgloref{}}|memjustarg}{1441} -\glossaryentry{fstream.syn@ {\memgloterm{fstream.syn}}{\memglodesc{(\ref {fstream.syn})}} {\memgloref{}}|memjustarg}{1441} -\glossaryentry{filebuf@ {\memgloterm{filebuf}}{\memglodesc{(\ref {filebuf})}} {\memgloref{}}|memjustarg}{1441} -\glossaryentry{filebuf.general@ {\memgloterm{filebuf.general}}{\memglodesc{(\ref {filebuf.general})}} {\memgloref{}}|memjustarg}{1441} -\glossaryentry{filebuf.cons@ {\memgloterm{filebuf.cons}}{\memglodesc{(\ref {filebuf.cons})}} {\memgloref{}}|memjustarg}{1443} -\glossaryentry{filebuf.assign@ {\memgloterm{filebuf.assign}}{\memglodesc{(\ref {filebuf.assign})}} {\memgloref{}}|memjustarg}{1443} -\glossaryentry{filebuf.members@ {\memgloterm{filebuf.members}}{\memglodesc{(\ref {filebuf.members})}} {\memgloref{}}|memjustarg}{1444} -\glossaryentry{filebuf.virtuals@ {\memgloterm{filebuf.virtuals}}{\memglodesc{(\ref {filebuf.virtuals})}} {\memgloref{}}|memjustarg}{1445} -\glossaryentry{ifstream@ {\memgloterm{ifstream}}{\memglodesc{(\ref {ifstream})}} {\memgloref{}}|memjustarg}{1447} -\glossaryentry{ifstream.general@ {\memgloterm{ifstream.general}}{\memglodesc{(\ref {ifstream.general})}} {\memgloref{}}|memjustarg}{1447} -\glossaryentry{ifstream.cons@ {\memgloterm{ifstream.cons}}{\memglodesc{(\ref {ifstream.cons})}} {\memgloref{}}|memjustarg}{1448} -\glossaryentry{ifstream.assign@ {\memgloterm{ifstream.assign}}{\memglodesc{(\ref {ifstream.assign})}} {\memgloref{}}|memjustarg}{1448} -\glossaryentry{ifstream.members@ {\memgloterm{ifstream.members}}{\memglodesc{(\ref {ifstream.members})}} {\memgloref{}}|memjustarg}{1449} -\glossaryentry{ofstream@ {\memgloterm{ofstream}}{\memglodesc{(\ref {ofstream})}} {\memgloref{}}|memjustarg}{1449} -\glossaryentry{ofstream.general@ {\memgloterm{ofstream.general}}{\memglodesc{(\ref {ofstream.general})}} {\memgloref{}}|memjustarg}{1449} -\glossaryentry{ofstream.cons@ {\memgloterm{ofstream.cons}}{\memglodesc{(\ref {ofstream.cons})}} {\memgloref{}}|memjustarg}{1450} -\glossaryentry{ofstream.assign@ {\memgloterm{ofstream.assign}}{\memglodesc{(\ref {ofstream.assign})}} {\memgloref{}}|memjustarg}{1450} -\glossaryentry{ofstream.members@ {\memgloterm{ofstream.members}}{\memglodesc{(\ref {ofstream.members})}} {\memgloref{}}|memjustarg}{1450} -\glossaryentry{fstream@ {\memgloterm{fstream}}{\memglodesc{(\ref {fstream})}} {\memgloref{}}|memjustarg}{1451} -\glossaryentry{fstream.general@ {\memgloterm{fstream.general}}{\memglodesc{(\ref {fstream.general})}} {\memgloref{}}|memjustarg}{1451} -\glossaryentry{fstream.cons@ {\memgloterm{fstream.cons}}{\memglodesc{(\ref {fstream.cons})}} {\memgloref{}}|memjustarg}{1452} -\glossaryentry{fstream.assign@ {\memgloterm{fstream.assign}}{\memglodesc{(\ref {fstream.assign})}} {\memgloref{}}|memjustarg}{1452} -\glossaryentry{fstream.members@ {\memgloterm{fstream.members}}{\memglodesc{(\ref {fstream.members})}} {\memgloref{}}|memjustarg}{1452} -\glossaryentry{syncstream@ {\memgloterm{syncstream}}{\memglodesc{(\ref {syncstream})}} {\memgloref{}}|memjustarg}{1453} -\glossaryentry{syncstream.syn@ {\memgloterm{syncstream.syn}}{\memglodesc{(\ref {syncstream.syn})}} {\memgloref{}}|memjustarg}{1453} -\glossaryentry{syncstream.syncbuf@ {\memgloterm{syncstream.syncbuf}}{\memglodesc{(\ref {syncstream.syncbuf})}} {\memgloref{}}|memjustarg}{1453} -\glossaryentry{syncstream.syncbuf.overview@ {\memgloterm{syncstream.syncbuf.overview}}{\memglodesc{(\ref {syncstream.syncbuf.overview})}} {\memgloref{}}|memjustarg}{1453} -\glossaryentry{syncstream.syncbuf.cons@ {\memgloterm{syncstream.syncbuf.cons}}{\memglodesc{(\ref {syncstream.syncbuf.cons})}} {\memgloref{}}|memjustarg}{1454} -\glossaryentry{syncstream.syncbuf.assign@ {\memgloterm{syncstream.syncbuf.assign}}{\memglodesc{(\ref {syncstream.syncbuf.assign})}} {\memgloref{}}|memjustarg}{1455} -\glossaryentry{syncstream.syncbuf.members@ {\memgloterm{syncstream.syncbuf.members}}{\memglodesc{(\ref {syncstream.syncbuf.members})}} {\memgloref{}}|memjustarg}{1455} -\glossaryentry{syncstream.syncbuf.virtuals@ {\memgloterm{syncstream.syncbuf.virtuals}}{\memglodesc{(\ref {syncstream.syncbuf.virtuals})}} {\memgloref{}}|memjustarg}{1455} -\glossaryentry{syncstream.syncbuf.special@ {\memgloterm{syncstream.syncbuf.special}}{\memglodesc{(\ref {syncstream.syncbuf.special})}} {\memgloref{}}|memjustarg}{1456} -\glossaryentry{syncstream.osyncstream@ {\memgloterm{syncstream.osyncstream}}{\memglodesc{(\ref {syncstream.osyncstream})}} {\memgloref{}}|memjustarg}{1456} -\glossaryentry{syncstream.osyncstream.overview@ {\memgloterm{syncstream.osyncstream.overview}}{\memglodesc{(\ref {syncstream.osyncstream.overview})}} {\memgloref{}}|memjustarg}{1456} -\glossaryentry{syncstream.osyncstream.cons@ {\memgloterm{syncstream.osyncstream.cons}}{\memglodesc{(\ref {syncstream.osyncstream.cons})}} {\memgloref{}}|memjustarg}{1457} -\glossaryentry{syncstream.osyncstream.members@ {\memgloterm{syncstream.osyncstream.members}}{\memglodesc{(\ref {syncstream.osyncstream.members})}} {\memgloref{}}|memjustarg}{1457} -\glossaryentry{filesystems@ {\memgloterm{filesystems}}{\memglodesc{(\ref {filesystems})}} {\memgloref{}}|memjustarg}{1458} -\glossaryentry{fs.general@ {\memgloterm{fs.general}}{\memglodesc{(\ref {fs.general})}} {\memgloref{}}|memjustarg}{1458} -\glossaryentry{fs.conformance@ {\memgloterm{fs.conformance}}{\memglodesc{(\ref {fs.conformance})}} {\memgloref{}}|memjustarg}{1458} -\glossaryentry{fs.conformance.general@ {\memgloterm{fs.conformance.general}}{\memglodesc{(\ref {fs.conformance.general})}} {\memgloref{}}|memjustarg}{1458} -\glossaryentry{fs.conform.9945@ {\memgloterm{fs.conform.9945}}{\memglodesc{(\ref {fs.conform.9945})}} {\memgloref{}}|memjustarg}{1458} -\glossaryentry{fs.conform.os@ {\memgloterm{fs.conform.os}}{\memglodesc{(\ref {fs.conform.os})}} {\memgloref{}}|memjustarg}{1458} -\glossaryentry{fs.race.behavior@ {\memgloterm{fs.race.behavior}}{\memglodesc{(\ref {fs.race.behavior})}} {\memgloref{}}|memjustarg}{1459} -\glossaryentry{fs.req@ {\memgloterm{fs.req}}{\memglodesc{(\ref {fs.req})}} {\memgloref{}}|memjustarg}{1459} -\glossaryentry{fs.req.general@ {\memgloterm{fs.req.general}}{\memglodesc{(\ref {fs.req.general})}} {\memgloref{}}|memjustarg}{1459} -\glossaryentry{fs.req.namespace@ {\memgloterm{fs.req.namespace}}{\memglodesc{(\ref {fs.req.namespace})}} {\memgloref{}}|memjustarg}{1459} -\glossaryentry{fs.filesystem.syn@ {\memgloterm{fs.filesystem.syn}}{\memglodesc{(\ref {fs.filesystem.syn})}} {\memgloref{}}|memjustarg}{1459} -\glossaryentry{fs.err.report@ {\memgloterm{fs.err.report}}{\memglodesc{(\ref {fs.err.report})}} {\memgloref{}}|memjustarg}{1462} -\glossaryentry{fs.class.path@ {\memgloterm{fs.class.path}}{\memglodesc{(\ref {fs.class.path})}} {\memgloref{}}|memjustarg}{1463} -\glossaryentry{fs.class.path.general@ {\memgloterm{fs.class.path.general}}{\memglodesc{(\ref {fs.class.path.general})}} {\memgloref{}}|memjustarg}{1463} -\glossaryentry{fs.path.generic@ {\memgloterm{fs.path.generic}}{\memglodesc{(\ref {fs.path.generic})}} {\memgloref{}}|memjustarg}{1466} -\glossaryentry{fs.path.cvt@ {\memgloterm{fs.path.cvt}}{\memglodesc{(\ref {fs.path.cvt})}} {\memgloref{}}|memjustarg}{1467} -\glossaryentry{fs.path.fmt.cvt@ {\memgloterm{fs.path.fmt.cvt}}{\memglodesc{(\ref {fs.path.fmt.cvt})}} {\memgloref{}}|memjustarg}{1467} -\glossaryentry{fs.path.type.cvt@ {\memgloterm{fs.path.type.cvt}}{\memglodesc{(\ref {fs.path.type.cvt})}} {\memgloref{}}|memjustarg}{1468} -\glossaryentry{fs.path.req@ {\memgloterm{fs.path.req}}{\memglodesc{(\ref {fs.path.req})}} {\memgloref{}}|memjustarg}{1468} -\glossaryentry{fs.path.member@ {\memgloterm{fs.path.member}}{\memglodesc{(\ref {fs.path.member})}} {\memgloref{}}|memjustarg}{1469} -\glossaryentry{fs.path.construct@ {\memgloterm{fs.path.construct}}{\memglodesc{(\ref {fs.path.construct})}} {\memgloref{}}|memjustarg}{1469} -\glossaryentry{fs.path.assign@ {\memgloterm{fs.path.assign}}{\memglodesc{(\ref {fs.path.assign})}} {\memgloref{}}|memjustarg}{1470} -\glossaryentry{fs.path.append@ {\memgloterm{fs.path.append}}{\memglodesc{(\ref {fs.path.append})}} {\memgloref{}}|memjustarg}{1470} -\glossaryentry{fs.path.concat@ {\memgloterm{fs.path.concat}}{\memglodesc{(\ref {fs.path.concat})}} {\memgloref{}}|memjustarg}{1471} -\glossaryentry{fs.path.modifiers@ {\memgloterm{fs.path.modifiers}}{\memglodesc{(\ref {fs.path.modifiers})}} {\memgloref{}}|memjustarg}{1471} -\glossaryentry{fs.path.native.obs@ {\memgloterm{fs.path.native.obs}}{\memglodesc{(\ref {fs.path.native.obs})}} {\memgloref{}}|memjustarg}{1472} -\glossaryentry{fs.path.generic.obs@ {\memgloterm{fs.path.generic.obs}}{\memglodesc{(\ref {fs.path.generic.obs})}} {\memgloref{}}|memjustarg}{1473} -\glossaryentry{fs.path.compare@ {\memgloterm{fs.path.compare}}{\memglodesc{(\ref {fs.path.compare})}} {\memgloref{}}|memjustarg}{1473} -\glossaryentry{fs.path.decompose@ {\memgloterm{fs.path.decompose}}{\memglodesc{(\ref {fs.path.decompose})}} {\memgloref{}}|memjustarg}{1474} -\glossaryentry{fs.path.query@ {\memgloterm{fs.path.query}}{\memglodesc{(\ref {fs.path.query})}} {\memgloref{}}|memjustarg}{1475} -\glossaryentry{fs.path.gen@ {\memgloterm{fs.path.gen}}{\memglodesc{(\ref {fs.path.gen})}} {\memgloref{}}|memjustarg}{1475} -\glossaryentry{fs.path.itr@ {\memgloterm{fs.path.itr}}{\memglodesc{(\ref {fs.path.itr})}} {\memgloref{}}|memjustarg}{1476} -\glossaryentry{fs.path.io@ {\memgloterm{fs.path.io}}{\memglodesc{(\ref {fs.path.io})}} {\memgloref{}}|memjustarg}{1477} -\glossaryentry{fs.path.nonmember@ {\memgloterm{fs.path.nonmember}}{\memglodesc{(\ref {fs.path.nonmember})}} {\memgloref{}}|memjustarg}{1477} -\glossaryentry{fs.class.filesystem.error@ {\memgloterm{fs.class.filesystem.error}}{\memglodesc{(\ref {fs.class.filesystem.error})}} {\memgloref{}}|memjustarg}{1478} -\glossaryentry{fs.class.filesystem.error.general@ {\memgloterm{fs.class.filesystem.error.general}}{\memglodesc{(\ref {fs.class.filesystem.error.general})}} {\memgloref{}}|memjustarg}{1478} -\glossaryentry{fs.filesystem.error.members@ {\memgloterm{fs.filesystem.error.members}}{\memglodesc{(\ref {fs.filesystem.error.members})}} {\memgloref{}}|memjustarg}{1478} -\glossaryentry{fs.enum@ {\memgloterm{fs.enum}}{\memglodesc{(\ref {fs.enum})}} {\memgloref{}}|memjustarg}{1479} -\glossaryentry{fs.enum.path.format@ {\memgloterm{fs.enum.path.format}}{\memglodesc{(\ref {fs.enum.path.format})}} {\memgloref{}}|memjustarg}{1479} -\glossaryentry{fs.enum.file.type@ {\memgloterm{fs.enum.file.type}}{\memglodesc{(\ref {fs.enum.file.type})}} {\memgloref{}}|memjustarg}{1479} -\glossaryentry{fs.enum.copy.opts@ {\memgloterm{fs.enum.copy.opts}}{\memglodesc{(\ref {fs.enum.copy.opts})}} {\memgloref{}}|memjustarg}{1479} -\glossaryentry{fs.enum.perms@ {\memgloterm{fs.enum.perms}}{\memglodesc{(\ref {fs.enum.perms})}} {\memgloref{}}|memjustarg}{1480} -\glossaryentry{fs.enum.perm.opts@ {\memgloterm{fs.enum.perm.opts}}{\memglodesc{(\ref {fs.enum.perm.opts})}} {\memgloref{}}|memjustarg}{1480} -\glossaryentry{fs.enum.dir.opts@ {\memgloterm{fs.enum.dir.opts}}{\memglodesc{(\ref {fs.enum.dir.opts})}} {\memgloref{}}|memjustarg}{1480} -\glossaryentry{fs.class.file.status@ {\memgloterm{fs.class.file.status}}{\memglodesc{(\ref {fs.class.file.status})}} {\memgloref{}}|memjustarg}{1480} -\glossaryentry{fs.class.file.status.general@ {\memgloterm{fs.class.file.status.general}}{\memglodesc{(\ref {fs.class.file.status.general})}} {\memgloref{}}|memjustarg}{1480} -\glossaryentry{fs.file.status.cons@ {\memgloterm{fs.file.status.cons}}{\memglodesc{(\ref {fs.file.status.cons})}} {\memgloref{}}|memjustarg}{1482} -\glossaryentry{fs.file.status.obs@ {\memgloterm{fs.file.status.obs}}{\memglodesc{(\ref {fs.file.status.obs})}} {\memgloref{}}|memjustarg}{1482} -\glossaryentry{fs.file.status.mods@ {\memgloterm{fs.file.status.mods}}{\memglodesc{(\ref {fs.file.status.mods})}} {\memgloref{}}|memjustarg}{1482} -\glossaryentry{fs.class.directory.entry@ {\memgloterm{fs.class.directory.entry}}{\memglodesc{(\ref {fs.class.directory.entry})}} {\memgloref{}}|memjustarg}{1482} -\glossaryentry{fs.class.directory.entry.general@ {\memgloterm{fs.class.directory.entry.general}}{\memglodesc{(\ref {fs.class.directory.entry.general})}} {\memgloref{}}|memjustarg}{1482} -\glossaryentry{fs.dir.entry.cons@ {\memgloterm{fs.dir.entry.cons}}{\memglodesc{(\ref {fs.dir.entry.cons})}} {\memgloref{}}|memjustarg}{1484} -\glossaryentry{fs.dir.entry.mods@ {\memgloterm{fs.dir.entry.mods}}{\memglodesc{(\ref {fs.dir.entry.mods})}} {\memgloref{}}|memjustarg}{1484} -\glossaryentry{fs.dir.entry.obs@ {\memgloterm{fs.dir.entry.obs}}{\memglodesc{(\ref {fs.dir.entry.obs})}} {\memgloref{}}|memjustarg}{1484} -\glossaryentry{fs.class.directory.iterator@ {\memgloterm{fs.class.directory.iterator}}{\memglodesc{(\ref {fs.class.directory.iterator})}} {\memgloref{}}|memjustarg}{1486} -\glossaryentry{fs.class.directory.iterator.general@ {\memgloterm{fs.class.directory.iterator.general}}{\memglodesc{(\ref {fs.class.directory.iterator.general})}} {\memgloref{}}|memjustarg}{1486} -\glossaryentry{fs.dir.itr.members@ {\memgloterm{fs.dir.itr.members}}{\memglodesc{(\ref {fs.dir.itr.members})}} {\memgloref{}}|memjustarg}{1487} -\glossaryentry{fs.dir.itr.nonmembers@ {\memgloterm{fs.dir.itr.nonmembers}}{\memglodesc{(\ref {fs.dir.itr.nonmembers})}} {\memgloref{}}|memjustarg}{1488} -\glossaryentry{fs.class.rec.dir.itr@ {\memgloterm{fs.class.rec.dir.itr}}{\memglodesc{(\ref {fs.class.rec.dir.itr})}} {\memgloref{}}|memjustarg}{1488} -\glossaryentry{fs.class.rec.dir.itr.general@ {\memgloterm{fs.class.rec.dir.itr.general}}{\memglodesc{(\ref {fs.class.rec.dir.itr.general})}} {\memgloref{}}|memjustarg}{1488} -\glossaryentry{fs.rec.dir.itr.members@ {\memgloterm{fs.rec.dir.itr.members}}{\memglodesc{(\ref {fs.rec.dir.itr.members})}} {\memgloref{}}|memjustarg}{1489} -\glossaryentry{fs.rec.dir.itr.nonmembers@ {\memgloterm{fs.rec.dir.itr.nonmembers}}{\memglodesc{(\ref {fs.rec.dir.itr.nonmembers})}} {\memgloref{}}|memjustarg}{1490} -\glossaryentry{fs.op.funcs@ {\memgloterm{fs.op.funcs}}{\memglodesc{(\ref {fs.op.funcs})}} {\memgloref{}}|memjustarg}{1491} -\glossaryentry{fs.op.funcs.general@ {\memgloterm{fs.op.funcs.general}}{\memglodesc{(\ref {fs.op.funcs.general})}} {\memgloref{}}|memjustarg}{1491} -\glossaryentry{fs.op.absolute@ {\memgloterm{fs.op.absolute}}{\memglodesc{(\ref {fs.op.absolute})}} {\memgloref{}}|memjustarg}{1491} -\glossaryentry{fs.op.canonical@ {\memgloterm{fs.op.canonical}}{\memglodesc{(\ref {fs.op.canonical})}} {\memgloref{}}|memjustarg}{1491} -\glossaryentry{fs.op.copy@ {\memgloterm{fs.op.copy}}{\memglodesc{(\ref {fs.op.copy})}} {\memgloref{}}|memjustarg}{1491} -\glossaryentry{fs.op.copy.file@ {\memgloterm{fs.op.copy.file}}{\memglodesc{(\ref {fs.op.copy.file})}} {\memgloref{}}|memjustarg}{1493} -\glossaryentry{fs.op.copy.symlink@ {\memgloterm{fs.op.copy.symlink}}{\memglodesc{(\ref {fs.op.copy.symlink})}} {\memgloref{}}|memjustarg}{1494} -\glossaryentry{fs.op.create.directories@ {\memgloterm{fs.op.create.directories}}{\memglodesc{(\ref {fs.op.create.directories})}} {\memgloref{}}|memjustarg}{1494} -\glossaryentry{fs.op.create.directory@ {\memgloterm{fs.op.create.directory}}{\memglodesc{(\ref {fs.op.create.directory})}} {\memgloref{}}|memjustarg}{1494} -\glossaryentry{fs.op.create.dir.symlk@ {\memgloterm{fs.op.create.dir.symlk}}{\memglodesc{(\ref {fs.op.create.dir.symlk})}} {\memgloref{}}|memjustarg}{1494} -\glossaryentry{fs.op.create.hard.lk@ {\memgloterm{fs.op.create.hard.lk}}{\memglodesc{(\ref {fs.op.create.hard.lk})}} {\memgloref{}}|memjustarg}{1495} -\glossaryentry{fs.op.create.symlink@ {\memgloterm{fs.op.create.symlink}}{\memglodesc{(\ref {fs.op.create.symlink})}} {\memgloref{}}|memjustarg}{1495} -\glossaryentry{fs.op.current.path@ {\memgloterm{fs.op.current.path}}{\memglodesc{(\ref {fs.op.current.path})}} {\memgloref{}}|memjustarg}{1495} -\glossaryentry{fs.op.equivalent@ {\memgloterm{fs.op.equivalent}}{\memglodesc{(\ref {fs.op.equivalent})}} {\memgloref{}}|memjustarg}{1496} -\glossaryentry{fs.op.exists@ {\memgloterm{fs.op.exists}}{\memglodesc{(\ref {fs.op.exists})}} {\memgloref{}}|memjustarg}{1496} -\glossaryentry{fs.op.file.size@ {\memgloterm{fs.op.file.size}}{\memglodesc{(\ref {fs.op.file.size})}} {\memgloref{}}|memjustarg}{1496} -\glossaryentry{fs.op.hard.lk.ct@ {\memgloterm{fs.op.hard.lk.ct}}{\memglodesc{(\ref {fs.op.hard.lk.ct})}} {\memgloref{}}|memjustarg}{1496} -\glossaryentry{fs.op.is.block.file@ {\memgloterm{fs.op.is.block.file}}{\memglodesc{(\ref {fs.op.is.block.file})}} {\memgloref{}}|memjustarg}{1497} -\glossaryentry{fs.op.is.char.file@ {\memgloterm{fs.op.is.char.file}}{\memglodesc{(\ref {fs.op.is.char.file})}} {\memgloref{}}|memjustarg}{1497} -\glossaryentry{fs.op.is.directory@ {\memgloterm{fs.op.is.directory}}{\memglodesc{(\ref {fs.op.is.directory})}} {\memgloref{}}|memjustarg}{1497} -\glossaryentry{fs.op.is.empty@ {\memgloterm{fs.op.is.empty}}{\memglodesc{(\ref {fs.op.is.empty})}} {\memgloref{}}|memjustarg}{1497} -\glossaryentry{fs.op.is.fifo@ {\memgloterm{fs.op.is.fifo}}{\memglodesc{(\ref {fs.op.is.fifo})}} {\memgloref{}}|memjustarg}{1497} -\glossaryentry{fs.op.is.other@ {\memgloterm{fs.op.is.other}}{\memglodesc{(\ref {fs.op.is.other})}} {\memgloref{}}|memjustarg}{1498} -\glossaryentry{fs.op.is.regular.file@ {\memgloterm{fs.op.is.regular.file}}{\memglodesc{(\ref {fs.op.is.regular.file})}} {\memgloref{}}|memjustarg}{1498} -\glossaryentry{fs.op.is.socket@ {\memgloterm{fs.op.is.socket}}{\memglodesc{(\ref {fs.op.is.socket})}} {\memgloref{}}|memjustarg}{1498} -\glossaryentry{fs.op.is.symlink@ {\memgloterm{fs.op.is.symlink}}{\memglodesc{(\ref {fs.op.is.symlink})}} {\memgloref{}}|memjustarg}{1498} -\glossaryentry{fs.op.last.write.time@ {\memgloterm{fs.op.last.write.time}}{\memglodesc{(\ref {fs.op.last.write.time})}} {\memgloref{}}|memjustarg}{1498} -\glossaryentry{fs.op.permissions@ {\memgloterm{fs.op.permissions}}{\memglodesc{(\ref {fs.op.permissions})}} {\memgloref{}}|memjustarg}{1499} -\glossaryentry{fs.op.proximate@ {\memgloterm{fs.op.proximate}}{\memglodesc{(\ref {fs.op.proximate})}} {\memgloref{}}|memjustarg}{1499} -\glossaryentry{fs.op.read.symlink@ {\memgloterm{fs.op.read.symlink}}{\memglodesc{(\ref {fs.op.read.symlink})}} {\memgloref{}}|memjustarg}{1499} -\glossaryentry{fs.op.relative@ {\memgloterm{fs.op.relative}}{\memglodesc{(\ref {fs.op.relative})}} {\memgloref{}}|memjustarg}{1500} -\glossaryentry{fs.op.remove@ {\memgloterm{fs.op.remove}}{\memglodesc{(\ref {fs.op.remove})}} {\memgloref{}}|memjustarg}{1500} -\glossaryentry{fs.op.remove.all@ {\memgloterm{fs.op.remove.all}}{\memglodesc{(\ref {fs.op.remove.all})}} {\memgloref{}}|memjustarg}{1500} -\glossaryentry{fs.op.rename@ {\memgloterm{fs.op.rename}}{\memglodesc{(\ref {fs.op.rename})}} {\memgloref{}}|memjustarg}{1500} -\glossaryentry{fs.op.resize.file@ {\memgloterm{fs.op.resize.file}}{\memglodesc{(\ref {fs.op.resize.file})}} {\memgloref{}}|memjustarg}{1501} -\glossaryentry{fs.op.space@ {\memgloterm{fs.op.space}}{\memglodesc{(\ref {fs.op.space})}} {\memgloref{}}|memjustarg}{1501} -\glossaryentry{fs.op.status@ {\memgloterm{fs.op.status}}{\memglodesc{(\ref {fs.op.status})}} {\memgloref{}}|memjustarg}{1501} -\glossaryentry{fs.op.status.known@ {\memgloterm{fs.op.status.known}}{\memglodesc{(\ref {fs.op.status.known})}} {\memgloref{}}|memjustarg}{1502} -\glossaryentry{fs.op.symlink.status@ {\memgloterm{fs.op.symlink.status}}{\memglodesc{(\ref {fs.op.symlink.status})}} {\memgloref{}}|memjustarg}{1502} -\glossaryentry{fs.op.temp.dir.path@ {\memgloterm{fs.op.temp.dir.path}}{\memglodesc{(\ref {fs.op.temp.dir.path})}} {\memgloref{}}|memjustarg}{1502} -\glossaryentry{fs.op.weakly.canonical@ {\memgloterm{fs.op.weakly.canonical}}{\memglodesc{(\ref {fs.op.weakly.canonical})}} {\memgloref{}}|memjustarg}{1503} -\glossaryentry{c.files@ {\memgloterm{c.files}}{\memglodesc{(\ref {c.files})}} {\memgloref{}}|memjustarg}{1503} -\glossaryentry{cstdio.syn@ {\memgloterm{cstdio.syn}}{\memglodesc{(\ref {cstdio.syn})}} {\memgloref{}}|memjustarg}{1503} -\glossaryentry{cinttypes.syn@ {\memgloterm{cinttypes.syn}}{\memglodesc{(\ref {cinttypes.syn})}} {\memgloref{}}|memjustarg}{1504} -\glossaryentry{re@ {\memgloterm{re}}{\memglodesc{(\ref {re})}} {\memgloref{}}|memjustarg}{1506} -\glossaryentry{re.general@ {\memgloterm{re.general}}{\memglodesc{(\ref {re.general})}} {\memgloref{}}|memjustarg}{1506} -\glossaryentry{re.def@ {\memgloterm{re.def}}{\memglodesc{(\ref {re.def})}} {\memgloref{}}|memjustarg}{1506} -\glossaryentry{defns.regex.collating.element@ {\memgloterm{defns.regex.collating.element}}{\memglodesc{(\ref {defns.regex.collating.element})}} {\memgloref{}}|memjustarg}{1506} -\glossaryentry{defns.regex.finite.state.machine@ {\memgloterm{defns.regex.finite.state.machine}}{\memglodesc{(\ref {defns.regex.finite.state.machine})}} {\memgloref{}}|memjustarg}{1506} -\glossaryentry{defns.regex.format.specifier@ {\memgloterm{defns.regex.format.specifier}}{\memglodesc{(\ref {defns.regex.format.specifier})}} {\memgloref{}}|memjustarg}{1506} -\glossaryentry{defns.regex.matched@ {\memgloterm{defns.regex.matched}}{\memglodesc{(\ref {defns.regex.matched})}} {\memgloref{}}|memjustarg}{1506} -\glossaryentry{defns.regex.primary.equivalence.class@ {\memgloterm{defns.regex.primary.equivalence.class}}{\memglodesc{(\ref {defns.regex.primary.equivalence.class})}} {\memgloref{}}|memjustarg}{1506} -\glossaryentry{defns.regex.regular.expression@ {\memgloterm{defns.regex.regular.expression}}{\memglodesc{(\ref {defns.regex.regular.expression})}} {\memgloref{}}|memjustarg}{1506} -\glossaryentry{defns.regex.subexpression@ {\memgloterm{defns.regex.subexpression}}{\memglodesc{(\ref {defns.regex.subexpression})}} {\memgloref{}}|memjustarg}{1507} -\glossaryentry{re.req@ {\memgloterm{re.req}}{\memglodesc{(\ref {re.req})}} {\memgloref{}}|memjustarg}{1507} -\glossaryentry{re.syn@ {\memgloterm{re.syn}}{\memglodesc{(\ref {re.syn})}} {\memgloref{}}|memjustarg}{1508} -\glossaryentry{re.const@ {\memgloterm{re.const}}{\memglodesc{(\ref {re.const})}} {\memgloref{}}|memjustarg}{1512} -\glossaryentry{re.const.general@ {\memgloterm{re.const.general}}{\memglodesc{(\ref {re.const.general})}} {\memgloref{}}|memjustarg}{1512} -\glossaryentry{re.synopt@ {\memgloterm{re.synopt}}{\memglodesc{(\ref {re.synopt})}} {\memgloref{}}|memjustarg}{1512} -\glossaryentry{re.matchflag@ {\memgloterm{re.matchflag}}{\memglodesc{(\ref {re.matchflag})}} {\memgloref{}}|memjustarg}{1512} -\glossaryentry{re.err@ {\memgloterm{re.err}}{\memglodesc{(\ref {re.err})}} {\memgloref{}}|memjustarg}{1514} -\glossaryentry{re.badexp@ {\memgloterm{re.badexp}}{\memglodesc{(\ref {re.badexp})}} {\memgloref{}}|memjustarg}{1515} -\glossaryentry{re.traits@ {\memgloterm{re.traits}}{\memglodesc{(\ref {re.traits})}} {\memgloref{}}|memjustarg}{1515} -\glossaryentry{re.regex@ {\memgloterm{re.regex}}{\memglodesc{(\ref {re.regex})}} {\memgloref{}}|memjustarg}{1517} -\glossaryentry{re.regex.general@ {\memgloterm{re.regex.general}}{\memglodesc{(\ref {re.regex.general})}} {\memgloref{}}|memjustarg}{1517} -\glossaryentry{re.regex.construct@ {\memgloterm{re.regex.construct}}{\memglodesc{(\ref {re.regex.construct})}} {\memgloref{}}|memjustarg}{1519} -\glossaryentry{re.regex.assign@ {\memgloterm{re.regex.assign}}{\memglodesc{(\ref {re.regex.assign})}} {\memgloref{}}|memjustarg}{1520} -\glossaryentry{re.regex.operations@ {\memgloterm{re.regex.operations}}{\memglodesc{(\ref {re.regex.operations})}} {\memgloref{}}|memjustarg}{1521} -\glossaryentry{re.regex.locale@ {\memgloterm{re.regex.locale}}{\memglodesc{(\ref {re.regex.locale})}} {\memgloref{}}|memjustarg}{1521} -\glossaryentry{re.regex.swap@ {\memgloterm{re.regex.swap}}{\memglodesc{(\ref {re.regex.swap})}} {\memgloref{}}|memjustarg}{1521} -\glossaryentry{re.regex.nonmemb@ {\memgloterm{re.regex.nonmemb}}{\memglodesc{(\ref {re.regex.nonmemb})}} {\memgloref{}}|memjustarg}{1522} -\glossaryentry{re.submatch@ {\memgloterm{re.submatch}}{\memglodesc{(\ref {re.submatch})}} {\memgloref{}}|memjustarg}{1522} -\glossaryentry{re.submatch.general@ {\memgloterm{re.submatch.general}}{\memglodesc{(\ref {re.submatch.general})}} {\memgloref{}}|memjustarg}{1522} -\glossaryentry{re.submatch.members@ {\memgloterm{re.submatch.members}}{\memglodesc{(\ref {re.submatch.members})}} {\memgloref{}}|memjustarg}{1522} -\glossaryentry{re.submatch.op@ {\memgloterm{re.submatch.op}}{\memglodesc{(\ref {re.submatch.op})}} {\memgloref{}}|memjustarg}{1522} -\glossaryentry{re.results@ {\memgloterm{re.results}}{\memglodesc{(\ref {re.results})}} {\memgloref{}}|memjustarg}{1523} -\glossaryentry{re.results.general@ {\memgloterm{re.results.general}}{\memglodesc{(\ref {re.results.general})}} {\memgloref{}}|memjustarg}{1523} -\glossaryentry{re.results.const@ {\memgloterm{re.results.const}}{\memglodesc{(\ref {re.results.const})}} {\memgloref{}}|memjustarg}{1525} -\glossaryentry{re.results.state@ {\memgloterm{re.results.state}}{\memglodesc{(\ref {re.results.state})}} {\memgloref{}}|memjustarg}{1526} -\glossaryentry{re.results.size@ {\memgloterm{re.results.size}}{\memglodesc{(\ref {re.results.size})}} {\memgloref{}}|memjustarg}{1526} -\glossaryentry{re.results.acc@ {\memgloterm{re.results.acc}}{\memglodesc{(\ref {re.results.acc})}} {\memgloref{}}|memjustarg}{1526} -\glossaryentry{re.results.form@ {\memgloterm{re.results.form}}{\memglodesc{(\ref {re.results.form})}} {\memgloref{}}|memjustarg}{1527} -\glossaryentry{re.results.all@ {\memgloterm{re.results.all}}{\memglodesc{(\ref {re.results.all})}} {\memgloref{}}|memjustarg}{1527} -\glossaryentry{re.results.swap@ {\memgloterm{re.results.swap}}{\memglodesc{(\ref {re.results.swap})}} {\memgloref{}}|memjustarg}{1527} -\glossaryentry{re.results.nonmember@ {\memgloterm{re.results.nonmember}}{\memglodesc{(\ref {re.results.nonmember})}} {\memgloref{}}|memjustarg}{1528} -\glossaryentry{re.alg@ {\memgloterm{re.alg}}{\memglodesc{(\ref {re.alg})}} {\memgloref{}}|memjustarg}{1528} -\glossaryentry{re.except@ {\memgloterm{re.except}}{\memglodesc{(\ref {re.except})}} {\memgloref{}}|memjustarg}{1528} -\glossaryentry{re.alg.match@ {\memgloterm{re.alg.match}}{\memglodesc{(\ref {re.alg.match})}} {\memgloref{}}|memjustarg}{1528} -\glossaryentry{re.alg.search@ {\memgloterm{re.alg.search}}{\memglodesc{(\ref {re.alg.search})}} {\memgloref{}}|memjustarg}{1529} -\glossaryentry{re.alg.replace@ {\memgloterm{re.alg.replace}}{\memglodesc{(\ref {re.alg.replace})}} {\memgloref{}}|memjustarg}{1531} -\glossaryentry{re.iter@ {\memgloterm{re.iter}}{\memglodesc{(\ref {re.iter})}} {\memgloref{}}|memjustarg}{1532} -\glossaryentry{re.regiter@ {\memgloterm{re.regiter}}{\memglodesc{(\ref {re.regiter})}} {\memgloref{}}|memjustarg}{1532} -\glossaryentry{re.regiter.general@ {\memgloterm{re.regiter.general}}{\memglodesc{(\ref {re.regiter.general})}} {\memgloref{}}|memjustarg}{1532} -\glossaryentry{re.regiter.cnstr@ {\memgloterm{re.regiter.cnstr}}{\memglodesc{(\ref {re.regiter.cnstr})}} {\memgloref{}}|memjustarg}{1533} -\glossaryentry{re.regiter.comp@ {\memgloterm{re.regiter.comp}}{\memglodesc{(\ref {re.regiter.comp})}} {\memgloref{}}|memjustarg}{1533} -\glossaryentry{re.regiter.deref@ {\memgloterm{re.regiter.deref}}{\memglodesc{(\ref {re.regiter.deref})}} {\memgloref{}}|memjustarg}{1533} -\glossaryentry{re.regiter.incr@ {\memgloterm{re.regiter.incr}}{\memglodesc{(\ref {re.regiter.incr})}} {\memgloref{}}|memjustarg}{1534} -\glossaryentry{re.tokiter@ {\memgloterm{re.tokiter}}{\memglodesc{(\ref {re.tokiter})}} {\memgloref{}}|memjustarg}{1534} -\glossaryentry{re.tokiter.general@ {\memgloterm{re.tokiter.general}}{\memglodesc{(\ref {re.tokiter.general})}} {\memgloref{}}|memjustarg}{1534} -\glossaryentry{re.tokiter.cnstr@ {\memgloterm{re.tokiter.cnstr}}{\memglodesc{(\ref {re.tokiter.cnstr})}} {\memgloref{}}|memjustarg}{1536} -\glossaryentry{re.tokiter.comp@ {\memgloterm{re.tokiter.comp}}{\memglodesc{(\ref {re.tokiter.comp})}} {\memgloref{}}|memjustarg}{1537} -\glossaryentry{re.tokiter.deref@ {\memgloterm{re.tokiter.deref}}{\memglodesc{(\ref {re.tokiter.deref})}} {\memgloref{}}|memjustarg}{1537} -\glossaryentry{re.tokiter.incr@ {\memgloterm{re.tokiter.incr}}{\memglodesc{(\ref {re.tokiter.incr})}} {\memgloref{}}|memjustarg}{1537} -\glossaryentry{re.grammar@ {\memgloterm{re.grammar}}{\memglodesc{(\ref {re.grammar})}} {\memgloref{}}|memjustarg}{1537} -\glossaryentry{atomics@ {\memgloterm{atomics}}{\memglodesc{(\ref {atomics})}} {\memgloref{}}|memjustarg}{1540} -\glossaryentry{atomics.general@ {\memgloterm{atomics.general}}{\memglodesc{(\ref {atomics.general})}} {\memgloref{}}|memjustarg}{1540} -\glossaryentry{atomics.syn@ {\memgloterm{atomics.syn}}{\memglodesc{(\ref {atomics.syn})}} {\memgloref{}}|memjustarg}{1540} -\glossaryentry{atomics.alias@ {\memgloterm{atomics.alias}}{\memglodesc{(\ref {atomics.alias})}} {\memgloref{}}|memjustarg}{1544} -\glossaryentry{atomics.order@ {\memgloterm{atomics.order}}{\memglodesc{(\ref {atomics.order})}} {\memgloref{}}|memjustarg}{1544} -\glossaryentry{atomics.lockfree@ {\memgloterm{atomics.lockfree}}{\memglodesc{(\ref {atomics.lockfree})}} {\memgloref{}}|memjustarg}{1546} -\glossaryentry{atomics.wait@ {\memgloterm{atomics.wait}}{\memglodesc{(\ref {atomics.wait})}} {\memgloref{}}|memjustarg}{1546} -\glossaryentry{atomics.ref.generic@ {\memgloterm{atomics.ref.generic}}{\memglodesc{(\ref {atomics.ref.generic})}} {\memgloref{}}|memjustarg}{1547} -\glossaryentry{atomics.ref.generic.general@ {\memgloterm{atomics.ref.generic.general}}{\memglodesc{(\ref {atomics.ref.generic.general})}} {\memgloref{}}|memjustarg}{1547} -\glossaryentry{atomics.ref.ops@ {\memgloterm{atomics.ref.ops}}{\memglodesc{(\ref {atomics.ref.ops})}} {\memgloref{}}|memjustarg}{1548} -\glossaryentry{atomics.ref.int@ {\memgloterm{atomics.ref.int}}{\memglodesc{(\ref {atomics.ref.int})}} {\memgloref{}}|memjustarg}{1550} -\glossaryentry{atomics.ref.float@ {\memgloterm{atomics.ref.float}}{\memglodesc{(\ref {atomics.ref.float})}} {\memgloref{}}|memjustarg}{1551} -\glossaryentry{atomics.ref.pointer@ {\memgloterm{atomics.ref.pointer}}{\memglodesc{(\ref {atomics.ref.pointer})}} {\memgloref{}}|memjustarg}{1552} -\glossaryentry{atomics.ref.memop@ {\memgloterm{atomics.ref.memop}}{\memglodesc{(\ref {atomics.ref.memop})}} {\memgloref{}}|memjustarg}{1553} -\glossaryentry{atomics.types.generic@ {\memgloterm{atomics.types.generic}}{\memglodesc{(\ref {atomics.types.generic})}} {\memgloref{}}|memjustarg}{1553} -\glossaryentry{atomics.types.generic.general@ {\memgloterm{atomics.types.generic.general}}{\memglodesc{(\ref {atomics.types.generic.general})}} {\memgloref{}}|memjustarg}{1553} -\glossaryentry{atomics.types.operations@ {\memgloterm{atomics.types.operations}}{\memglodesc{(\ref {atomics.types.operations})}} {\memgloref{}}|memjustarg}{1554} -\glossaryentry{atomics.types.int@ {\memgloterm{atomics.types.int}}{\memglodesc{(\ref {atomics.types.int})}} {\memgloref{}}|memjustarg}{1558} -\glossaryentry{atomics.types.float@ {\memgloterm{atomics.types.float}}{\memglodesc{(\ref {atomics.types.float})}} {\memgloref{}}|memjustarg}{1560} -\glossaryentry{atomics.types.pointer@ {\memgloterm{atomics.types.pointer}}{\memglodesc{(\ref {atomics.types.pointer})}} {\memgloref{}}|memjustarg}{1561} -\glossaryentry{atomics.types.memop@ {\memgloterm{atomics.types.memop}}{\memglodesc{(\ref {atomics.types.memop})}} {\memgloref{}}|memjustarg}{1563} -\glossaryentry{util.smartptr.atomic@ {\memgloterm{util.smartptr.atomic}}{\memglodesc{(\ref {util.smartptr.atomic})}} {\memgloref{}}|memjustarg}{1563} -\glossaryentry{util.smartptr.atomic.general@ {\memgloterm{util.smartptr.atomic.general}}{\memglodesc{(\ref {util.smartptr.atomic.general})}} {\memgloref{}}|memjustarg}{1563} -\glossaryentry{util.smartptr.atomic.shared@ {\memgloterm{util.smartptr.atomic.shared}}{\memglodesc{(\ref {util.smartptr.atomic.shared})}} {\memgloref{}}|memjustarg}{1564} -\glossaryentry{util.smartptr.atomic.weak@ {\memgloterm{util.smartptr.atomic.weak}}{\memglodesc{(\ref {util.smartptr.atomic.weak})}} {\memgloref{}}|memjustarg}{1566} -\glossaryentry{atomics.nonmembers@ {\memgloterm{atomics.nonmembers}}{\memglodesc{(\ref {atomics.nonmembers})}} {\memgloref{}}|memjustarg}{1568} -\glossaryentry{atomics.flag@ {\memgloterm{atomics.flag}}{\memglodesc{(\ref {atomics.flag})}} {\memgloref{}}|memjustarg}{1568} -\glossaryentry{atomics.fences@ {\memgloterm{atomics.fences}}{\memglodesc{(\ref {atomics.fences})}} {\memgloref{}}|memjustarg}{1570} -\glossaryentry{thread@ {\memgloterm{thread}}{\memglodesc{(\ref {thread})}} {\memgloref{}}|memjustarg}{1572} -\glossaryentry{thread.general@ {\memgloterm{thread.general}}{\memglodesc{(\ref {thread.general})}} {\memgloref{}}|memjustarg}{1572} -\glossaryentry{thread.req@ {\memgloterm{thread.req}}{\memglodesc{(\ref {thread.req})}} {\memgloref{}}|memjustarg}{1572} -\glossaryentry{thread.req.paramname@ {\memgloterm{thread.req.paramname}}{\memglodesc{(\ref {thread.req.paramname})}} {\memgloref{}}|memjustarg}{1572} -\glossaryentry{thread.req.exception@ {\memgloterm{thread.req.exception}}{\memglodesc{(\ref {thread.req.exception})}} {\memgloref{}}|memjustarg}{1572} -\glossaryentry{thread.req.native@ {\memgloterm{thread.req.native}}{\memglodesc{(\ref {thread.req.native})}} {\memgloref{}}|memjustarg}{1572} -\glossaryentry{thread.req.timing@ {\memgloterm{thread.req.timing}}{\memglodesc{(\ref {thread.req.timing})}} {\memgloref{}}|memjustarg}{1572} -\glossaryentry{thread.req.lockable@ {\memgloterm{thread.req.lockable}}{\memglodesc{(\ref {thread.req.lockable})}} {\memgloref{}}|memjustarg}{1573} -\glossaryentry{thread.req.lockable.general@ {\memgloterm{thread.req.lockable.general}}{\memglodesc{(\ref {thread.req.lockable.general})}} {\memgloref{}}|memjustarg}{1573} -\glossaryentry{thread.req.lockable.basic@ {\memgloterm{thread.req.lockable.basic}}{\memglodesc{(\ref {thread.req.lockable.basic})}} {\memgloref{}}|memjustarg}{1574} -\glossaryentry{thread.req.lockable.req@ {\memgloterm{thread.req.lockable.req}}{\memglodesc{(\ref {thread.req.lockable.req})}} {\memgloref{}}|memjustarg}{1574} -\glossaryentry{thread.req.lockable.timed@ {\memgloterm{thread.req.lockable.timed}}{\memglodesc{(\ref {thread.req.lockable.timed})}} {\memgloref{}}|memjustarg}{1574} -\glossaryentry{thread.stoptoken@ {\memgloterm{thread.stoptoken}}{\memglodesc{(\ref {thread.stoptoken})}} {\memgloref{}}|memjustarg}{1574} -\glossaryentry{thread.stoptoken.intro@ {\memgloterm{thread.stoptoken.intro}}{\memglodesc{(\ref {thread.stoptoken.intro})}} {\memgloref{}}|memjustarg}{1574} -\glossaryentry{thread.stoptoken.syn@ {\memgloterm{thread.stoptoken.syn}}{\memglodesc{(\ref {thread.stoptoken.syn})}} {\memgloref{}}|memjustarg}{1575} -\glossaryentry{stoptoken@ {\memgloterm{stoptoken}}{\memglodesc{(\ref {stoptoken})}} {\memgloref{}}|memjustarg}{1575} -\glossaryentry{stoptoken.general@ {\memgloterm{stoptoken.general}}{\memglodesc{(\ref {stoptoken.general})}} {\memgloref{}}|memjustarg}{1575} -\glossaryentry{stoptoken.cons@ {\memgloterm{stoptoken.cons}}{\memglodesc{(\ref {stoptoken.cons})}} {\memgloref{}}|memjustarg}{1576} -\glossaryentry{stoptoken.mem@ {\memgloterm{stoptoken.mem}}{\memglodesc{(\ref {stoptoken.mem})}} {\memgloref{}}|memjustarg}{1576} -\glossaryentry{stoptoken.nonmembers@ {\memgloterm{stoptoken.nonmembers}}{\memglodesc{(\ref {stoptoken.nonmembers})}} {\memgloref{}}|memjustarg}{1576} -\glossaryentry{stopsource@ {\memgloterm{stopsource}}{\memglodesc{(\ref {stopsource})}} {\memgloref{}}|memjustarg}{1576} -\glossaryentry{stopsource.general@ {\memgloterm{stopsource.general}}{\memglodesc{(\ref {stopsource.general})}} {\memgloref{}}|memjustarg}{1576} -\glossaryentry{stopsource.cons@ {\memgloterm{stopsource.cons}}{\memglodesc{(\ref {stopsource.cons})}} {\memgloref{}}|memjustarg}{1577} -\glossaryentry{stopsource.mem@ {\memgloterm{stopsource.mem}}{\memglodesc{(\ref {stopsource.mem})}} {\memgloref{}}|memjustarg}{1578} -\glossaryentry{stopsource.nonmembers@ {\memgloterm{stopsource.nonmembers}}{\memglodesc{(\ref {stopsource.nonmembers})}} {\memgloref{}}|memjustarg}{1578} -\glossaryentry{stopcallback@ {\memgloterm{stopcallback}}{\memglodesc{(\ref {stopcallback})}} {\memgloref{}}|memjustarg}{1578} -\glossaryentry{stopcallback.general@ {\memgloterm{stopcallback.general}}{\memglodesc{(\ref {stopcallback.general})}} {\memgloref{}}|memjustarg}{1578} -\glossaryentry{stopcallback.cons@ {\memgloterm{stopcallback.cons}}{\memglodesc{(\ref {stopcallback.cons})}} {\memgloref{}}|memjustarg}{1579} -\glossaryentry{thread.threads@ {\memgloterm{thread.threads}}{\memglodesc{(\ref {thread.threads})}} {\memgloref{}}|memjustarg}{1579} -\glossaryentry{thread.threads.general@ {\memgloterm{thread.threads.general}}{\memglodesc{(\ref {thread.threads.general})}} {\memgloref{}}|memjustarg}{1579} -\glossaryentry{thread.syn@ {\memgloterm{thread.syn}}{\memglodesc{(\ref {thread.syn})}} {\memgloref{}}|memjustarg}{1579} -\glossaryentry{thread.thread.class@ {\memgloterm{thread.thread.class}}{\memglodesc{(\ref {thread.thread.class})}} {\memgloref{}}|memjustarg}{1580} -\glossaryentry{thread.thread.class.general@ {\memgloterm{thread.thread.class.general}}{\memglodesc{(\ref {thread.thread.class.general})}} {\memgloref{}}|memjustarg}{1580} -\glossaryentry{thread.thread.id@ {\memgloterm{thread.thread.id}}{\memglodesc{(\ref {thread.thread.id})}} {\memgloref{}}|memjustarg}{1580} -\glossaryentry{thread.thread.constr@ {\memgloterm{thread.thread.constr}}{\memglodesc{(\ref {thread.thread.constr})}} {\memgloref{}}|memjustarg}{1581} -\glossaryentry{thread.thread.destr@ {\memgloterm{thread.thread.destr}}{\memglodesc{(\ref {thread.thread.destr})}} {\memgloref{}}|memjustarg}{1582} -\glossaryentry{thread.thread.assign@ {\memgloterm{thread.thread.assign}}{\memglodesc{(\ref {thread.thread.assign})}} {\memgloref{}}|memjustarg}{1582} -\glossaryentry{thread.thread.member@ {\memgloterm{thread.thread.member}}{\memglodesc{(\ref {thread.thread.member})}} {\memgloref{}}|memjustarg}{1582} -\glossaryentry{thread.thread.static@ {\memgloterm{thread.thread.static}}{\memglodesc{(\ref {thread.thread.static})}} {\memgloref{}}|memjustarg}{1583} -\glossaryentry{thread.thread.algorithm@ {\memgloterm{thread.thread.algorithm}}{\memglodesc{(\ref {thread.thread.algorithm})}} {\memgloref{}}|memjustarg}{1583} -\glossaryentry{thread.jthread.class@ {\memgloterm{thread.jthread.class}}{\memglodesc{(\ref {thread.jthread.class})}} {\memgloref{}}|memjustarg}{1583} -\glossaryentry{thread.jthread.class.general@ {\memgloterm{thread.jthread.class.general}}{\memglodesc{(\ref {thread.jthread.class.general})}} {\memgloref{}}|memjustarg}{1583} -\glossaryentry{thread.jthread.cons@ {\memgloterm{thread.jthread.cons}}{\memglodesc{(\ref {thread.jthread.cons})}} {\memgloref{}}|memjustarg}{1584} -\glossaryentry{thread.jthread.mem@ {\memgloterm{thread.jthread.mem}}{\memglodesc{(\ref {thread.jthread.mem})}} {\memgloref{}}|memjustarg}{1585} -\glossaryentry{thread.jthread.stop@ {\memgloterm{thread.jthread.stop}}{\memglodesc{(\ref {thread.jthread.stop})}} {\memgloref{}}|memjustarg}{1586} -\glossaryentry{thread.jthread.special@ {\memgloterm{thread.jthread.special}}{\memglodesc{(\ref {thread.jthread.special})}} {\memgloref{}}|memjustarg}{1586} -\glossaryentry{thread.jthread.static@ {\memgloterm{thread.jthread.static}}{\memglodesc{(\ref {thread.jthread.static})}} {\memgloref{}}|memjustarg}{1586} -\glossaryentry{thread.thread.this@ {\memgloterm{thread.thread.this}}{\memglodesc{(\ref {thread.thread.this})}} {\memgloref{}}|memjustarg}{1586} -\glossaryentry{thread.mutex@ {\memgloterm{thread.mutex}}{\memglodesc{(\ref {thread.mutex})}} {\memgloref{}}|memjustarg}{1586} -\glossaryentry{thread.mutex.general@ {\memgloterm{thread.mutex.general}}{\memglodesc{(\ref {thread.mutex.general})}} {\memgloref{}}|memjustarg}{1586} -\glossaryentry{mutex.syn@ {\memgloterm{mutex.syn}}{\memglodesc{(\ref {mutex.syn})}} {\memgloref{}}|memjustarg}{1587} -\glossaryentry{shared.mutex.syn@ {\memgloterm{shared.mutex.syn}}{\memglodesc{(\ref {shared.mutex.syn})}} {\memgloref{}}|memjustarg}{1587} -\glossaryentry{thread.mutex.requirements@ {\memgloterm{thread.mutex.requirements}}{\memglodesc{(\ref {thread.mutex.requirements})}} {\memgloref{}}|memjustarg}{1587} -\glossaryentry{thread.mutex.requirements.general@ {\memgloterm{thread.mutex.requirements.general}}{\memglodesc{(\ref {thread.mutex.requirements.general})}} {\memgloref{}}|memjustarg}{1587} -\glossaryentry{thread.mutex.requirements.mutex@ {\memgloterm{thread.mutex.requirements.mutex}}{\memglodesc{(\ref {thread.mutex.requirements.mutex})}} {\memgloref{}}|memjustarg}{1587} -\glossaryentry{thread.mutex.requirements.mutex.general@ {\memgloterm{thread.mutex.requirements.mutex.general}}{\memglodesc{(\ref {thread.mutex.requirements.mutex.general})}} {\memgloref{}}|memjustarg}{1587} -\glossaryentry{thread.mutex.class@ {\memgloterm{thread.mutex.class}}{\memglodesc{(\ref {thread.mutex.class})}} {\memgloref{}}|memjustarg}{1588} -\glossaryentry{thread.mutex.recursive@ {\memgloterm{thread.mutex.recursive}}{\memglodesc{(\ref {thread.mutex.recursive})}} {\memgloref{}}|memjustarg}{1589} -\glossaryentry{thread.timedmutex.requirements@ {\memgloterm{thread.timedmutex.requirements}}{\memglodesc{(\ref {thread.timedmutex.requirements})}} {\memgloref{}}|memjustarg}{1590} -\glossaryentry{thread.timedmutex.requirements.general@ {\memgloterm{thread.timedmutex.requirements.general}}{\memglodesc{(\ref {thread.timedmutex.requirements.general})}} {\memgloref{}}|memjustarg}{1590} -\glossaryentry{thread.timedmutex.class@ {\memgloterm{thread.timedmutex.class}}{\memglodesc{(\ref {thread.timedmutex.class})}} {\memgloref{}}|memjustarg}{1590} -\glossaryentry{thread.timedmutex.recursive@ {\memgloterm{thread.timedmutex.recursive}}{\memglodesc{(\ref {thread.timedmutex.recursive})}} {\memgloref{}}|memjustarg}{1591} -\glossaryentry{thread.sharedmutex.requirements@ {\memgloterm{thread.sharedmutex.requirements}}{\memglodesc{(\ref {thread.sharedmutex.requirements})}} {\memgloref{}}|memjustarg}{1592} -\glossaryentry{thread.sharedmutex.requirements.general@ {\memgloterm{thread.sharedmutex.requirements.general}}{\memglodesc{(\ref {thread.sharedmutex.requirements.general})}} {\memgloref{}}|memjustarg}{1592} -\glossaryentry{thread.sharedmutex.class@ {\memgloterm{thread.sharedmutex.class}}{\memglodesc{(\ref {thread.sharedmutex.class})}} {\memgloref{}}|memjustarg}{1592} -\glossaryentry{thread.sharedtimedmutex.requirements@ {\memgloterm{thread.sharedtimedmutex.requirements}}{\memglodesc{(\ref {thread.sharedtimedmutex.requirements})}} {\memgloref{}}|memjustarg}{1593} -\glossaryentry{thread.sharedtimedmutex.requirements.general@ {\memgloterm{thread.sharedtimedmutex.requirements.general}}{\memglodesc{(\ref {thread.sharedtimedmutex.requirements.general})}} {\memgloref{}}|memjustarg}{1593} -\glossaryentry{thread.sharedtimedmutex.class@ {\memgloterm{thread.sharedtimedmutex.class}}{\memglodesc{(\ref {thread.sharedtimedmutex.class})}} {\memgloref{}}|memjustarg}{1594} -\glossaryentry{thread.lock@ {\memgloterm{thread.lock}}{\memglodesc{(\ref {thread.lock})}} {\memgloref{}}|memjustarg}{1594} -\glossaryentry{thread.lock.general@ {\memgloterm{thread.lock.general}}{\memglodesc{(\ref {thread.lock.general})}} {\memgloref{}}|memjustarg}{1594} -\glossaryentry{thread.lock.guard@ {\memgloterm{thread.lock.guard}}{\memglodesc{(\ref {thread.lock.guard})}} {\memgloref{}}|memjustarg}{1595} -\glossaryentry{thread.lock.scoped@ {\memgloterm{thread.lock.scoped}}{\memglodesc{(\ref {thread.lock.scoped})}} {\memgloref{}}|memjustarg}{1595} -\glossaryentry{thread.lock.unique@ {\memgloterm{thread.lock.unique}}{\memglodesc{(\ref {thread.lock.unique})}} {\memgloref{}}|memjustarg}{1596} -\glossaryentry{thread.lock.unique.general@ {\memgloterm{thread.lock.unique.general}}{\memglodesc{(\ref {thread.lock.unique.general})}} {\memgloref{}}|memjustarg}{1596} -\glossaryentry{thread.lock.unique.cons@ {\memgloterm{thread.lock.unique.cons}}{\memglodesc{(\ref {thread.lock.unique.cons})}} {\memgloref{}}|memjustarg}{1597} -\glossaryentry{thread.lock.unique.locking@ {\memgloterm{thread.lock.unique.locking}}{\memglodesc{(\ref {thread.lock.unique.locking})}} {\memgloref{}}|memjustarg}{1598} -\glossaryentry{thread.lock.unique.mod@ {\memgloterm{thread.lock.unique.mod}}{\memglodesc{(\ref {thread.lock.unique.mod})}} {\memgloref{}}|memjustarg}{1599} -\glossaryentry{thread.lock.unique.obs@ {\memgloterm{thread.lock.unique.obs}}{\memglodesc{(\ref {thread.lock.unique.obs})}} {\memgloref{}}|memjustarg}{1599} -\glossaryentry{thread.lock.shared@ {\memgloterm{thread.lock.shared}}{\memglodesc{(\ref {thread.lock.shared})}} {\memgloref{}}|memjustarg}{1600} -\glossaryentry{thread.lock.shared.general@ {\memgloterm{thread.lock.shared.general}}{\memglodesc{(\ref {thread.lock.shared.general})}} {\memgloref{}}|memjustarg}{1600} -\glossaryentry{thread.lock.shared.cons@ {\memgloterm{thread.lock.shared.cons}}{\memglodesc{(\ref {thread.lock.shared.cons})}} {\memgloref{}}|memjustarg}{1601} -\glossaryentry{thread.lock.shared.locking@ {\memgloterm{thread.lock.shared.locking}}{\memglodesc{(\ref {thread.lock.shared.locking})}} {\memgloref{}}|memjustarg}{1602} -\glossaryentry{thread.lock.shared.mod@ {\memgloterm{thread.lock.shared.mod}}{\memglodesc{(\ref {thread.lock.shared.mod})}} {\memgloref{}}|memjustarg}{1603} -\glossaryentry{thread.lock.shared.obs@ {\memgloterm{thread.lock.shared.obs}}{\memglodesc{(\ref {thread.lock.shared.obs})}} {\memgloref{}}|memjustarg}{1603} -\glossaryentry{thread.lock.algorithm@ {\memgloterm{thread.lock.algorithm}}{\memglodesc{(\ref {thread.lock.algorithm})}} {\memgloref{}}|memjustarg}{1603} -\glossaryentry{thread.once@ {\memgloterm{thread.once}}{\memglodesc{(\ref {thread.once})}} {\memgloref{}}|memjustarg}{1603} -\glossaryentry{thread.once.onceflag@ {\memgloterm{thread.once.onceflag}}{\memglodesc{(\ref {thread.once.onceflag})}} {\memgloref{}}|memjustarg}{1603} -\glossaryentry{thread.once.callonce@ {\memgloterm{thread.once.callonce}}{\memglodesc{(\ref {thread.once.callonce})}} {\memgloref{}}|memjustarg}{1604} -\glossaryentry{thread.condition@ {\memgloterm{thread.condition}}{\memglodesc{(\ref {thread.condition})}} {\memgloref{}}|memjustarg}{1605} -\glossaryentry{thread.condition.general@ {\memgloterm{thread.condition.general}}{\memglodesc{(\ref {thread.condition.general})}} {\memgloref{}}|memjustarg}{1605} -\glossaryentry{condition.variable.syn@ {\memgloterm{condition.variable.syn}}{\memglodesc{(\ref {condition.variable.syn})}} {\memgloref{}}|memjustarg}{1605} -\glossaryentry{thread.condition.nonmember@ {\memgloterm{thread.condition.nonmember}}{\memglodesc{(\ref {thread.condition.nonmember})}} {\memgloref{}}|memjustarg}{1605} -\glossaryentry{thread.condition.condvar@ {\memgloterm{thread.condition.condvar}}{\memglodesc{(\ref {thread.condition.condvar})}} {\memgloref{}}|memjustarg}{1606} -\glossaryentry{thread.condition.condvarany@ {\memgloterm{thread.condition.condvarany}}{\memglodesc{(\ref {thread.condition.condvarany})}} {\memgloref{}}|memjustarg}{1609} -\glossaryentry{thread.condition.condvarany.general@ {\memgloterm{thread.condition.condvarany.general}}{\memglodesc{(\ref {thread.condition.condvarany.general})}} {\memgloref{}}|memjustarg}{1609} -\glossaryentry{thread.condvarany.wait@ {\memgloterm{thread.condvarany.wait}}{\memglodesc{(\ref {thread.condvarany.wait})}} {\memgloref{}}|memjustarg}{1610} -\glossaryentry{thread.condvarany.intwait@ {\memgloterm{thread.condvarany.intwait}}{\memglodesc{(\ref {thread.condvarany.intwait})}} {\memgloref{}}|memjustarg}{1611} -\glossaryentry{thread.sema@ {\memgloterm{thread.sema}}{\memglodesc{(\ref {thread.sema})}} {\memgloref{}}|memjustarg}{1612} -\glossaryentry{thread.sema.general@ {\memgloterm{thread.sema.general}}{\memglodesc{(\ref {thread.sema.general})}} {\memgloref{}}|memjustarg}{1612} -\glossaryentry{semaphore.syn@ {\memgloterm{semaphore.syn}}{\memglodesc{(\ref {semaphore.syn})}} {\memgloref{}}|memjustarg}{1612} -\glossaryentry{thread.sema.cnt@ {\memgloterm{thread.sema.cnt}}{\memglodesc{(\ref {thread.sema.cnt})}} {\memgloref{}}|memjustarg}{1612} -\glossaryentry{thread.coord@ {\memgloterm{thread.coord}}{\memglodesc{(\ref {thread.coord})}} {\memgloref{}}|memjustarg}{1614} -\glossaryentry{thread.coord.general@ {\memgloterm{thread.coord.general}}{\memglodesc{(\ref {thread.coord.general})}} {\memgloref{}}|memjustarg}{1614} -\glossaryentry{thread.latch@ {\memgloterm{thread.latch}}{\memglodesc{(\ref {thread.latch})}} {\memgloref{}}|memjustarg}{1614} -\glossaryentry{thread.latch.general@ {\memgloterm{thread.latch.general}}{\memglodesc{(\ref {thread.latch.general})}} {\memgloref{}}|memjustarg}{1614} -\glossaryentry{latch.syn@ {\memgloterm{latch.syn}}{\memglodesc{(\ref {latch.syn})}} {\memgloref{}}|memjustarg}{1614} -\glossaryentry{thread.latch.class@ {\memgloterm{thread.latch.class}}{\memglodesc{(\ref {thread.latch.class})}} {\memgloref{}}|memjustarg}{1614} -\glossaryentry{thread.barrier@ {\memgloterm{thread.barrier}}{\memglodesc{(\ref {thread.barrier})}} {\memgloref{}}|memjustarg}{1615} -\glossaryentry{thread.barrier.general@ {\memgloterm{thread.barrier.general}}{\memglodesc{(\ref {thread.barrier.general})}} {\memgloref{}}|memjustarg}{1615} -\glossaryentry{barrier.syn@ {\memgloterm{barrier.syn}}{\memglodesc{(\ref {barrier.syn})}} {\memgloref{}}|memjustarg}{1615} -\glossaryentry{thread.barrier.class@ {\memgloterm{thread.barrier.class}}{\memglodesc{(\ref {thread.barrier.class})}} {\memgloref{}}|memjustarg}{1615} -\glossaryentry{futures@ {\memgloterm{futures}}{\memglodesc{(\ref {futures})}} {\memgloref{}}|memjustarg}{1617} -\glossaryentry{futures.overview@ {\memgloterm{futures.overview}}{\memglodesc{(\ref {futures.overview})}} {\memgloref{}}|memjustarg}{1617} -\glossaryentry{future.syn@ {\memgloterm{future.syn}}{\memglodesc{(\ref {future.syn})}} {\memgloref{}}|memjustarg}{1617} -\glossaryentry{futures.errors@ {\memgloterm{futures.errors}}{\memglodesc{(\ref {futures.errors})}} {\memgloref{}}|memjustarg}{1618} -\glossaryentry{futures.future.error@ {\memgloterm{futures.future.error}}{\memglodesc{(\ref {futures.future.error})}} {\memgloref{}}|memjustarg}{1618} -\glossaryentry{futures.state@ {\memgloterm{futures.state}}{\memglodesc{(\ref {futures.state})}} {\memgloref{}}|memjustarg}{1619} -\glossaryentry{futures.promise@ {\memgloterm{futures.promise}}{\memglodesc{(\ref {futures.promise})}} {\memgloref{}}|memjustarg}{1620} -\glossaryentry{futures.unique.future@ {\memgloterm{futures.unique.future}}{\memglodesc{(\ref {futures.unique.future})}} {\memgloref{}}|memjustarg}{1622} -\glossaryentry{futures.shared.future@ {\memgloterm{futures.shared.future}}{\memglodesc{(\ref {futures.shared.future})}} {\memgloref{}}|memjustarg}{1624} -\glossaryentry{futures.async@ {\memgloterm{futures.async}}{\memglodesc{(\ref {futures.async})}} {\memgloref{}}|memjustarg}{1627} -\glossaryentry{futures.task@ {\memgloterm{futures.task}}{\memglodesc{(\ref {futures.task})}} {\memgloref{}}|memjustarg}{1628} -\glossaryentry{futures.task.general@ {\memgloterm{futures.task.general}}{\memglodesc{(\ref {futures.task.general})}} {\memgloref{}}|memjustarg}{1628} -\glossaryentry{futures.task.members@ {\memgloterm{futures.task.members}}{\memglodesc{(\ref {futures.task.members})}} {\memgloref{}}|memjustarg}{1629} -\glossaryentry{futures.task.nonmembers@ {\memgloterm{futures.task.nonmembers}}{\memglodesc{(\ref {futures.task.nonmembers})}} {\memgloref{}}|memjustarg}{1630} -\glossaryentry{gram@ {\memgloterm{gram}}{\memglodesc{(\ref {gram})}} {\memgloref{}}|memjustarg}{1631} -\glossaryentry{gram.general@ {\memgloterm{gram.general}}{\memglodesc{(\ref {gram.general})}} {\memgloref{}}|memjustarg}{1631} -\glossaryentry{gram.key@ {\memgloterm{gram.key}}{\memglodesc{(\ref {gram.key})}} {\memgloref{}}|memjustarg}{1631} -\glossaryentry{gram.lex@ {\memgloterm{gram.lex}}{\memglodesc{(\ref {gram.lex})}} {\memgloref{}}|memjustarg}{1631} -\glossaryentry{gram.basic@ {\memgloterm{gram.basic}}{\memglodesc{(\ref {gram.basic})}} {\memgloref{}}|memjustarg}{1635} -\glossaryentry{gram.expr@ {\memgloterm{gram.expr}}{\memglodesc{(\ref {gram.expr})}} {\memgloref{}}|memjustarg}{1635} -\glossaryentry{gram.stmt@ {\memgloterm{gram.stmt}}{\memglodesc{(\ref {gram.stmt})}} {\memgloref{}}|memjustarg}{1639} -\glossaryentry{gram.dcl@ {\memgloterm{gram.dcl}}{\memglodesc{(\ref {gram.dcl})}} {\memgloref{}}|memjustarg}{1640} -\glossaryentry{gram.module@ {\memgloterm{gram.module}}{\memglodesc{(\ref {gram.module})}} {\memgloref{}}|memjustarg}{1646} -\glossaryentry{gram.class@ {\memgloterm{gram.class}}{\memglodesc{(\ref {gram.class})}} {\memgloref{}}|memjustarg}{1647} -\glossaryentry{gram.over@ {\memgloterm{gram.over}}{\memglodesc{(\ref {gram.over})}} {\memgloref{}}|memjustarg}{1648} -\glossaryentry{gram.temp@ {\memgloterm{gram.temp}}{\memglodesc{(\ref {gram.temp})}} {\memgloref{}}|memjustarg}{1648} -\glossaryentry{gram.except@ {\memgloterm{gram.except}}{\memglodesc{(\ref {gram.except})}} {\memgloref{}}|memjustarg}{1650} -\glossaryentry{gram.cpp@ {\memgloterm{gram.cpp}}{\memglodesc{(\ref {gram.cpp})}} {\memgloref{}}|memjustarg}{1650} -\glossaryentry{implimits@ {\memgloterm{implimits}}{\memglodesc{(\ref {implimits})}} {\memgloref{}}|memjustarg}{1652} -\glossaryentry{diff@ {\memgloterm{diff}}{\memglodesc{(\ref {diff})}} {\memgloref{}}|memjustarg}{1654} -\glossaryentry{diff.cpp17@ {\memgloterm{diff.cpp17}}{\memglodesc{(\ref {diff.cpp17})}} {\memgloref{}}|memjustarg}{1654} -\glossaryentry{diff.cpp17.general@ {\memgloterm{diff.cpp17.general}}{\memglodesc{(\ref {diff.cpp17.general})}} {\memgloref{}}|memjustarg}{1654} -\glossaryentry{diff.cpp17.lex@ {\memgloterm{diff.cpp17.lex}}{\memglodesc{(\ref {diff.cpp17.lex})}} {\memgloref{}}|memjustarg}{1654} -\glossaryentry{diff.cpp17.basic@ {\memgloterm{diff.cpp17.basic}}{\memglodesc{(\ref {diff.cpp17.basic})}} {\memgloref{}}|memjustarg}{1655} -\glossaryentry{diff.cpp17.expr@ {\memgloterm{diff.cpp17.expr}}{\memglodesc{(\ref {diff.cpp17.expr})}} {\memgloref{}}|memjustarg}{1655} -\glossaryentry{diff.cpp17.dcl.dcl@ {\memgloterm{diff.cpp17.dcl.dcl}}{\memglodesc{(\ref {diff.cpp17.dcl.dcl})}} {\memgloref{}}|memjustarg}{1656} -\glossaryentry{diff.cpp17.class@ {\memgloterm{diff.cpp17.class}}{\memglodesc{(\ref {diff.cpp17.class})}} {\memgloref{}}|memjustarg}{1657} -\glossaryentry{diff.cpp17.over@ {\memgloterm{diff.cpp17.over}}{\memglodesc{(\ref {diff.cpp17.over})}} {\memgloref{}}|memjustarg}{1658} -\glossaryentry{diff.cpp17.temp@ {\memgloterm{diff.cpp17.temp}}{\memglodesc{(\ref {diff.cpp17.temp})}} {\memgloref{}}|memjustarg}{1658} -\glossaryentry{diff.cpp17.except@ {\memgloterm{diff.cpp17.except}}{\memglodesc{(\ref {diff.cpp17.except})}} {\memgloref{}}|memjustarg}{1658} -\glossaryentry{diff.cpp17.library@ {\memgloterm{diff.cpp17.library}}{\memglodesc{(\ref {diff.cpp17.library})}} {\memgloref{}}|memjustarg}{1659} -\glossaryentry{diff.cpp17.containers@ {\memgloterm{diff.cpp17.containers}}{\memglodesc{(\ref {diff.cpp17.containers})}} {\memgloref{}}|memjustarg}{1659} -\glossaryentry{diff.cpp17.iterators@ {\memgloterm{diff.cpp17.iterators}}{\memglodesc{(\ref {diff.cpp17.iterators})}} {\memgloref{}}|memjustarg}{1659} -\glossaryentry{diff.cpp17.alg.reqs@ {\memgloterm{diff.cpp17.alg.reqs}}{\memglodesc{(\ref {diff.cpp17.alg.reqs})}} {\memgloref{}}|memjustarg}{1659} -\glossaryentry{diff.cpp17.input.output@ {\memgloterm{diff.cpp17.input.output}}{\memglodesc{(\ref {diff.cpp17.input.output})}} {\memgloref{}}|memjustarg}{1659} -\glossaryentry{diff.cpp17.depr@ {\memgloterm{diff.cpp17.depr}}{\memglodesc{(\ref {diff.cpp17.depr})}} {\memgloref{}}|memjustarg}{1660} -\glossaryentry{diff.cpp14@ {\memgloterm{diff.cpp14}}{\memglodesc{(\ref {diff.cpp14})}} {\memgloref{}}|memjustarg}{1661} -\glossaryentry{diff.cpp14.general@ {\memgloterm{diff.cpp14.general}}{\memglodesc{(\ref {diff.cpp14.general})}} {\memgloref{}}|memjustarg}{1661} -\glossaryentry{diff.cpp14.lex@ {\memgloterm{diff.cpp14.lex}}{\memglodesc{(\ref {diff.cpp14.lex})}} {\memgloref{}}|memjustarg}{1661} -\glossaryentry{diff.cpp14.expr@ {\memgloterm{diff.cpp14.expr}}{\memglodesc{(\ref {diff.cpp14.expr})}} {\memgloref{}}|memjustarg}{1661} -\glossaryentry{diff.cpp14.dcl.dcl@ {\memgloterm{diff.cpp14.dcl.dcl}}{\memglodesc{(\ref {diff.cpp14.dcl.dcl})}} {\memgloref{}}|memjustarg}{1662} -\glossaryentry{diff.cpp14.class@ {\memgloterm{diff.cpp14.class}}{\memglodesc{(\ref {diff.cpp14.class})}} {\memgloref{}}|memjustarg}{1662} -\glossaryentry{diff.cpp14.temp@ {\memgloterm{diff.cpp14.temp}}{\memglodesc{(\ref {diff.cpp14.temp})}} {\memgloref{}}|memjustarg}{1663} -\glossaryentry{diff.cpp14.except@ {\memgloterm{diff.cpp14.except}}{\memglodesc{(\ref {diff.cpp14.except})}} {\memgloref{}}|memjustarg}{1663} -\glossaryentry{diff.cpp14.library@ {\memgloterm{diff.cpp14.library}}{\memglodesc{(\ref {diff.cpp14.library})}} {\memgloref{}}|memjustarg}{1663} -\glossaryentry{diff.cpp14.utilities@ {\memgloterm{diff.cpp14.utilities}}{\memglodesc{(\ref {diff.cpp14.utilities})}} {\memgloref{}}|memjustarg}{1663} -\glossaryentry{diff.cpp14.string@ {\memgloterm{diff.cpp14.string}}{\memglodesc{(\ref {diff.cpp14.string})}} {\memgloref{}}|memjustarg}{1664} -\glossaryentry{diff.cpp14.containers@ {\memgloterm{diff.cpp14.containers}}{\memglodesc{(\ref {diff.cpp14.containers})}} {\memgloref{}}|memjustarg}{1664} -\glossaryentry{diff.cpp14.depr@ {\memgloterm{diff.cpp14.depr}}{\memglodesc{(\ref {diff.cpp14.depr})}} {\memgloref{}}|memjustarg}{1664} -\glossaryentry{diff.cpp11@ {\memgloterm{diff.cpp11}}{\memglodesc{(\ref {diff.cpp11})}} {\memgloref{}}|memjustarg}{1664} -\glossaryentry{diff.cpp11.general@ {\memgloterm{diff.cpp11.general}}{\memglodesc{(\ref {diff.cpp11.general})}} {\memgloref{}}|memjustarg}{1664} -\glossaryentry{diff.cpp11.lex@ {\memgloterm{diff.cpp11.lex}}{\memglodesc{(\ref {diff.cpp11.lex})}} {\memgloref{}}|memjustarg}{1664} -\glossaryentry{diff.cpp11.basic@ {\memgloterm{diff.cpp11.basic}}{\memglodesc{(\ref {diff.cpp11.basic})}} {\memgloref{}}|memjustarg}{1665} -\glossaryentry{diff.cpp11.expr@ {\memgloterm{diff.cpp11.expr}}{\memglodesc{(\ref {diff.cpp11.expr})}} {\memgloref{}}|memjustarg}{1665} -\glossaryentry{diff.cpp11.dcl.dcl@ {\memgloterm{diff.cpp11.dcl.dcl}}{\memglodesc{(\ref {diff.cpp11.dcl.dcl})}} {\memgloref{}}|memjustarg}{1665} -\glossaryentry{diff.cpp11.library@ {\memgloterm{diff.cpp11.library}}{\memglodesc{(\ref {diff.cpp11.library})}} {\memgloref{}}|memjustarg}{1666} -\glossaryentry{diff.cpp11.input.output@ {\memgloterm{diff.cpp11.input.output}}{\memglodesc{(\ref {diff.cpp11.input.output})}} {\memgloref{}}|memjustarg}{1666} -\glossaryentry{diff.cpp03@ {\memgloterm{diff.cpp03}}{\memglodesc{(\ref {diff.cpp03})}} {\memgloref{}}|memjustarg}{1666} -\glossaryentry{diff.cpp03.general@ {\memgloterm{diff.cpp03.general}}{\memglodesc{(\ref {diff.cpp03.general})}} {\memgloref{}}|memjustarg}{1666} -\glossaryentry{diff.cpp03.lex@ {\memgloterm{diff.cpp03.lex}}{\memglodesc{(\ref {diff.cpp03.lex})}} {\memgloref{}}|memjustarg}{1666} -\glossaryentry{diff.cpp03.expr@ {\memgloterm{diff.cpp03.expr}}{\memglodesc{(\ref {diff.cpp03.expr})}} {\memgloref{}}|memjustarg}{1667} -\glossaryentry{diff.cpp03.dcl.dcl@ {\memgloterm{diff.cpp03.dcl.dcl}}{\memglodesc{(\ref {diff.cpp03.dcl.dcl})}} {\memgloref{}}|memjustarg}{1667} -\glossaryentry{diff.cpp03.class@ {\memgloterm{diff.cpp03.class}}{\memglodesc{(\ref {diff.cpp03.class})}} {\memgloref{}}|memjustarg}{1667} -\glossaryentry{diff.cpp03.temp@ {\memgloterm{diff.cpp03.temp}}{\memglodesc{(\ref {diff.cpp03.temp})}} {\memgloref{}}|memjustarg}{1668} -\glossaryentry{diff.cpp03.library@ {\memgloterm{diff.cpp03.library}}{\memglodesc{(\ref {diff.cpp03.library})}} {\memgloref{}}|memjustarg}{1668} -\glossaryentry{diff.cpp03.language.support@ {\memgloterm{diff.cpp03.language.support}}{\memglodesc{(\ref {diff.cpp03.language.support})}} {\memgloref{}}|memjustarg}{1669} -\glossaryentry{diff.cpp03.diagnostics@ {\memgloterm{diff.cpp03.diagnostics}}{\memglodesc{(\ref {diff.cpp03.diagnostics})}} {\memgloref{}}|memjustarg}{1669} -\glossaryentry{diff.cpp03.utilities@ {\memgloterm{diff.cpp03.utilities}}{\memglodesc{(\ref {diff.cpp03.utilities})}} {\memgloref{}}|memjustarg}{1669} -\glossaryentry{diff.cpp03.strings@ {\memgloterm{diff.cpp03.strings}}{\memglodesc{(\ref {diff.cpp03.strings})}} {\memgloref{}}|memjustarg}{1669} -\glossaryentry{diff.cpp03.containers@ {\memgloterm{diff.cpp03.containers}}{\memglodesc{(\ref {diff.cpp03.containers})}} {\memgloref{}}|memjustarg}{1669} -\glossaryentry{diff.cpp03.algorithms@ {\memgloterm{diff.cpp03.algorithms}}{\memglodesc{(\ref {diff.cpp03.algorithms})}} {\memgloref{}}|memjustarg}{1670} -\glossaryentry{diff.cpp03.numerics@ {\memgloterm{diff.cpp03.numerics}}{\memglodesc{(\ref {diff.cpp03.numerics})}} {\memgloref{}}|memjustarg}{1671} -\glossaryentry{diff.cpp03.input.output@ {\memgloterm{diff.cpp03.input.output}}{\memglodesc{(\ref {diff.cpp03.input.output})}} {\memgloref{}}|memjustarg}{1671} -\glossaryentry{diff.iso@ {\memgloterm{diff.iso}}{\memglodesc{(\ref {diff.iso})}} {\memgloref{}}|memjustarg}{1671} -\glossaryentry{diff.iso.general@ {\memgloterm{diff.iso.general}}{\memglodesc{(\ref {diff.iso.general})}} {\memgloref{}}|memjustarg}{1671} -\glossaryentry{diff.lex@ {\memgloterm{diff.lex}}{\memglodesc{(\ref {diff.lex})}} {\memgloref{}}|memjustarg}{1671} -\glossaryentry{diff.basic@ {\memgloterm{diff.basic}}{\memglodesc{(\ref {diff.basic})}} {\memgloref{}}|memjustarg}{1672} -\glossaryentry{diff.expr@ {\memgloterm{diff.expr}}{\memglodesc{(\ref {diff.expr})}} {\memgloref{}}|memjustarg}{1673} -\glossaryentry{diff.stat@ {\memgloterm{diff.stat}}{\memglodesc{(\ref {diff.stat})}} {\memgloref{}}|memjustarg}{1674} -\glossaryentry{diff.dcl@ {\memgloterm{diff.dcl}}{\memglodesc{(\ref {diff.dcl})}} {\memgloref{}}|memjustarg}{1674} -\glossaryentry{diff.class@ {\memgloterm{diff.class}}{\memglodesc{(\ref {diff.class})}} {\memgloref{}}|memjustarg}{1678} -\glossaryentry{diff.cpp@ {\memgloterm{diff.cpp}}{\memglodesc{(\ref {diff.cpp})}} {\memgloref{}}|memjustarg}{1679} -\glossaryentry{diff.library@ {\memgloterm{diff.library}}{\memglodesc{(\ref {diff.library})}} {\memgloref{}}|memjustarg}{1680} -\glossaryentry{diff.library.general@ {\memgloterm{diff.library.general}}{\memglodesc{(\ref {diff.library.general})}} {\memgloref{}}|memjustarg}{1680} -\glossaryentry{diff.mods.to.headers@ {\memgloterm{diff.mods.to.headers}}{\memglodesc{(\ref {diff.mods.to.headers})}} {\memgloref{}}|memjustarg}{1680} -\glossaryentry{diff.mods.to.definitions@ {\memgloterm{diff.mods.to.definitions}}{\memglodesc{(\ref {diff.mods.to.definitions})}} {\memgloref{}}|memjustarg}{1680} -\glossaryentry{diff.char16@ {\memgloterm{diff.char16}}{\memglodesc{(\ref {diff.char16})}} {\memgloref{}}|memjustarg}{1680} -\glossaryentry{diff.wchar.t@ {\memgloterm{diff.wchar.t}}{\memglodesc{(\ref {diff.wchar.t})}} {\memgloref{}}|memjustarg}{1680} -\glossaryentry{diff.header.assert.h@ {\memgloterm{diff.header.assert.h}}{\memglodesc{(\ref {diff.header.assert.h})}} {\memgloref{}}|memjustarg}{1680} -\glossaryentry{diff.header.iso646.h@ {\memgloterm{diff.header.iso646.h}}{\memglodesc{(\ref {diff.header.iso646.h})}} {\memgloref{}}|memjustarg}{1680} -\glossaryentry{diff.header.stdalign.h@ {\memgloterm{diff.header.stdalign.h}}{\memglodesc{(\ref {diff.header.stdalign.h})}} {\memgloref{}}|memjustarg}{1680} -\glossaryentry{diff.header.stdbool.h@ {\memgloterm{diff.header.stdbool.h}}{\memglodesc{(\ref {diff.header.stdbool.h})}} {\memgloref{}}|memjustarg}{1680} -\glossaryentry{diff.null@ {\memgloterm{diff.null}}{\memglodesc{(\ref {diff.null})}} {\memgloref{}}|memjustarg}{1680} -\glossaryentry{diff.mods.to.declarations@ {\memgloterm{diff.mods.to.declarations}}{\memglodesc{(\ref {diff.mods.to.declarations})}} {\memgloref{}}|memjustarg}{1680} -\glossaryentry{diff.mods.to.behavior@ {\memgloterm{diff.mods.to.behavior}}{\memglodesc{(\ref {diff.mods.to.behavior})}} {\memgloref{}}|memjustarg}{1681} -\glossaryentry{diff.mods.to.behavior.general@ {\memgloterm{diff.mods.to.behavior.general}}{\memglodesc{(\ref {diff.mods.to.behavior.general})}} {\memgloref{}}|memjustarg}{1681} -\glossaryentry{diff.offsetof@ {\memgloterm{diff.offsetof}}{\memglodesc{(\ref {diff.offsetof})}} {\memgloref{}}|memjustarg}{1681} -\glossaryentry{diff.malloc@ {\memgloterm{diff.malloc}}{\memglodesc{(\ref {diff.malloc})}} {\memgloref{}}|memjustarg}{1681} -\glossaryentry{depr@ {\memgloterm{depr}}{\memglodesc{(\ref {depr})}} {\memgloref{}}|memjustarg}{1682} -\glossaryentry{depr.general@ {\memgloterm{depr.general}}{\memglodesc{(\ref {depr.general})}} {\memgloref{}}|memjustarg}{1682} -\glossaryentry{depr.arith.conv.enum@ {\memgloterm{depr.arith.conv.enum}}{\memglodesc{(\ref {depr.arith.conv.enum})}} {\memgloref{}}|memjustarg}{1682} -\glossaryentry{depr.capture.this@ {\memgloterm{depr.capture.this}}{\memglodesc{(\ref {depr.capture.this})}} {\memgloref{}}|memjustarg}{1682} -\glossaryentry{depr.comma.subscript@ {\memgloterm{depr.comma.subscript}}{\memglodesc{(\ref {depr.comma.subscript})}} {\memgloref{}}|memjustarg}{1682} -\glossaryentry{depr.array.comp@ {\memgloterm{depr.array.comp}}{\memglodesc{(\ref {depr.array.comp})}} {\memgloref{}}|memjustarg}{1682} -\glossaryentry{depr.volatile.type@ {\memgloterm{depr.volatile.type}}{\memglodesc{(\ref {depr.volatile.type})}} {\memgloref{}}|memjustarg}{1683} -\glossaryentry{depr.static.constexpr@ {\memgloterm{depr.static.constexpr}}{\memglodesc{(\ref {depr.static.constexpr})}} {\memgloref{}}|memjustarg}{1683} -\glossaryentry{depr.local@ {\memgloterm{depr.local}}{\memglodesc{(\ref {depr.local})}} {\memgloref{}}|memjustarg}{1683} -\glossaryentry{depr.impldec@ {\memgloterm{depr.impldec}}{\memglodesc{(\ref {depr.impldec})}} {\memgloref{}}|memjustarg}{1684} -\glossaryentry{depr.c.headers@ {\memgloterm{depr.c.headers}}{\memglodesc{(\ref {depr.c.headers})}} {\memgloref{}}|memjustarg}{1684} -\glossaryentry{depr.c.headers.general@ {\memgloterm{depr.c.headers.general}}{\memglodesc{(\ref {depr.c.headers.general})}} {\memgloref{}}|memjustarg}{1684} -\glossaryentry{depr.complex.h.syn@ {\memgloterm{depr.complex.h.syn}}{\memglodesc{(\ref {depr.complex.h.syn})}} {\memgloref{}}|memjustarg}{1684} -\glossaryentry{depr.iso646.h.syn@ {\memgloterm{depr.iso646.h.syn}}{\memglodesc{(\ref {depr.iso646.h.syn})}} {\memgloref{}}|memjustarg}{1684} -\glossaryentry{depr.stdalign.h.syn@ {\memgloterm{depr.stdalign.h.syn}}{\memglodesc{(\ref {depr.stdalign.h.syn})}} {\memgloref{}}|memjustarg}{1684} -\glossaryentry{depr.stdbool.h.syn@ {\memgloterm{depr.stdbool.h.syn}}{\memglodesc{(\ref {depr.stdbool.h.syn})}} {\memgloref{}}|memjustarg}{1684} -\glossaryentry{depr.tgmath.h.syn@ {\memgloterm{depr.tgmath.h.syn}}{\memglodesc{(\ref {depr.tgmath.h.syn})}} {\memgloref{}}|memjustarg}{1685} -\glossaryentry{depr.c.headers.other@ {\memgloterm{depr.c.headers.other}}{\memglodesc{(\ref {depr.c.headers.other})}} {\memgloref{}}|memjustarg}{1685} -\glossaryentry{depr.res.on.required@ {\memgloterm{depr.res.on.required}}{\memglodesc{(\ref {depr.res.on.required})}} {\memgloref{}}|memjustarg}{1685} -\glossaryentry{depr.relops@ {\memgloterm{depr.relops}}{\memglodesc{(\ref {depr.relops})}} {\memgloref{}}|memjustarg}{1685} -\glossaryentry{depr.str.strstreams@ {\memgloterm{depr.str.strstreams}}{\memglodesc{(\ref {depr.str.strstreams})}} {\memgloref{}}|memjustarg}{1686} -\glossaryentry{depr.strstream.syn@ {\memgloterm{depr.strstream.syn}}{\memglodesc{(\ref {depr.strstream.syn})}} {\memgloref{}}|memjustarg}{1686} -\glossaryentry{depr.strstreambuf@ {\memgloterm{depr.strstreambuf}}{\memglodesc{(\ref {depr.strstreambuf})}} {\memgloref{}}|memjustarg}{1686} -\glossaryentry{depr.strstreambuf.general@ {\memgloterm{depr.strstreambuf.general}}{\memglodesc{(\ref {depr.strstreambuf.general})}} {\memgloref{}}|memjustarg}{1686} -\glossaryentry{depr.strstreambuf.cons@ {\memgloterm{depr.strstreambuf.cons}}{\memglodesc{(\ref {depr.strstreambuf.cons})}} {\memgloref{}}|memjustarg}{1687} -\glossaryentry{depr.strstreambuf.members@ {\memgloterm{depr.strstreambuf.members}}{\memglodesc{(\ref {depr.strstreambuf.members})}} {\memgloref{}}|memjustarg}{1688} -\glossaryentry{depr.strstreambuf.virtuals@ {\memgloterm{depr.strstreambuf.virtuals}}{\memglodesc{(\ref {depr.strstreambuf.virtuals})}} {\memgloref{}}|memjustarg}{1688} -\glossaryentry{depr.istrstream@ {\memgloterm{depr.istrstream}}{\memglodesc{(\ref {depr.istrstream})}} {\memgloref{}}|memjustarg}{1690} -\glossaryentry{depr.istrstream.general@ {\memgloterm{depr.istrstream.general}}{\memglodesc{(\ref {depr.istrstream.general})}} {\memgloref{}}|memjustarg}{1690} -\glossaryentry{depr.istrstream.cons@ {\memgloterm{depr.istrstream.cons}}{\memglodesc{(\ref {depr.istrstream.cons})}} {\memgloref{}}|memjustarg}{1691} -\glossaryentry{depr.istrstream.members@ {\memgloterm{depr.istrstream.members}}{\memglodesc{(\ref {depr.istrstream.members})}} {\memgloref{}}|memjustarg}{1691} -\glossaryentry{depr.ostrstream@ {\memgloterm{depr.ostrstream}}{\memglodesc{(\ref {depr.ostrstream})}} {\memgloref{}}|memjustarg}{1691} -\glossaryentry{depr.ostrstream.general@ {\memgloterm{depr.ostrstream.general}}{\memglodesc{(\ref {depr.ostrstream.general})}} {\memgloref{}}|memjustarg}{1691} -\glossaryentry{depr.ostrstream.cons@ {\memgloterm{depr.ostrstream.cons}}{\memglodesc{(\ref {depr.ostrstream.cons})}} {\memgloref{}}|memjustarg}{1691} -\glossaryentry{depr.ostrstream.members@ {\memgloterm{depr.ostrstream.members}}{\memglodesc{(\ref {depr.ostrstream.members})}} {\memgloref{}}|memjustarg}{1692} -\glossaryentry{depr.strstream@ {\memgloterm{depr.strstream}}{\memglodesc{(\ref {depr.strstream})}} {\memgloref{}}|memjustarg}{1692} -\glossaryentry{depr.strstream.general@ {\memgloterm{depr.strstream.general}}{\memglodesc{(\ref {depr.strstream.general})}} {\memgloref{}}|memjustarg}{1692} -\glossaryentry{depr.strstream.cons@ {\memgloterm{depr.strstream.cons}}{\memglodesc{(\ref {depr.strstream.cons})}} {\memgloref{}}|memjustarg}{1693} -\glossaryentry{depr.strstream.dest@ {\memgloterm{depr.strstream.dest}}{\memglodesc{(\ref {depr.strstream.dest})}} {\memgloref{}}|memjustarg}{1693} -\glossaryentry{depr.strstream.oper@ {\memgloterm{depr.strstream.oper}}{\memglodesc{(\ref {depr.strstream.oper})}} {\memgloref{}}|memjustarg}{1693} -\glossaryentry{depr.meta.types@ {\memgloterm{depr.meta.types}}{\memglodesc{(\ref {depr.meta.types})}} {\memgloref{}}|memjustarg}{1693} -\glossaryentry{depr.tuple@ {\memgloterm{depr.tuple}}{\memglodesc{(\ref {depr.tuple})}} {\memgloref{}}|memjustarg}{1693} -\glossaryentry{depr.variant@ {\memgloterm{depr.variant}}{\memglodesc{(\ref {depr.variant})}} {\memgloref{}}|memjustarg}{1694} -\glossaryentry{depr.iterator@ {\memgloterm{depr.iterator}}{\memglodesc{(\ref {depr.iterator})}} {\memgloref{}}|memjustarg}{1694} -\glossaryentry{depr.move.iter.elem@ {\memgloterm{depr.move.iter.elem}}{\memglodesc{(\ref {depr.move.iter.elem})}} {\memgloref{}}|memjustarg}{1695} -\glossaryentry{depr.util.smartptr.shared.atomic@ {\memgloterm{depr.util.smartptr.shared.atomic}}{\memglodesc{(\ref {depr.util.smartptr.shared.atomic})}} {\memgloref{}}|memjustarg}{1695} -\glossaryentry{depr.string.capacity@ {\memgloterm{depr.string.capacity}}{\memglodesc{(\ref {depr.string.capacity})}} {\memgloref{}}|memjustarg}{1697} -\glossaryentry{depr.locale.stdcvt@ {\memgloterm{depr.locale.stdcvt}}{\memglodesc{(\ref {depr.locale.stdcvt})}} {\memgloref{}}|memjustarg}{1697} -\glossaryentry{depr.locale.stdcvt.general@ {\memgloterm{depr.locale.stdcvt.general}}{\memglodesc{(\ref {depr.locale.stdcvt.general})}} {\memgloref{}}|memjustarg}{1697} -\glossaryentry{depr.codecvt.syn@ {\memgloterm{depr.codecvt.syn}}{\memglodesc{(\ref {depr.codecvt.syn})}} {\memgloref{}}|memjustarg}{1697} -\glossaryentry{depr.locale.stdcvt.req@ {\memgloterm{depr.locale.stdcvt.req}}{\memglodesc{(\ref {depr.locale.stdcvt.req})}} {\memgloref{}}|memjustarg}{1698} -\glossaryentry{depr.conversions@ {\memgloterm{depr.conversions}}{\memglodesc{(\ref {depr.conversions})}} {\memgloref{}}|memjustarg}{1699} -\glossaryentry{depr.conversions.general@ {\memgloterm{depr.conversions.general}}{\memglodesc{(\ref {depr.conversions.general})}} {\memgloref{}}|memjustarg}{1699} -\glossaryentry{depr.conversions.string@ {\memgloterm{depr.conversions.string}}{\memglodesc{(\ref {depr.conversions.string})}} {\memgloref{}}|memjustarg}{1699} -\glossaryentry{depr.conversions.buffer@ {\memgloterm{depr.conversions.buffer}}{\memglodesc{(\ref {depr.conversions.buffer})}} {\memgloref{}}|memjustarg}{1701} -\glossaryentry{depr.locale.category@ {\memgloterm{depr.locale.category}}{\memglodesc{(\ref {depr.locale.category})}} {\memgloref{}}|memjustarg}{1702} -\glossaryentry{depr.fs.path.factory@ {\memgloterm{depr.fs.path.factory}}{\memglodesc{(\ref {depr.fs.path.factory})}} {\memgloref{}}|memjustarg}{1702} -\glossaryentry{depr.atomics@ {\memgloterm{depr.atomics}}{\memglodesc{(\ref {depr.atomics})}} {\memgloref{}}|memjustarg}{1703} -\glossaryentry{depr.atomics.general@ {\memgloterm{depr.atomics.general}}{\memglodesc{(\ref {depr.atomics.general})}} {\memgloref{}}|memjustarg}{1703} -\glossaryentry{depr.atomics.volatile@ {\memgloterm{depr.atomics.volatile}}{\memglodesc{(\ref {depr.atomics.volatile})}} {\memgloref{}}|memjustarg}{1703} -\glossaryentry{depr.atomics.nonmembers@ {\memgloterm{depr.atomics.nonmembers}}{\memglodesc{(\ref {depr.atomics.nonmembers})}} {\memgloref{}}|memjustarg}{1704} -\glossaryentry{depr.atomics.types.operations@ {\memgloterm{depr.atomics.types.operations}}{\memglodesc{(\ref {depr.atomics.types.operations})}} {\memgloref{}}|memjustarg}{1704} -\glossaryentry{depr.atomics.flag@ {\memgloterm{depr.atomics.flag}}{\memglodesc{(\ref {depr.atomics.flag})}} {\memgloref{}}|memjustarg}{1704} +\glossaryentry{intro.scope@ {\memgloterm{intro.scope}}{\memglodesc{(\ref {intro.scope})}} {\memgloref{}}|memjustarg}{1} +\glossaryentry{intro.refs@ {\memgloterm{intro.refs}}{\memglodesc{(\ref {intro.refs})}} {\memgloref{}}|memjustarg}{2} +\glossaryentry{intro.defs@ {\memgloterm{intro.defs}}{\memglodesc{(\ref {intro.defs})}} {\memgloref{}}|memjustarg}{3} +\glossaryentry{defns.access@ {\memgloterm{defns.access}}{\memglodesc{(\ref {defns.access})}} {\memgloref{}}|memjustarg}{3} +\glossaryentry{defns.arbitrary.stream@ {\memgloterm{defns.arbitrary.stream}}{\memglodesc{(\ref {defns.arbitrary.stream})}} {\memgloref{}}|memjustarg}{3} +\glossaryentry{defns.argument@ {\memgloterm{defns.argument}}{\memglodesc{(\ref {defns.argument})}} {\memgloref{}}|memjustarg}{3} +\glossaryentry{defns.argument.macro@ {\memgloterm{defns.argument.macro}}{\memglodesc{(\ref {defns.argument.macro})}} {\memgloref{}}|memjustarg}{3} +\glossaryentry{defns.argument.throw@ {\memgloterm{defns.argument.throw}}{\memglodesc{(\ref {defns.argument.throw})}} {\memgloref{}}|memjustarg}{3} +\glossaryentry{defns.argument.templ@ {\memgloterm{defns.argument.templ}}{\memglodesc{(\ref {defns.argument.templ})}} {\memgloref{}}|memjustarg}{3} +\glossaryentry{defns.block@ {\memgloterm{defns.block}}{\memglodesc{(\ref {defns.block})}} {\memgloref{}}|memjustarg}{3} +\glossaryentry{defns.block.stmt@ {\memgloterm{defns.block.stmt}}{\memglodesc{(\ref {defns.block.stmt})}} {\memgloref{}}|memjustarg}{3} +\glossaryentry{defns.character@ {\memgloterm{defns.character}}{\memglodesc{(\ref {defns.character})}} {\memgloref{}}|memjustarg}{3} +\glossaryentry{defns.character.container@ {\memgloterm{defns.character.container}}{\memglodesc{(\ref {defns.character.container})}} {\memgloref{}}|memjustarg}{3} +\glossaryentry{defns.regex.collating.element@ {\memgloterm{defns.regex.collating.element}}{\memglodesc{(\ref {defns.regex.collating.element})}} {\memgloref{}}|memjustarg}{4} +\glossaryentry{defns.component@ {\memgloterm{defns.component}}{\memglodesc{(\ref {defns.component})}} {\memgloref{}}|memjustarg}{4} +\glossaryentry{defns.cond.supp@ {\memgloterm{defns.cond.supp}}{\memglodesc{(\ref {defns.cond.supp})}} {\memgloref{}}|memjustarg}{4} +\glossaryentry{defns.const.subexpr@ {\memgloterm{defns.const.subexpr}}{\memglodesc{(\ref {defns.const.subexpr})}} {\memgloref{}}|memjustarg}{4} +\glossaryentry{defns.deadlock@ {\memgloterm{defns.deadlock}}{\memglodesc{(\ref {defns.deadlock})}} {\memgloref{}}|memjustarg}{4} +\glossaryentry{defns.default.behavior.impl@ {\memgloterm{defns.default.behavior.impl}}{\memglodesc{(\ref {defns.default.behavior.impl})}} {\memgloref{}}|memjustarg}{4} +\glossaryentry{defns.diagnostic@ {\memgloterm{defns.diagnostic}}{\memglodesc{(\ref {defns.diagnostic})}} {\memgloref{}}|memjustarg}{4} +\glossaryentry{defns.direct.non.list.init@ {\memgloterm{defns.direct.non.list.init}}{\memglodesc{(\ref {defns.direct.non.list.init})}} {\memgloref{}}|memjustarg}{4} +\glossaryentry{defns.dynamic.type@ {\memgloterm{defns.dynamic.type}}{\memglodesc{(\ref {defns.dynamic.type})}} {\memgloref{}}|memjustarg}{4} +\glossaryentry{defns.dynamic.type.prvalue@ {\memgloterm{defns.dynamic.type.prvalue}}{\memglodesc{(\ref {defns.dynamic.type.prvalue})}} {\memgloref{}}|memjustarg}{4} +\glossaryentry{defns.expression.equivalent@ {\memgloterm{defns.expression.equivalent}}{\memglodesc{(\ref {defns.expression.equivalent})}} {\memgloref{}}|memjustarg}{4} +\glossaryentry{defns.regex.finite.state.machine@ {\memgloterm{defns.regex.finite.state.machine}}{\memglodesc{(\ref {defns.regex.finite.state.machine})}} {\memgloref{}}|memjustarg}{5} +\glossaryentry{defns.regex.format.specifier@ {\memgloterm{defns.regex.format.specifier}}{\memglodesc{(\ref {defns.regex.format.specifier})}} {\memgloref{}}|memjustarg}{5} +\glossaryentry{defns.handler@ {\memgloterm{defns.handler}}{\memglodesc{(\ref {defns.handler})}} {\memgloref{}}|memjustarg}{5} +\glossaryentry{defns.ill.formed@ {\memgloterm{defns.ill.formed}}{\memglodesc{(\ref {defns.ill.formed})}} {\memgloref{}}|memjustarg}{5} +\glossaryentry{defns.impl.defined@ {\memgloterm{defns.impl.defined}}{\memglodesc{(\ref {defns.impl.defined})}} {\memgloref{}}|memjustarg}{5} +\glossaryentry{defns.order.ptr@ {\memgloterm{defns.order.ptr}}{\memglodesc{(\ref {defns.order.ptr})}} {\memgloref{}}|memjustarg}{5} +\glossaryentry{defns.impl.limits@ {\memgloterm{defns.impl.limits}}{\memglodesc{(\ref {defns.impl.limits})}} {\memgloref{}}|memjustarg}{5} +\glossaryentry{defns.iostream.templates@ {\memgloterm{defns.iostream.templates}}{\memglodesc{(\ref {defns.iostream.templates})}} {\memgloref{}}|memjustarg}{5} +\glossaryentry{defns.locale.specific@ {\memgloterm{defns.locale.specific}}{\memglodesc{(\ref {defns.locale.specific})}} {\memgloref{}}|memjustarg}{5} +\glossaryentry{defns.regex.matched@ {\memgloterm{defns.regex.matched}}{\memglodesc{(\ref {defns.regex.matched})}} {\memgloref{}}|memjustarg}{5} +\glossaryentry{defns.modifier@ {\memgloterm{defns.modifier}}{\memglodesc{(\ref {defns.modifier})}} {\memgloref{}}|memjustarg}{5} +\glossaryentry{defns.move.assign@ {\memgloterm{defns.move.assign}}{\memglodesc{(\ref {defns.move.assign})}} {\memgloref{}}|memjustarg}{6} +\glossaryentry{defns.move.constr@ {\memgloterm{defns.move.constr}}{\memglodesc{(\ref {defns.move.constr})}} {\memgloref{}}|memjustarg}{6} +\glossaryentry{defns.nonconst.libcall@ {\memgloterm{defns.nonconst.libcall}}{\memglodesc{(\ref {defns.nonconst.libcall})}} {\memgloref{}}|memjustarg}{6} +\glossaryentry{defns.ntcts@ {\memgloterm{defns.ntcts}}{\memglodesc{(\ref {defns.ntcts})}} {\memgloref{}}|memjustarg}{6} +\glossaryentry{defns.observer@ {\memgloterm{defns.observer}}{\memglodesc{(\ref {defns.observer})}} {\memgloref{}}|memjustarg}{6} +\glossaryentry{defns.parameter@ {\memgloterm{defns.parameter}}{\memglodesc{(\ref {defns.parameter})}} {\memgloref{}}|memjustarg}{6} +\glossaryentry{defns.parameter.macro@ {\memgloterm{defns.parameter.macro}}{\memglodesc{(\ref {defns.parameter.macro})}} {\memgloref{}}|memjustarg}{6} +\glossaryentry{defns.parameter.templ@ {\memgloterm{defns.parameter.templ}}{\memglodesc{(\ref {defns.parameter.templ})}} {\memgloref{}}|memjustarg}{6} +\glossaryentry{defns.regex.primary.equivalence.class@ {\memgloterm{defns.regex.primary.equivalence.class}}{\memglodesc{(\ref {defns.regex.primary.equivalence.class})}} {\memgloref{}}|memjustarg}{6} +\glossaryentry{defns.prog.def.spec@ {\memgloterm{defns.prog.def.spec}}{\memglodesc{(\ref {defns.prog.def.spec})}} {\memgloref{}}|memjustarg}{6} +\glossaryentry{defns.prog.def.type@ {\memgloterm{defns.prog.def.type}}{\memglodesc{(\ref {defns.prog.def.type})}} {\memgloref{}}|memjustarg}{6} +\glossaryentry{defns.projection@ {\memgloterm{defns.projection}}{\memglodesc{(\ref {defns.projection})}} {\memgloref{}}|memjustarg}{6} +\glossaryentry{defns.referenceable@ {\memgloterm{defns.referenceable}}{\memglodesc{(\ref {defns.referenceable})}} {\memgloref{}}|memjustarg}{7} +\glossaryentry{defns.regex.regular.expression@ {\memgloterm{defns.regex.regular.expression}}{\memglodesc{(\ref {defns.regex.regular.expression})}} {\memgloref{}}|memjustarg}{7} +\glossaryentry{defns.replacement@ {\memgloterm{defns.replacement}}{\memglodesc{(\ref {defns.replacement})}} {\memgloref{}}|memjustarg}{7} +\glossaryentry{defns.repositional.stream@ {\memgloterm{defns.repositional.stream}}{\memglodesc{(\ref {defns.repositional.stream})}} {\memgloref{}}|memjustarg}{7} +\glossaryentry{defns.required.behavior@ {\memgloterm{defns.required.behavior}}{\memglodesc{(\ref {defns.required.behavior})}} {\memgloref{}}|memjustarg}{7} +\glossaryentry{defns.reserved.function@ {\memgloterm{defns.reserved.function}}{\memglodesc{(\ref {defns.reserved.function})}} {\memgloref{}}|memjustarg}{7} +\glossaryentry{defns.signature@ {\memgloterm{defns.signature}}{\memglodesc{(\ref {defns.signature})}} {\memgloref{}}|memjustarg}{7} +\glossaryentry{defns.signature.friend@ {\memgloterm{defns.signature.friend}}{\memglodesc{(\ref {defns.signature.friend})}} {\memgloref{}}|memjustarg}{7} +\glossaryentry{defns.signature.templ@ {\memgloterm{defns.signature.templ}}{\memglodesc{(\ref {defns.signature.templ})}} {\memgloref{}}|memjustarg}{7} +\glossaryentry{defns.signature.templ.friend@ {\memgloterm{defns.signature.templ.friend}}{\memglodesc{(\ref {defns.signature.templ.friend})}} {\memgloref{}}|memjustarg}{7} +\glossaryentry{defns.signature.spec@ {\memgloterm{defns.signature.spec}}{\memglodesc{(\ref {defns.signature.spec})}} {\memgloref{}}|memjustarg}{8} +\glossaryentry{defns.signature.member@ {\memgloterm{defns.signature.member}}{\memglodesc{(\ref {defns.signature.member})}} {\memgloref{}}|memjustarg}{8} +\glossaryentry{defns.signature.member.templ@ {\memgloterm{defns.signature.member.templ}}{\memglodesc{(\ref {defns.signature.member.templ})}} {\memgloref{}}|memjustarg}{8} +\glossaryentry{defns.signature.member.spec@ {\memgloterm{defns.signature.member.spec}}{\memglodesc{(\ref {defns.signature.member.spec})}} {\memgloref{}}|memjustarg}{8} +\glossaryentry{defns.signature.template.head@ {\memgloterm{defns.signature.template.head}}{\memglodesc{(\ref {defns.signature.template.head})}} {\memgloref{}}|memjustarg}{8} +\glossaryentry{defns.stable@ {\memgloterm{defns.stable}}{\memglodesc{(\ref {defns.stable})}} {\memgloref{}}|memjustarg}{8} +\glossaryentry{defns.static.type@ {\memgloterm{defns.static.type}}{\memglodesc{(\ref {defns.static.type})}} {\memgloref{}}|memjustarg}{8} +\glossaryentry{defns.regex.subexpression@ {\memgloterm{defns.regex.subexpression}}{\memglodesc{(\ref {defns.regex.subexpression})}} {\memgloref{}}|memjustarg}{8} +\glossaryentry{defns.traits@ {\memgloterm{defns.traits}}{\memglodesc{(\ref {defns.traits})}} {\memgloref{}}|memjustarg}{8} +\glossaryentry{defns.unblock@ {\memgloterm{defns.unblock}}{\memglodesc{(\ref {defns.unblock})}} {\memgloref{}}|memjustarg}{8} +\glossaryentry{defns.undefined@ {\memgloterm{defns.undefined}}{\memglodesc{(\ref {defns.undefined})}} {\memgloref{}}|memjustarg}{8} +\glossaryentry{defns.unspecified@ {\memgloterm{defns.unspecified}}{\memglodesc{(\ref {defns.unspecified})}} {\memgloref{}}|memjustarg}{9} +\glossaryentry{defns.valid@ {\memgloterm{defns.valid}}{\memglodesc{(\ref {defns.valid})}} {\memgloref{}}|memjustarg}{9} +\glossaryentry{defns.well.formed@ {\memgloterm{defns.well.formed}}{\memglodesc{(\ref {defns.well.formed})}} {\memgloref{}}|memjustarg}{9} +\glossaryentry{intro@ {\memgloterm{intro}}{\memglodesc{(\ref {intro})}} {\memgloref{}}|memjustarg}{10} +\glossaryentry{intro.compliance@ {\memgloterm{intro.compliance}}{\memglodesc{(\ref {intro.compliance})}} {\memgloref{}}|memjustarg}{10} +\glossaryentry{intro.compliance.general@ {\memgloterm{intro.compliance.general}}{\memglodesc{(\ref {intro.compliance.general})}} {\memgloref{}}|memjustarg}{10} +\glossaryentry{intro.abstract@ {\memgloterm{intro.abstract}}{\memglodesc{(\ref {intro.abstract})}} {\memgloref{}}|memjustarg}{11} +\glossaryentry{intro.structure@ {\memgloterm{intro.structure}}{\memglodesc{(\ref {intro.structure})}} {\memgloref{}}|memjustarg}{11} +\glossaryentry{syntax@ {\memgloterm{syntax}}{\memglodesc{(\ref {syntax})}} {\memgloref{}}|memjustarg}{12} +\glossaryentry{lex@ {\memgloterm{lex}}{\memglodesc{(\ref {lex})}} {\memgloref{}}|memjustarg}{13} +\glossaryentry{lex.separate@ {\memgloterm{lex.separate}}{\memglodesc{(\ref {lex.separate})}} {\memgloref{}}|memjustarg}{13} +\glossaryentry{lex.phases@ {\memgloterm{lex.phases}}{\memglodesc{(\ref {lex.phases})}} {\memgloref{}}|memjustarg}{13} +\glossaryentry{lex.charset@ {\memgloterm{lex.charset}}{\memglodesc{(\ref {lex.charset})}} {\memgloref{}}|memjustarg}{14} +\glossaryentry{lex.pptoken@ {\memgloterm{lex.pptoken}}{\memglodesc{(\ref {lex.pptoken})}} {\memgloref{}}|memjustarg}{17} +\glossaryentry{lex.digraph@ {\memgloterm{lex.digraph}}{\memglodesc{(\ref {lex.digraph})}} {\memgloref{}}|memjustarg}{18} +\glossaryentry{lex.token@ {\memgloterm{lex.token}}{\memglodesc{(\ref {lex.token})}} {\memgloref{}}|memjustarg}{18} +\glossaryentry{lex.comment@ {\memgloterm{lex.comment}}{\memglodesc{(\ref {lex.comment})}} {\memgloref{}}|memjustarg}{18} +\glossaryentry{lex.header@ {\memgloterm{lex.header}}{\memglodesc{(\ref {lex.header})}} {\memgloref{}}|memjustarg}{18} +\glossaryentry{lex.ppnumber@ {\memgloterm{lex.ppnumber}}{\memglodesc{(\ref {lex.ppnumber})}} {\memgloref{}}|memjustarg}{19} +\glossaryentry{lex.name@ {\memgloterm{lex.name}}{\memglodesc{(\ref {lex.name})}} {\memgloref{}}|memjustarg}{19} +\glossaryentry{lex.key@ {\memgloterm{lex.key}}{\memglodesc{(\ref {lex.key})}} {\memgloref{}}|memjustarg}{20} +\glossaryentry{lex.operators@ {\memgloterm{lex.operators}}{\memglodesc{(\ref {lex.operators})}} {\memgloref{}}|memjustarg}{20} +\glossaryentry{lex.literal@ {\memgloterm{lex.literal}}{\memglodesc{(\ref {lex.literal})}} {\memgloref{}}|memjustarg}{21} +\glossaryentry{lex.literal.kinds@ {\memgloterm{lex.literal.kinds}}{\memglodesc{(\ref {lex.literal.kinds})}} {\memgloref{}}|memjustarg}{21} +\glossaryentry{lex.icon@ {\memgloterm{lex.icon}}{\memglodesc{(\ref {lex.icon})}} {\memgloref{}}|memjustarg}{21} +\glossaryentry{lex.ccon@ {\memgloterm{lex.ccon}}{\memglodesc{(\ref {lex.ccon})}} {\memgloref{}}|memjustarg}{23} +\glossaryentry{lex.fcon@ {\memgloterm{lex.fcon}}{\memglodesc{(\ref {lex.fcon})}} {\memgloref{}}|memjustarg}{25} +\glossaryentry{lex.string@ {\memgloterm{lex.string}}{\memglodesc{(\ref {lex.string})}} {\memgloref{}}|memjustarg}{26} +\glossaryentry{lex.bool@ {\memgloterm{lex.bool}}{\memglodesc{(\ref {lex.bool})}} {\memgloref{}}|memjustarg}{29} +\glossaryentry{lex.nullptr@ {\memgloterm{lex.nullptr}}{\memglodesc{(\ref {lex.nullptr})}} {\memgloref{}}|memjustarg}{29} +\glossaryentry{lex.ext@ {\memgloterm{lex.ext}}{\memglodesc{(\ref {lex.ext})}} {\memgloref{}}|memjustarg}{29} +\glossaryentry{basic@ {\memgloterm{basic}}{\memglodesc{(\ref {basic})}} {\memgloref{}}|memjustarg}{32} +\glossaryentry{basic.pre@ {\memgloterm{basic.pre}}{\memglodesc{(\ref {basic.pre})}} {\memgloref{}}|memjustarg}{32} +\glossaryentry{basic.def@ {\memgloterm{basic.def}}{\memglodesc{(\ref {basic.def})}} {\memgloref{}}|memjustarg}{33} +\glossaryentry{basic.def.odr@ {\memgloterm{basic.def.odr}}{\memglodesc{(\ref {basic.def.odr})}} {\memgloref{}}|memjustarg}{34} +\glossaryentry{basic.scope@ {\memgloterm{basic.scope}}{\memglodesc{(\ref {basic.scope})}} {\memgloref{}}|memjustarg}{39} +\glossaryentry{basic.scope.scope@ {\memgloterm{basic.scope.scope}}{\memglodesc{(\ref {basic.scope.scope})}} {\memgloref{}}|memjustarg}{39} +\glossaryentry{basic.scope.pdecl@ {\memgloterm{basic.scope.pdecl}}{\memglodesc{(\ref {basic.scope.pdecl})}} {\memgloref{}}|memjustarg}{41} +\glossaryentry{basic.scope.block@ {\memgloterm{basic.scope.block}}{\memglodesc{(\ref {basic.scope.block})}} {\memgloref{}}|memjustarg}{42} +\glossaryentry{basic.scope.param@ {\memgloterm{basic.scope.param}}{\memglodesc{(\ref {basic.scope.param})}} {\memgloref{}}|memjustarg}{43} +\glossaryentry{basic.scope.lambda@ {\memgloterm{basic.scope.lambda}}{\memglodesc{(\ref {basic.scope.lambda})}} {\memgloref{}}|memjustarg}{43} +\glossaryentry{basic.scope.namespace@ {\memgloterm{basic.scope.namespace}}{\memglodesc{(\ref {basic.scope.namespace})}} {\memgloref{}}|memjustarg}{43} +\glossaryentry{basic.scope.class@ {\memgloterm{basic.scope.class}}{\memglodesc{(\ref {basic.scope.class})}} {\memgloref{}}|memjustarg}{44} +\glossaryentry{basic.scope.enum@ {\memgloterm{basic.scope.enum}}{\memglodesc{(\ref {basic.scope.enum})}} {\memgloref{}}|memjustarg}{44} +\glossaryentry{basic.scope.temp@ {\memgloterm{basic.scope.temp}}{\memglodesc{(\ref {basic.scope.temp})}} {\memgloref{}}|memjustarg}{44} +\glossaryentry{basic.lookup@ {\memgloterm{basic.lookup}}{\memglodesc{(\ref {basic.lookup})}} {\memgloref{}}|memjustarg}{44} +\glossaryentry{basic.lookup.general@ {\memgloterm{basic.lookup.general}}{\memglodesc{(\ref {basic.lookup.general})}} {\memgloref{}}|memjustarg}{44} +\glossaryentry{class.member.lookup@ {\memgloterm{class.member.lookup}}{\memglodesc{(\ref {class.member.lookup})}} {\memgloref{}}|memjustarg}{45} +\glossaryentry{basic.lookup.unqual@ {\memgloterm{basic.lookup.unqual}}{\memglodesc{(\ref {basic.lookup.unqual})}} {\memgloref{}}|memjustarg}{48} +\glossaryentry{basic.lookup.argdep@ {\memgloterm{basic.lookup.argdep}}{\memglodesc{(\ref {basic.lookup.argdep})}} {\memgloref{}}|memjustarg}{49} +\glossaryentry{basic.lookup.qual@ {\memgloterm{basic.lookup.qual}}{\memglodesc{(\ref {basic.lookup.qual})}} {\memgloref{}}|memjustarg}{52} +\glossaryentry{basic.lookup.qual.general@ {\memgloterm{basic.lookup.qual.general}}{\memglodesc{(\ref {basic.lookup.qual.general})}} {\memgloref{}}|memjustarg}{52} +\glossaryentry{class.qual@ {\memgloterm{class.qual}}{\memglodesc{(\ref {class.qual})}} {\memgloref{}}|memjustarg}{54} +\glossaryentry{namespace.qual@ {\memgloterm{namespace.qual}}{\memglodesc{(\ref {namespace.qual})}} {\memgloref{}}|memjustarg}{54} +\glossaryentry{basic.lookup.elab@ {\memgloterm{basic.lookup.elab}}{\memglodesc{(\ref {basic.lookup.elab})}} {\memgloref{}}|memjustarg}{56} +\glossaryentry{basic.lookup.udir@ {\memgloterm{basic.lookup.udir}}{\memglodesc{(\ref {basic.lookup.udir})}} {\memgloref{}}|memjustarg}{57} +\glossaryentry{basic.link@ {\memgloterm{basic.link}}{\memglodesc{(\ref {basic.link})}} {\memgloref{}}|memjustarg}{57} +\glossaryentry{basic.memobj@ {\memgloterm{basic.memobj}}{\memglodesc{(\ref {basic.memobj})}} {\memgloref{}}|memjustarg}{61} +\glossaryentry{intro.memory@ {\memgloterm{intro.memory}}{\memglodesc{(\ref {intro.memory})}} {\memgloref{}}|memjustarg}{61} +\glossaryentry{intro.object@ {\memgloterm{intro.object}}{\memglodesc{(\ref {intro.object})}} {\memgloref{}}|memjustarg}{62} +\glossaryentry{basic.life@ {\memgloterm{basic.life}}{\memglodesc{(\ref {basic.life})}} {\memgloref{}}|memjustarg}{64} +\glossaryentry{basic.indet@ {\memgloterm{basic.indet}}{\memglodesc{(\ref {basic.indet})}} {\memgloref{}}|memjustarg}{67} +\glossaryentry{basic.stc@ {\memgloterm{basic.stc}}{\memglodesc{(\ref {basic.stc})}} {\memgloref{}}|memjustarg}{67} +\glossaryentry{basic.stc.general@ {\memgloterm{basic.stc.general}}{\memglodesc{(\ref {basic.stc.general})}} {\memgloref{}}|memjustarg}{67} +\glossaryentry{basic.stc.static@ {\memgloterm{basic.stc.static}}{\memglodesc{(\ref {basic.stc.static})}} {\memgloref{}}|memjustarg}{68} +\glossaryentry{basic.stc.thread@ {\memgloterm{basic.stc.thread}}{\memglodesc{(\ref {basic.stc.thread})}} {\memgloref{}}|memjustarg}{68} +\glossaryentry{basic.stc.auto@ {\memgloterm{basic.stc.auto}}{\memglodesc{(\ref {basic.stc.auto})}} {\memgloref{}}|memjustarg}{68} +\glossaryentry{basic.stc.dynamic@ {\memgloterm{basic.stc.dynamic}}{\memglodesc{(\ref {basic.stc.dynamic})}} {\memgloref{}}|memjustarg}{68} +\glossaryentry{basic.stc.dynamic.general@ {\memgloterm{basic.stc.dynamic.general}}{\memglodesc{(\ref {basic.stc.dynamic.general})}} {\memgloref{}}|memjustarg}{68} +\glossaryentry{basic.stc.dynamic.allocation@ {\memgloterm{basic.stc.dynamic.allocation}}{\memglodesc{(\ref {basic.stc.dynamic.allocation})}} {\memgloref{}}|memjustarg}{69} +\glossaryentry{basic.stc.dynamic.deallocation@ {\memgloterm{basic.stc.dynamic.deallocation}}{\memglodesc{(\ref {basic.stc.dynamic.deallocation})}} {\memgloref{}}|memjustarg}{70} +\glossaryentry{basic.stc.inherit@ {\memgloterm{basic.stc.inherit}}{\memglodesc{(\ref {basic.stc.inherit})}} {\memgloref{}}|memjustarg}{70} +\glossaryentry{basic.align@ {\memgloterm{basic.align}}{\memglodesc{(\ref {basic.align})}} {\memgloref{}}|memjustarg}{70} +\glossaryentry{class.temporary@ {\memgloterm{class.temporary}}{\memglodesc{(\ref {class.temporary})}} {\memgloref{}}|memjustarg}{71} +\glossaryentry{basic.types@ {\memgloterm{basic.types}}{\memglodesc{(\ref {basic.types})}} {\memgloref{}}|memjustarg}{74} +\glossaryentry{basic.types.general@ {\memgloterm{basic.types.general}}{\memglodesc{(\ref {basic.types.general})}} {\memgloref{}}|memjustarg}{74} +\glossaryentry{basic.fundamental@ {\memgloterm{basic.fundamental}}{\memglodesc{(\ref {basic.fundamental})}} {\memgloref{}}|memjustarg}{76} +\glossaryentry{basic.extended.fp@ {\memgloterm{basic.extended.fp}}{\memglodesc{(\ref {basic.extended.fp})}} {\memgloref{}}|memjustarg}{78} +\glossaryentry{basic.compound@ {\memgloterm{basic.compound}}{\memglodesc{(\ref {basic.compound})}} {\memgloref{}}|memjustarg}{79} +\glossaryentry{basic.type.qualifier@ {\memgloterm{basic.type.qualifier}}{\memglodesc{(\ref {basic.type.qualifier})}} {\memgloref{}}|memjustarg}{80} +\glossaryentry{conv.rank@ {\memgloterm{conv.rank}}{\memglodesc{(\ref {conv.rank})}} {\memgloref{}}|memjustarg}{81} +\glossaryentry{basic.exec@ {\memgloterm{basic.exec}}{\memglodesc{(\ref {basic.exec})}} {\memgloref{}}|memjustarg}{82} +\glossaryentry{intro.execution@ {\memgloterm{intro.execution}}{\memglodesc{(\ref {intro.execution})}} {\memgloref{}}|memjustarg}{82} +\glossaryentry{intro.multithread@ {\memgloterm{intro.multithread}}{\memglodesc{(\ref {intro.multithread})}} {\memgloref{}}|memjustarg}{85} +\glossaryentry{intro.multithread.general@ {\memgloterm{intro.multithread.general}}{\memglodesc{(\ref {intro.multithread.general})}} {\memgloref{}}|memjustarg}{85} +\glossaryentry{intro.races@ {\memgloterm{intro.races}}{\memglodesc{(\ref {intro.races})}} {\memgloref{}}|memjustarg}{85} +\glossaryentry{intro.progress@ {\memgloterm{intro.progress}}{\memglodesc{(\ref {intro.progress})}} {\memgloref{}}|memjustarg}{88} +\glossaryentry{basic.start@ {\memgloterm{basic.start}}{\memglodesc{(\ref {basic.start})}} {\memgloref{}}|memjustarg}{90} +\glossaryentry{basic.start.main@ {\memgloterm{basic.start.main}}{\memglodesc{(\ref {basic.start.main})}} {\memgloref{}}|memjustarg}{90} +\glossaryentry{basic.start.static@ {\memgloterm{basic.start.static}}{\memglodesc{(\ref {basic.start.static})}} {\memgloref{}}|memjustarg}{91} +\glossaryentry{basic.start.dynamic@ {\memgloterm{basic.start.dynamic}}{\memglodesc{(\ref {basic.start.dynamic})}} {\memgloref{}}|memjustarg}{91} +\glossaryentry{basic.start.term@ {\memgloterm{basic.start.term}}{\memglodesc{(\ref {basic.start.term})}} {\memgloref{}}|memjustarg}{93} +\glossaryentry{expr@ {\memgloterm{expr}}{\memglodesc{(\ref {expr})}} {\memgloref{}}|memjustarg}{94} +\glossaryentry{expr.pre@ {\memgloterm{expr.pre}}{\memglodesc{(\ref {expr.pre})}} {\memgloref{}}|memjustarg}{94} +\glossaryentry{expr.prop@ {\memgloterm{expr.prop}}{\memglodesc{(\ref {expr.prop})}} {\memgloref{}}|memjustarg}{95} +\glossaryentry{basic.lval@ {\memgloterm{basic.lval}}{\memglodesc{(\ref {basic.lval})}} {\memgloref{}}|memjustarg}{95} +\glossaryentry{expr.type@ {\memgloterm{expr.type}}{\memglodesc{(\ref {expr.type})}} {\memgloref{}}|memjustarg}{96} +\glossaryentry{expr.context@ {\memgloterm{expr.context}}{\memglodesc{(\ref {expr.context})}} {\memgloref{}}|memjustarg}{97} +\glossaryentry{conv@ {\memgloterm{conv}}{\memglodesc{(\ref {conv})}} {\memgloref{}}|memjustarg}{98} +\glossaryentry{conv.general@ {\memgloterm{conv.general}}{\memglodesc{(\ref {conv.general})}} {\memgloref{}}|memjustarg}{98} +\glossaryentry{conv.lval@ {\memgloterm{conv.lval}}{\memglodesc{(\ref {conv.lval})}} {\memgloref{}}|memjustarg}{99} +\glossaryentry{conv.array@ {\memgloterm{conv.array}}{\memglodesc{(\ref {conv.array})}} {\memgloref{}}|memjustarg}{99} +\glossaryentry{conv.func@ {\memgloterm{conv.func}}{\memglodesc{(\ref {conv.func})}} {\memgloref{}}|memjustarg}{99} +\glossaryentry{conv.rval@ {\memgloterm{conv.rval}}{\memglodesc{(\ref {conv.rval})}} {\memgloref{}}|memjustarg}{99} +\glossaryentry{conv.qual@ {\memgloterm{conv.qual}}{\memglodesc{(\ref {conv.qual})}} {\memgloref{}}|memjustarg}{100} +\glossaryentry{conv.prom@ {\memgloterm{conv.prom}}{\memglodesc{(\ref {conv.prom})}} {\memgloref{}}|memjustarg}{100} +\glossaryentry{conv.fpprom@ {\memgloterm{conv.fpprom}}{\memglodesc{(\ref {conv.fpprom})}} {\memgloref{}}|memjustarg}{101} +\glossaryentry{conv.integral@ {\memgloterm{conv.integral}}{\memglodesc{(\ref {conv.integral})}} {\memgloref{}}|memjustarg}{101} +\glossaryentry{conv.double@ {\memgloterm{conv.double}}{\memglodesc{(\ref {conv.double})}} {\memgloref{}}|memjustarg}{101} +\glossaryentry{conv.fpint@ {\memgloterm{conv.fpint}}{\memglodesc{(\ref {conv.fpint})}} {\memgloref{}}|memjustarg}{101} +\glossaryentry{conv.ptr@ {\memgloterm{conv.ptr}}{\memglodesc{(\ref {conv.ptr})}} {\memgloref{}}|memjustarg}{102} +\glossaryentry{conv.mem@ {\memgloterm{conv.mem}}{\memglodesc{(\ref {conv.mem})}} {\memgloref{}}|memjustarg}{102} +\glossaryentry{conv.fctptr@ {\memgloterm{conv.fctptr}}{\memglodesc{(\ref {conv.fctptr})}} {\memgloref{}}|memjustarg}{102} +\glossaryentry{conv.bool@ {\memgloterm{conv.bool}}{\memglodesc{(\ref {conv.bool})}} {\memgloref{}}|memjustarg}{103} +\glossaryentry{expr.arith.conv@ {\memgloterm{expr.arith.conv}}{\memglodesc{(\ref {expr.arith.conv})}} {\memgloref{}}|memjustarg}{103} +\glossaryentry{expr.prim@ {\memgloterm{expr.prim}}{\memglodesc{(\ref {expr.prim})}} {\memgloref{}}|memjustarg}{103} +\glossaryentry{expr.prim.literal@ {\memgloterm{expr.prim.literal}}{\memglodesc{(\ref {expr.prim.literal})}} {\memgloref{}}|memjustarg}{103} +\glossaryentry{expr.prim.this@ {\memgloterm{expr.prim.this}}{\memglodesc{(\ref {expr.prim.this})}} {\memgloref{}}|memjustarg}{104} +\glossaryentry{expr.prim.paren@ {\memgloterm{expr.prim.paren}}{\memglodesc{(\ref {expr.prim.paren})}} {\memgloref{}}|memjustarg}{104} +\glossaryentry{expr.prim.id@ {\memgloterm{expr.prim.id}}{\memglodesc{(\ref {expr.prim.id})}} {\memgloref{}}|memjustarg}{104} +\glossaryentry{expr.prim.id.general@ {\memgloterm{expr.prim.id.general}}{\memglodesc{(\ref {expr.prim.id.general})}} {\memgloref{}}|memjustarg}{104} +\glossaryentry{expr.prim.id.unqual@ {\memgloterm{expr.prim.id.unqual}}{\memglodesc{(\ref {expr.prim.id.unqual})}} {\memgloref{}}|memjustarg}{105} +\glossaryentry{expr.prim.id.qual@ {\memgloterm{expr.prim.id.qual}}{\memglodesc{(\ref {expr.prim.id.qual})}} {\memgloref{}}|memjustarg}{107} +\glossaryentry{expr.prim.id.dtor@ {\memgloterm{expr.prim.id.dtor}}{\memglodesc{(\ref {expr.prim.id.dtor})}} {\memgloref{}}|memjustarg}{108} +\glossaryentry{expr.prim.lambda@ {\memgloterm{expr.prim.lambda}}{\memglodesc{(\ref {expr.prim.lambda})}} {\memgloref{}}|memjustarg}{108} +\glossaryentry{expr.prim.lambda.general@ {\memgloterm{expr.prim.lambda.general}}{\memglodesc{(\ref {expr.prim.lambda.general})}} {\memgloref{}}|memjustarg}{108} +\glossaryentry{expr.prim.lambda.closure@ {\memgloterm{expr.prim.lambda.closure}}{\memglodesc{(\ref {expr.prim.lambda.closure})}} {\memgloref{}}|memjustarg}{109} +\glossaryentry{expr.prim.lambda.capture@ {\memgloterm{expr.prim.lambda.capture}}{\memglodesc{(\ref {expr.prim.lambda.capture})}} {\memgloref{}}|memjustarg}{113} +\glossaryentry{expr.prim.fold@ {\memgloterm{expr.prim.fold}}{\memglodesc{(\ref {expr.prim.fold})}} {\memgloref{}}|memjustarg}{118} +\glossaryentry{expr.prim.req@ {\memgloterm{expr.prim.req}}{\memglodesc{(\ref {expr.prim.req})}} {\memgloref{}}|memjustarg}{119} +\glossaryentry{expr.prim.req.general@ {\memgloterm{expr.prim.req.general}}{\memglodesc{(\ref {expr.prim.req.general})}} {\memgloref{}}|memjustarg}{119} +\glossaryentry{expr.prim.req.simple@ {\memgloterm{expr.prim.req.simple}}{\memglodesc{(\ref {expr.prim.req.simple})}} {\memgloref{}}|memjustarg}{120} +\glossaryentry{expr.prim.req.type@ {\memgloterm{expr.prim.req.type}}{\memglodesc{(\ref {expr.prim.req.type})}} {\memgloref{}}|memjustarg}{120} +\glossaryentry{expr.prim.req.compound@ {\memgloterm{expr.prim.req.compound}}{\memglodesc{(\ref {expr.prim.req.compound})}} {\memgloref{}}|memjustarg}{120} +\glossaryentry{expr.prim.req.nested@ {\memgloterm{expr.prim.req.nested}}{\memglodesc{(\ref {expr.prim.req.nested})}} {\memgloref{}}|memjustarg}{121} +\glossaryentry{expr.compound@ {\memgloterm{expr.compound}}{\memglodesc{(\ref {expr.compound})}} {\memgloref{}}|memjustarg}{122} +\glossaryentry{expr.post@ {\memgloterm{expr.post}}{\memglodesc{(\ref {expr.post})}} {\memgloref{}}|memjustarg}{122} +\glossaryentry{expr.post.general@ {\memgloterm{expr.post.general}}{\memglodesc{(\ref {expr.post.general})}} {\memgloref{}}|memjustarg}{122} +\glossaryentry{expr.sub@ {\memgloterm{expr.sub}}{\memglodesc{(\ref {expr.sub})}} {\memgloref{}}|memjustarg}{122} +\glossaryentry{expr.call@ {\memgloterm{expr.call}}{\memglodesc{(\ref {expr.call})}} {\memgloref{}}|memjustarg}{122} +\glossaryentry{expr.type.conv@ {\memgloterm{expr.type.conv}}{\memglodesc{(\ref {expr.type.conv})}} {\memgloref{}}|memjustarg}{124} +\glossaryentry{expr.ref@ {\memgloterm{expr.ref}}{\memglodesc{(\ref {expr.ref})}} {\memgloref{}}|memjustarg}{125} +\glossaryentry{expr.post.incr@ {\memgloterm{expr.post.incr}}{\memglodesc{(\ref {expr.post.incr})}} {\memgloref{}}|memjustarg}{126} +\glossaryentry{expr.dynamic.cast@ {\memgloterm{expr.dynamic.cast}}{\memglodesc{(\ref {expr.dynamic.cast})}} {\memgloref{}}|memjustarg}{126} +\glossaryentry{expr.typeid@ {\memgloterm{expr.typeid}}{\memglodesc{(\ref {expr.typeid})}} {\memgloref{}}|memjustarg}{127} +\glossaryentry{expr.static.cast@ {\memgloterm{expr.static.cast}}{\memglodesc{(\ref {expr.static.cast})}} {\memgloref{}}|memjustarg}{128} +\glossaryentry{expr.reinterpret.cast@ {\memgloterm{expr.reinterpret.cast}}{\memglodesc{(\ref {expr.reinterpret.cast})}} {\memgloref{}}|memjustarg}{130} +\glossaryentry{expr.const.cast@ {\memgloterm{expr.const.cast}}{\memglodesc{(\ref {expr.const.cast})}} {\memgloref{}}|memjustarg}{131} +\glossaryentry{expr.unary@ {\memgloterm{expr.unary}}{\memglodesc{(\ref {expr.unary})}} {\memgloref{}}|memjustarg}{132} +\glossaryentry{expr.unary.general@ {\memgloterm{expr.unary.general}}{\memglodesc{(\ref {expr.unary.general})}} {\memgloref{}}|memjustarg}{132} +\glossaryentry{expr.unary.op@ {\memgloterm{expr.unary.op}}{\memglodesc{(\ref {expr.unary.op})}} {\memgloref{}}|memjustarg}{133} +\glossaryentry{expr.pre.incr@ {\memgloterm{expr.pre.incr}}{\memglodesc{(\ref {expr.pre.incr})}} {\memgloref{}}|memjustarg}{134} +\glossaryentry{expr.await@ {\memgloterm{expr.await}}{\memglodesc{(\ref {expr.await})}} {\memgloref{}}|memjustarg}{134} +\glossaryentry{expr.sizeof@ {\memgloterm{expr.sizeof}}{\memglodesc{(\ref {expr.sizeof})}} {\memgloref{}}|memjustarg}{136} +\glossaryentry{expr.alignof@ {\memgloterm{expr.alignof}}{\memglodesc{(\ref {expr.alignof})}} {\memgloref{}}|memjustarg}{136} +\glossaryentry{expr.unary.noexcept@ {\memgloterm{expr.unary.noexcept}}{\memglodesc{(\ref {expr.unary.noexcept})}} {\memgloref{}}|memjustarg}{137} +\glossaryentry{expr.new@ {\memgloterm{expr.new}}{\memglodesc{(\ref {expr.new})}} {\memgloref{}}|memjustarg}{137} +\glossaryentry{expr.delete@ {\memgloterm{expr.delete}}{\memglodesc{(\ref {expr.delete})}} {\memgloref{}}|memjustarg}{141} +\glossaryentry{expr.cast@ {\memgloterm{expr.cast}}{\memglodesc{(\ref {expr.cast})}} {\memgloref{}}|memjustarg}{143} +\glossaryentry{expr.mptr.oper@ {\memgloterm{expr.mptr.oper}}{\memglodesc{(\ref {expr.mptr.oper})}} {\memgloref{}}|memjustarg}{144} +\glossaryentry{expr.mul@ {\memgloterm{expr.mul}}{\memglodesc{(\ref {expr.mul})}} {\memgloref{}}|memjustarg}{145} +\glossaryentry{expr.add@ {\memgloterm{expr.add}}{\memglodesc{(\ref {expr.add})}} {\memgloref{}}|memjustarg}{145} +\glossaryentry{expr.shift@ {\memgloterm{expr.shift}}{\memglodesc{(\ref {expr.shift})}} {\memgloref{}}|memjustarg}{146} +\glossaryentry{expr.spaceship@ {\memgloterm{expr.spaceship}}{\memglodesc{(\ref {expr.spaceship})}} {\memgloref{}}|memjustarg}{147} +\glossaryentry{expr.rel@ {\memgloterm{expr.rel}}{\memglodesc{(\ref {expr.rel})}} {\memgloref{}}|memjustarg}{147} +\glossaryentry{expr.eq@ {\memgloterm{expr.eq}}{\memglodesc{(\ref {expr.eq})}} {\memgloref{}}|memjustarg}{148} +\glossaryentry{expr.bit.and@ {\memgloterm{expr.bit.and}}{\memglodesc{(\ref {expr.bit.and})}} {\memgloref{}}|memjustarg}{149} +\glossaryentry{expr.xor@ {\memgloterm{expr.xor}}{\memglodesc{(\ref {expr.xor})}} {\memgloref{}}|memjustarg}{149} +\glossaryentry{expr.or@ {\memgloterm{expr.or}}{\memglodesc{(\ref {expr.or})}} {\memgloref{}}|memjustarg}{150} +\glossaryentry{expr.log.and@ {\memgloterm{expr.log.and}}{\memglodesc{(\ref {expr.log.and})}} {\memgloref{}}|memjustarg}{150} +\glossaryentry{expr.log.or@ {\memgloterm{expr.log.or}}{\memglodesc{(\ref {expr.log.or})}} {\memgloref{}}|memjustarg}{150} +\glossaryentry{expr.cond@ {\memgloterm{expr.cond}}{\memglodesc{(\ref {expr.cond})}} {\memgloref{}}|memjustarg}{150} +\glossaryentry{expr.yield@ {\memgloterm{expr.yield}}{\memglodesc{(\ref {expr.yield})}} {\memgloref{}}|memjustarg}{152} +\glossaryentry{expr.throw@ {\memgloterm{expr.throw}}{\memglodesc{(\ref {expr.throw})}} {\memgloref{}}|memjustarg}{152} +\glossaryentry{expr.ass@ {\memgloterm{expr.ass}}{\memglodesc{(\ref {expr.ass})}} {\memgloref{}}|memjustarg}{153} +\glossaryentry{expr.comma@ {\memgloterm{expr.comma}}{\memglodesc{(\ref {expr.comma})}} {\memgloref{}}|memjustarg}{154} +\glossaryentry{expr.const@ {\memgloterm{expr.const}}{\memglodesc{(\ref {expr.const})}} {\memgloref{}}|memjustarg}{154} +\glossaryentry{stmt.stmt@ {\memgloterm{stmt.stmt}}{\memglodesc{(\ref {stmt.stmt})}} {\memgloref{}}|memjustarg}{163} +\glossaryentry{stmt.pre@ {\memgloterm{stmt.pre}}{\memglodesc{(\ref {stmt.pre})}} {\memgloref{}}|memjustarg}{163} +\glossaryentry{stmt.label@ {\memgloterm{stmt.label}}{\memglodesc{(\ref {stmt.label})}} {\memgloref{}}|memjustarg}{164} +\glossaryentry{stmt.expr@ {\memgloterm{stmt.expr}}{\memglodesc{(\ref {stmt.expr})}} {\memgloref{}}|memjustarg}{164} +\glossaryentry{stmt.block@ {\memgloterm{stmt.block}}{\memglodesc{(\ref {stmt.block})}} {\memgloref{}}|memjustarg}{164} +\glossaryentry{stmt.select@ {\memgloterm{stmt.select}}{\memglodesc{(\ref {stmt.select})}} {\memgloref{}}|memjustarg}{164} +\glossaryentry{stmt.select.general@ {\memgloterm{stmt.select.general}}{\memglodesc{(\ref {stmt.select.general})}} {\memgloref{}}|memjustarg}{164} +\glossaryentry{stmt.if@ {\memgloterm{stmt.if}}{\memglodesc{(\ref {stmt.if})}} {\memgloref{}}|memjustarg}{165} +\glossaryentry{stmt.switch@ {\memgloterm{stmt.switch}}{\memglodesc{(\ref {stmt.switch})}} {\memgloref{}}|memjustarg}{166} +\glossaryentry{stmt.iter@ {\memgloterm{stmt.iter}}{\memglodesc{(\ref {stmt.iter})}} {\memgloref{}}|memjustarg}{167} +\glossaryentry{stmt.iter.general@ {\memgloterm{stmt.iter.general}}{\memglodesc{(\ref {stmt.iter.general})}} {\memgloref{}}|memjustarg}{167} +\glossaryentry{stmt.while@ {\memgloterm{stmt.while}}{\memglodesc{(\ref {stmt.while})}} {\memgloref{}}|memjustarg}{167} +\glossaryentry{stmt.do@ {\memgloterm{stmt.do}}{\memglodesc{(\ref {stmt.do})}} {\memgloref{}}|memjustarg}{168} +\glossaryentry{stmt.for@ {\memgloterm{stmt.for}}{\memglodesc{(\ref {stmt.for})}} {\memgloref{}}|memjustarg}{168} +\glossaryentry{stmt.ranged@ {\memgloterm{stmt.ranged}}{\memglodesc{(\ref {stmt.ranged})}} {\memgloref{}}|memjustarg}{168} +\glossaryentry{stmt.jump@ {\memgloterm{stmt.jump}}{\memglodesc{(\ref {stmt.jump})}} {\memgloref{}}|memjustarg}{169} +\glossaryentry{stmt.jump.general@ {\memgloterm{stmt.jump.general}}{\memglodesc{(\ref {stmt.jump.general})}} {\memgloref{}}|memjustarg}{169} +\glossaryentry{stmt.break@ {\memgloterm{stmt.break}}{\memglodesc{(\ref {stmt.break})}} {\memgloref{}}|memjustarg}{169} +\glossaryentry{stmt.cont@ {\memgloterm{stmt.cont}}{\memglodesc{(\ref {stmt.cont})}} {\memgloref{}}|memjustarg}{169} +\glossaryentry{stmt.return@ {\memgloterm{stmt.return}}{\memglodesc{(\ref {stmt.return})}} {\memgloref{}}|memjustarg}{170} +\glossaryentry{stmt.return.coroutine@ {\memgloterm{stmt.return.coroutine}}{\memglodesc{(\ref {stmt.return.coroutine})}} {\memgloref{}}|memjustarg}{170} +\glossaryentry{stmt.goto@ {\memgloterm{stmt.goto}}{\memglodesc{(\ref {stmt.goto})}} {\memgloref{}}|memjustarg}{171} +\glossaryentry{stmt.dcl@ {\memgloterm{stmt.dcl}}{\memglodesc{(\ref {stmt.dcl})}} {\memgloref{}}|memjustarg}{171} +\glossaryentry{stmt.ambig@ {\memgloterm{stmt.ambig}}{\memglodesc{(\ref {stmt.ambig})}} {\memgloref{}}|memjustarg}{172} +\glossaryentry{dcl.dcl@ {\memgloterm{dcl.dcl}}{\memglodesc{(\ref {dcl.dcl})}} {\memgloref{}}|memjustarg}{173} +\glossaryentry{dcl.pre@ {\memgloterm{dcl.pre}}{\memglodesc{(\ref {dcl.pre})}} {\memgloref{}}|memjustarg}{173} +\glossaryentry{dcl.spec@ {\memgloterm{dcl.spec}}{\memglodesc{(\ref {dcl.spec})}} {\memgloref{}}|memjustarg}{175} +\glossaryentry{dcl.spec.general@ {\memgloterm{dcl.spec.general}}{\memglodesc{(\ref {dcl.spec.general})}} {\memgloref{}}|memjustarg}{175} +\glossaryentry{dcl.stc@ {\memgloterm{dcl.stc}}{\memglodesc{(\ref {dcl.stc})}} {\memgloref{}}|memjustarg}{176} +\glossaryentry{dcl.fct.spec@ {\memgloterm{dcl.fct.spec}}{\memglodesc{(\ref {dcl.fct.spec})}} {\memgloref{}}|memjustarg}{178} +\glossaryentry{dcl.typedef@ {\memgloterm{dcl.typedef}}{\memglodesc{(\ref {dcl.typedef})}} {\memgloref{}}|memjustarg}{178} +\glossaryentry{dcl.friend@ {\memgloterm{dcl.friend}}{\memglodesc{(\ref {dcl.friend})}} {\memgloref{}}|memjustarg}{179} +\glossaryentry{dcl.constexpr@ {\memgloterm{dcl.constexpr}}{\memglodesc{(\ref {dcl.constexpr})}} {\memgloref{}}|memjustarg}{179} +\glossaryentry{dcl.constinit@ {\memgloterm{dcl.constinit}}{\memglodesc{(\ref {dcl.constinit})}} {\memgloref{}}|memjustarg}{181} +\glossaryentry{dcl.inline@ {\memgloterm{dcl.inline}}{\memglodesc{(\ref {dcl.inline})}} {\memgloref{}}|memjustarg}{181} +\glossaryentry{dcl.type@ {\memgloterm{dcl.type}}{\memglodesc{(\ref {dcl.type})}} {\memgloref{}}|memjustarg}{182} +\glossaryentry{dcl.type.general@ {\memgloterm{dcl.type.general}}{\memglodesc{(\ref {dcl.type.general})}} {\memgloref{}}|memjustarg}{182} +\glossaryentry{dcl.type.cv@ {\memgloterm{dcl.type.cv}}{\memglodesc{(\ref {dcl.type.cv})}} {\memgloref{}}|memjustarg}{183} +\glossaryentry{dcl.type.simple@ {\memgloterm{dcl.type.simple}}{\memglodesc{(\ref {dcl.type.simple})}} {\memgloref{}}|memjustarg}{184} +\glossaryentry{dcl.type.elab@ {\memgloterm{dcl.type.elab}}{\memglodesc{(\ref {dcl.type.elab})}} {\memgloref{}}|memjustarg}{184} +\glossaryentry{dcl.type.decltype@ {\memgloterm{dcl.type.decltype}}{\memglodesc{(\ref {dcl.type.decltype})}} {\memgloref{}}|memjustarg}{186} +\glossaryentry{dcl.spec.auto@ {\memgloterm{dcl.spec.auto}}{\memglodesc{(\ref {dcl.spec.auto})}} {\memgloref{}}|memjustarg}{187} +\glossaryentry{dcl.spec.auto.general@ {\memgloterm{dcl.spec.auto.general}}{\memglodesc{(\ref {dcl.spec.auto.general})}} {\memgloref{}}|memjustarg}{187} +\glossaryentry{dcl.type.auto.deduct@ {\memgloterm{dcl.type.auto.deduct}}{\memglodesc{(\ref {dcl.type.auto.deduct})}} {\memgloref{}}|memjustarg}{190} +\glossaryentry{dcl.type.class.deduct@ {\memgloterm{dcl.type.class.deduct}}{\memglodesc{(\ref {dcl.type.class.deduct})}} {\memgloref{}}|memjustarg}{191} +\glossaryentry{dcl.decl@ {\memgloterm{dcl.decl}}{\memglodesc{(\ref {dcl.decl})}} {\memgloref{}}|memjustarg}{192} +\glossaryentry{dcl.decl.general@ {\memgloterm{dcl.decl.general}}{\memglodesc{(\ref {dcl.decl.general})}} {\memgloref{}}|memjustarg}{192} +\glossaryentry{dcl.name@ {\memgloterm{dcl.name}}{\memglodesc{(\ref {dcl.name})}} {\memgloref{}}|memjustarg}{193} +\glossaryentry{dcl.ambig.res@ {\memgloterm{dcl.ambig.res}}{\memglodesc{(\ref {dcl.ambig.res})}} {\memgloref{}}|memjustarg}{194} +\glossaryentry{dcl.meaning@ {\memgloterm{dcl.meaning}}{\memglodesc{(\ref {dcl.meaning})}} {\memgloref{}}|memjustarg}{195} +\glossaryentry{dcl.meaning.general@ {\memgloterm{dcl.meaning.general}}{\memglodesc{(\ref {dcl.meaning.general})}} {\memgloref{}}|memjustarg}{195} +\glossaryentry{dcl.ptr@ {\memgloterm{dcl.ptr}}{\memglodesc{(\ref {dcl.ptr})}} {\memgloref{}}|memjustarg}{197} +\glossaryentry{dcl.ref@ {\memgloterm{dcl.ref}}{\memglodesc{(\ref {dcl.ref})}} {\memgloref{}}|memjustarg}{198} +\glossaryentry{dcl.mptr@ {\memgloterm{dcl.mptr}}{\memglodesc{(\ref {dcl.mptr})}} {\memgloref{}}|memjustarg}{199} +\glossaryentry{dcl.array@ {\memgloterm{dcl.array}}{\memglodesc{(\ref {dcl.array})}} {\memgloref{}}|memjustarg}{200} +\glossaryentry{dcl.fct@ {\memgloterm{dcl.fct}}{\memglodesc{(\ref {dcl.fct})}} {\memgloref{}}|memjustarg}{201} +\glossaryentry{dcl.fct.default@ {\memgloterm{dcl.fct.default}}{\memglodesc{(\ref {dcl.fct.default})}} {\memgloref{}}|memjustarg}{206} +\glossaryentry{dcl.init@ {\memgloterm{dcl.init}}{\memglodesc{(\ref {dcl.init})}} {\memgloref{}}|memjustarg}{209} +\glossaryentry{dcl.init.general@ {\memgloterm{dcl.init.general}}{\memglodesc{(\ref {dcl.init.general})}} {\memgloref{}}|memjustarg}{209} +\glossaryentry{dcl.init.aggr@ {\memgloterm{dcl.init.aggr}}{\memglodesc{(\ref {dcl.init.aggr})}} {\memgloref{}}|memjustarg}{213} +\glossaryentry{dcl.init.string@ {\memgloterm{dcl.init.string}}{\memglodesc{(\ref {dcl.init.string})}} {\memgloref{}}|memjustarg}{217} +\glossaryentry{dcl.init.ref@ {\memgloterm{dcl.init.ref}}{\memglodesc{(\ref {dcl.init.ref})}} {\memgloref{}}|memjustarg}{218} +\glossaryentry{dcl.init.list@ {\memgloterm{dcl.init.list}}{\memglodesc{(\ref {dcl.init.list})}} {\memgloref{}}|memjustarg}{220} +\glossaryentry{dcl.fct.def@ {\memgloterm{dcl.fct.def}}{\memglodesc{(\ref {dcl.fct.def})}} {\memgloref{}}|memjustarg}{225} +\glossaryentry{dcl.fct.def.general@ {\memgloterm{dcl.fct.def.general}}{\memglodesc{(\ref {dcl.fct.def.general})}} {\memgloref{}}|memjustarg}{225} +\glossaryentry{dcl.fct.def.default@ {\memgloterm{dcl.fct.def.default}}{\memglodesc{(\ref {dcl.fct.def.default})}} {\memgloref{}}|memjustarg}{226} +\glossaryentry{dcl.fct.def.delete@ {\memgloterm{dcl.fct.def.delete}}{\memglodesc{(\ref {dcl.fct.def.delete})}} {\memgloref{}}|memjustarg}{227} +\glossaryentry{dcl.fct.def.coroutine@ {\memgloterm{dcl.fct.def.coroutine}}{\memglodesc{(\ref {dcl.fct.def.coroutine})}} {\memgloref{}}|memjustarg}{228} +\glossaryentry{dcl.struct.bind@ {\memgloterm{dcl.struct.bind}}{\memglodesc{(\ref {dcl.struct.bind})}} {\memgloref{}}|memjustarg}{231} +\glossaryentry{enum@ {\memgloterm{enum}}{\memglodesc{(\ref {enum})}} {\memgloref{}}|memjustarg}{232} +\glossaryentry{dcl.enum@ {\memgloterm{dcl.enum}}{\memglodesc{(\ref {dcl.enum})}} {\memgloref{}}|memjustarg}{232} +\glossaryentry{enum.udecl@ {\memgloterm{enum.udecl}}{\memglodesc{(\ref {enum.udecl})}} {\memgloref{}}|memjustarg}{235} +\glossaryentry{basic.namespace@ {\memgloterm{basic.namespace}}{\memglodesc{(\ref {basic.namespace})}} {\memgloref{}}|memjustarg}{235} +\glossaryentry{basic.namespace.general@ {\memgloterm{basic.namespace.general}}{\memglodesc{(\ref {basic.namespace.general})}} {\memgloref{}}|memjustarg}{235} +\glossaryentry{namespace.def@ {\memgloterm{namespace.def}}{\memglodesc{(\ref {namespace.def})}} {\memgloref{}}|memjustarg}{236} +\glossaryentry{namespace.def.general@ {\memgloterm{namespace.def.general}}{\memglodesc{(\ref {namespace.def.general})}} {\memgloref{}}|memjustarg}{236} +\glossaryentry{namespace.unnamed@ {\memgloterm{namespace.unnamed}}{\memglodesc{(\ref {namespace.unnamed})}} {\memgloref{}}|memjustarg}{237} +\glossaryentry{namespace.alias@ {\memgloterm{namespace.alias}}{\memglodesc{(\ref {namespace.alias})}} {\memgloref{}}|memjustarg}{238} +\glossaryentry{namespace.udir@ {\memgloterm{namespace.udir}}{\memglodesc{(\ref {namespace.udir})}} {\memgloref{}}|memjustarg}{238} +\glossaryentry{namespace.udecl@ {\memgloterm{namespace.udecl}}{\memglodesc{(\ref {namespace.udecl})}} {\memgloref{}}|memjustarg}{240} +\glossaryentry{dcl.asm@ {\memgloterm{dcl.asm}}{\memglodesc{(\ref {dcl.asm})}} {\memgloref{}}|memjustarg}{245} +\glossaryentry{dcl.link@ {\memgloterm{dcl.link}}{\memglodesc{(\ref {dcl.link})}} {\memgloref{}}|memjustarg}{245} +\glossaryentry{dcl.attr@ {\memgloterm{dcl.attr}}{\memglodesc{(\ref {dcl.attr})}} {\memgloref{}}|memjustarg}{247} +\glossaryentry{dcl.attr.grammar@ {\memgloterm{dcl.attr.grammar}}{\memglodesc{(\ref {dcl.attr.grammar})}} {\memgloref{}}|memjustarg}{247} +\glossaryentry{dcl.align@ {\memgloterm{dcl.align}}{\memglodesc{(\ref {dcl.align})}} {\memgloref{}}|memjustarg}{249} +\glossaryentry{dcl.attr.assume@ {\memgloterm{dcl.attr.assume}}{\memglodesc{(\ref {dcl.attr.assume})}} {\memgloref{}}|memjustarg}{250} +\glossaryentry{dcl.attr.depend@ {\memgloterm{dcl.attr.depend}}{\memglodesc{(\ref {dcl.attr.depend})}} {\memgloref{}}|memjustarg}{250} +\glossaryentry{dcl.attr.deprecated@ {\memgloterm{dcl.attr.deprecated}}{\memglodesc{(\ref {dcl.attr.deprecated})}} {\memgloref{}}|memjustarg}{251} +\glossaryentry{dcl.attr.fallthrough@ {\memgloterm{dcl.attr.fallthrough}}{\memglodesc{(\ref {dcl.attr.fallthrough})}} {\memgloref{}}|memjustarg}{251} +\glossaryentry{dcl.attr.likelihood@ {\memgloterm{dcl.attr.likelihood}}{\memglodesc{(\ref {dcl.attr.likelihood})}} {\memgloref{}}|memjustarg}{252} +\glossaryentry{dcl.attr.unused@ {\memgloterm{dcl.attr.unused}}{\memglodesc{(\ref {dcl.attr.unused})}} {\memgloref{}}|memjustarg}{253} +\glossaryentry{dcl.attr.nodiscard@ {\memgloterm{dcl.attr.nodiscard}}{\memglodesc{(\ref {dcl.attr.nodiscard})}} {\memgloref{}}|memjustarg}{253} +\glossaryentry{dcl.attr.noreturn@ {\memgloterm{dcl.attr.noreturn}}{\memglodesc{(\ref {dcl.attr.noreturn})}} {\memgloref{}}|memjustarg}{254} +\glossaryentry{dcl.attr.nouniqueaddr@ {\memgloterm{dcl.attr.nouniqueaddr}}{\memglodesc{(\ref {dcl.attr.nouniqueaddr})}} {\memgloref{}}|memjustarg}{254} +\glossaryentry{module@ {\memgloterm{module}}{\memglodesc{(\ref {module})}} {\memgloref{}}|memjustarg}{256} +\glossaryentry{module.unit@ {\memgloterm{module.unit}}{\memglodesc{(\ref {module.unit})}} {\memgloref{}}|memjustarg}{256} +\glossaryentry{module.interface@ {\memgloterm{module.interface}}{\memglodesc{(\ref {module.interface})}} {\memgloref{}}|memjustarg}{257} +\glossaryentry{module.import@ {\memgloterm{module.import}}{\memglodesc{(\ref {module.import})}} {\memgloref{}}|memjustarg}{260} +\glossaryentry{module.global.frag@ {\memgloterm{module.global.frag}}{\memglodesc{(\ref {module.global.frag})}} {\memgloref{}}|memjustarg}{261} +\glossaryentry{module.private.frag@ {\memgloterm{module.private.frag}}{\memglodesc{(\ref {module.private.frag})}} {\memgloref{}}|memjustarg}{263} +\glossaryentry{module.context@ {\memgloterm{module.context}}{\memglodesc{(\ref {module.context})}} {\memgloref{}}|memjustarg}{264} +\glossaryentry{module.reach@ {\memgloterm{module.reach}}{\memglodesc{(\ref {module.reach})}} {\memgloref{}}|memjustarg}{265} +\glossaryentry{class@ {\memgloterm{class}}{\memglodesc{(\ref {class})}} {\memgloref{}}|memjustarg}{267} +\glossaryentry{class.pre@ {\memgloterm{class.pre}}{\memglodesc{(\ref {class.pre})}} {\memgloref{}}|memjustarg}{267} +\glossaryentry{class.prop@ {\memgloterm{class.prop}}{\memglodesc{(\ref {class.prop})}} {\memgloref{}}|memjustarg}{268} +\glossaryentry{class.name@ {\memgloterm{class.name}}{\memglodesc{(\ref {class.name})}} {\memgloref{}}|memjustarg}{269} +\glossaryentry{class.mem@ {\memgloterm{class.mem}}{\memglodesc{(\ref {class.mem})}} {\memgloref{}}|memjustarg}{271} +\glossaryentry{class.mem.general@ {\memgloterm{class.mem.general}}{\memglodesc{(\ref {class.mem.general})}} {\memgloref{}}|memjustarg}{271} +\glossaryentry{class.mfct@ {\memgloterm{class.mfct}}{\memglodesc{(\ref {class.mfct})}} {\memgloref{}}|memjustarg}{274} +\glossaryentry{class.mfct.non.static@ {\memgloterm{class.mfct.non.static}}{\memglodesc{(\ref {class.mfct.non.static})}} {\memgloref{}}|memjustarg}{275} +\glossaryentry{special@ {\memgloterm{special}}{\memglodesc{(\ref {special})}} {\memgloref{}}|memjustarg}{276} +\glossaryentry{class.ctor@ {\memgloterm{class.ctor}}{\memglodesc{(\ref {class.ctor})}} {\memgloref{}}|memjustarg}{277} +\glossaryentry{class.ctor.general@ {\memgloterm{class.ctor.general}}{\memglodesc{(\ref {class.ctor.general})}} {\memgloref{}}|memjustarg}{277} +\glossaryentry{class.default.ctor@ {\memgloterm{class.default.ctor}}{\memglodesc{(\ref {class.default.ctor})}} {\memgloref{}}|memjustarg}{277} +\glossaryentry{class.copy.ctor@ {\memgloterm{class.copy.ctor}}{\memglodesc{(\ref {class.copy.ctor})}} {\memgloref{}}|memjustarg}{278} +\glossaryentry{class.copy.assign@ {\memgloterm{class.copy.assign}}{\memglodesc{(\ref {class.copy.assign})}} {\memgloref{}}|memjustarg}{281} +\glossaryentry{class.dtor@ {\memgloterm{class.dtor}}{\memglodesc{(\ref {class.dtor})}} {\memgloref{}}|memjustarg}{283} +\glossaryentry{class.conv@ {\memgloterm{class.conv}}{\memglodesc{(\ref {class.conv})}} {\memgloref{}}|memjustarg}{286} +\glossaryentry{class.conv.general@ {\memgloterm{class.conv.general}}{\memglodesc{(\ref {class.conv.general})}} {\memgloref{}}|memjustarg}{286} +\glossaryentry{class.conv.ctor@ {\memgloterm{class.conv.ctor}}{\memglodesc{(\ref {class.conv.ctor})}} {\memgloref{}}|memjustarg}{286} +\glossaryentry{class.conv.fct@ {\memgloterm{class.conv.fct}}{\memglodesc{(\ref {class.conv.fct})}} {\memgloref{}}|memjustarg}{287} +\glossaryentry{class.static@ {\memgloterm{class.static}}{\memglodesc{(\ref {class.static})}} {\memgloref{}}|memjustarg}{289} +\glossaryentry{class.static.general@ {\memgloterm{class.static.general}}{\memglodesc{(\ref {class.static.general})}} {\memgloref{}}|memjustarg}{289} +\glossaryentry{class.static.mfct@ {\memgloterm{class.static.mfct}}{\memglodesc{(\ref {class.static.mfct})}} {\memgloref{}}|memjustarg}{289} +\glossaryentry{class.static.data@ {\memgloterm{class.static.data}}{\memglodesc{(\ref {class.static.data})}} {\memgloref{}}|memjustarg}{289} +\glossaryentry{class.bit@ {\memgloterm{class.bit}}{\memglodesc{(\ref {class.bit})}} {\memgloref{}}|memjustarg}{290} +\glossaryentry{class.free@ {\memgloterm{class.free}}{\memglodesc{(\ref {class.free})}} {\memgloref{}}|memjustarg}{291} +\glossaryentry{class.nest@ {\memgloterm{class.nest}}{\memglodesc{(\ref {class.nest})}} {\memgloref{}}|memjustarg}{292} +\glossaryentry{class.union@ {\memgloterm{class.union}}{\memglodesc{(\ref {class.union})}} {\memgloref{}}|memjustarg}{293} +\glossaryentry{class.union.general@ {\memgloterm{class.union.general}}{\memglodesc{(\ref {class.union.general})}} {\memgloref{}}|memjustarg}{293} +\glossaryentry{class.union.anon@ {\memgloterm{class.union.anon}}{\memglodesc{(\ref {class.union.anon})}} {\memgloref{}}|memjustarg}{294} +\glossaryentry{class.local@ {\memgloterm{class.local}}{\memglodesc{(\ref {class.local})}} {\memgloref{}}|memjustarg}{295} +\glossaryentry{class.derived@ {\memgloterm{class.derived}}{\memglodesc{(\ref {class.derived})}} {\memgloref{}}|memjustarg}{296} +\glossaryentry{class.derived.general@ {\memgloterm{class.derived.general}}{\memglodesc{(\ref {class.derived.general})}} {\memgloref{}}|memjustarg}{296} +\glossaryentry{class.mi@ {\memgloterm{class.mi}}{\memglodesc{(\ref {class.mi})}} {\memgloref{}}|memjustarg}{297} +\glossaryentry{class.virtual@ {\memgloterm{class.virtual}}{\memglodesc{(\ref {class.virtual})}} {\memgloref{}}|memjustarg}{299} +\glossaryentry{class.abstract@ {\memgloterm{class.abstract}}{\memglodesc{(\ref {class.abstract})}} {\memgloref{}}|memjustarg}{303} +\glossaryentry{class.access@ {\memgloterm{class.access}}{\memglodesc{(\ref {class.access})}} {\memgloref{}}|memjustarg}{304} +\glossaryentry{class.access.general@ {\memgloterm{class.access.general}}{\memglodesc{(\ref {class.access.general})}} {\memgloref{}}|memjustarg}{304} +\glossaryentry{class.access.spec@ {\memgloterm{class.access.spec}}{\memglodesc{(\ref {class.access.spec})}} {\memgloref{}}|memjustarg}{306} +\glossaryentry{class.access.base@ {\memgloterm{class.access.base}}{\memglodesc{(\ref {class.access.base})}} {\memgloref{}}|memjustarg}{307} +\glossaryentry{class.friend@ {\memgloterm{class.friend}}{\memglodesc{(\ref {class.friend})}} {\memgloref{}}|memjustarg}{309} +\glossaryentry{class.protected@ {\memgloterm{class.protected}}{\memglodesc{(\ref {class.protected})}} {\memgloref{}}|memjustarg}{312} +\glossaryentry{class.access.virt@ {\memgloterm{class.access.virt}}{\memglodesc{(\ref {class.access.virt})}} {\memgloref{}}|memjustarg}{313} +\glossaryentry{class.paths@ {\memgloterm{class.paths}}{\memglodesc{(\ref {class.paths})}} {\memgloref{}}|memjustarg}{313} +\glossaryentry{class.access.nest@ {\memgloterm{class.access.nest}}{\memglodesc{(\ref {class.access.nest})}} {\memgloref{}}|memjustarg}{313} +\glossaryentry{class.init@ {\memgloterm{class.init}}{\memglodesc{(\ref {class.init})}} {\memgloref{}}|memjustarg}{314} +\glossaryentry{class.init.general@ {\memgloterm{class.init.general}}{\memglodesc{(\ref {class.init.general})}} {\memgloref{}}|memjustarg}{314} +\glossaryentry{class.expl.init@ {\memgloterm{class.expl.init}}{\memglodesc{(\ref {class.expl.init})}} {\memgloref{}}|memjustarg}{314} +\glossaryentry{class.base.init@ {\memgloterm{class.base.init}}{\memglodesc{(\ref {class.base.init})}} {\memgloref{}}|memjustarg}{315} +\glossaryentry{class.inhctor.init@ {\memgloterm{class.inhctor.init}}{\memglodesc{(\ref {class.inhctor.init})}} {\memgloref{}}|memjustarg}{319} +\glossaryentry{class.cdtor@ {\memgloterm{class.cdtor}}{\memglodesc{(\ref {class.cdtor})}} {\memgloref{}}|memjustarg}{320} +\glossaryentry{class.copy.elision@ {\memgloterm{class.copy.elision}}{\memglodesc{(\ref {class.copy.elision})}} {\memgloref{}}|memjustarg}{323} +\glossaryentry{class.compare@ {\memgloterm{class.compare}}{\memglodesc{(\ref {class.compare})}} {\memgloref{}}|memjustarg}{325} +\glossaryentry{class.compare.default@ {\memgloterm{class.compare.default}}{\memglodesc{(\ref {class.compare.default})}} {\memgloref{}}|memjustarg}{325} +\glossaryentry{class.eq@ {\memgloterm{class.eq}}{\memglodesc{(\ref {class.eq})}} {\memgloref{}}|memjustarg}{326} +\glossaryentry{class.spaceship@ {\memgloterm{class.spaceship}}{\memglodesc{(\ref {class.spaceship})}} {\memgloref{}}|memjustarg}{327} +\glossaryentry{class.compare.secondary@ {\memgloterm{class.compare.secondary}}{\memglodesc{(\ref {class.compare.secondary})}} {\memgloref{}}|memjustarg}{327} +\glossaryentry{over@ {\memgloterm{over}}{\memglodesc{(\ref {over})}} {\memgloref{}}|memjustarg}{329} +\glossaryentry{over.pre@ {\memgloterm{over.pre}}{\memglodesc{(\ref {over.pre})}} {\memgloref{}}|memjustarg}{329} +\glossaryentry{over.match@ {\memgloterm{over.match}}{\memglodesc{(\ref {over.match})}} {\memgloref{}}|memjustarg}{329} +\glossaryentry{over.match.general@ {\memgloterm{over.match.general}}{\memglodesc{(\ref {over.match.general})}} {\memgloref{}}|memjustarg}{329} +\glossaryentry{over.match.funcs@ {\memgloterm{over.match.funcs}}{\memglodesc{(\ref {over.match.funcs})}} {\memgloref{}}|memjustarg}{330} +\glossaryentry{over.match.funcs.general@ {\memgloterm{over.match.funcs.general}}{\memglodesc{(\ref {over.match.funcs.general})}} {\memgloref{}}|memjustarg}{330} +\glossaryentry{over.match.call@ {\memgloterm{over.match.call}}{\memglodesc{(\ref {over.match.call})}} {\memgloref{}}|memjustarg}{331} +\glossaryentry{over.match.call.general@ {\memgloterm{over.match.call.general}}{\memglodesc{(\ref {over.match.call.general})}} {\memgloref{}}|memjustarg}{331} +\glossaryentry{over.call.func@ {\memgloterm{over.call.func}}{\memglodesc{(\ref {over.call.func})}} {\memgloref{}}|memjustarg}{332} +\glossaryentry{over.call.object@ {\memgloterm{over.call.object}}{\memglodesc{(\ref {over.call.object})}} {\memgloref{}}|memjustarg}{333} +\glossaryentry{over.match.oper@ {\memgloterm{over.match.oper}}{\memglodesc{(\ref {over.match.oper})}} {\memgloref{}}|memjustarg}{334} +\glossaryentry{over.match.ctor@ {\memgloterm{over.match.ctor}}{\memglodesc{(\ref {over.match.ctor})}} {\memgloref{}}|memjustarg}{337} +\glossaryentry{over.match.copy@ {\memgloterm{over.match.copy}}{\memglodesc{(\ref {over.match.copy})}} {\memgloref{}}|memjustarg}{337} +\glossaryentry{over.match.conv@ {\memgloterm{over.match.conv}}{\memglodesc{(\ref {over.match.conv})}} {\memgloref{}}|memjustarg}{337} +\glossaryentry{over.match.ref@ {\memgloterm{over.match.ref}}{\memglodesc{(\ref {over.match.ref})}} {\memgloref{}}|memjustarg}{338} +\glossaryentry{over.match.list@ {\memgloterm{over.match.list}}{\memglodesc{(\ref {over.match.list})}} {\memgloref{}}|memjustarg}{338} +\glossaryentry{over.match.class.deduct@ {\memgloterm{over.match.class.deduct}}{\memglodesc{(\ref {over.match.class.deduct})}} {\memgloref{}}|memjustarg}{338} +\glossaryentry{over.match.viable@ {\memgloterm{over.match.viable}}{\memglodesc{(\ref {over.match.viable})}} {\memgloref{}}|memjustarg}{343} +\glossaryentry{over.match.best@ {\memgloterm{over.match.best}}{\memglodesc{(\ref {over.match.best})}} {\memgloref{}}|memjustarg}{343} +\glossaryentry{over.match.best.general@ {\memgloterm{over.match.best.general}}{\memglodesc{(\ref {over.match.best.general})}} {\memgloref{}}|memjustarg}{343} +\glossaryentry{over.best.ics@ {\memgloterm{over.best.ics}}{\memglodesc{(\ref {over.best.ics})}} {\memgloref{}}|memjustarg}{346} +\glossaryentry{over.best.ics.general@ {\memgloterm{over.best.ics.general}}{\memglodesc{(\ref {over.best.ics.general})}} {\memgloref{}}|memjustarg}{346} +\glossaryentry{over.ics.scs@ {\memgloterm{over.ics.scs}}{\memglodesc{(\ref {over.ics.scs})}} {\memgloref{}}|memjustarg}{348} +\glossaryentry{over.ics.user@ {\memgloterm{over.ics.user}}{\memglodesc{(\ref {over.ics.user})}} {\memgloref{}}|memjustarg}{348} +\glossaryentry{over.ics.ellipsis@ {\memgloterm{over.ics.ellipsis}}{\memglodesc{(\ref {over.ics.ellipsis})}} {\memgloref{}}|memjustarg}{349} +\glossaryentry{over.ics.ref@ {\memgloterm{over.ics.ref}}{\memglodesc{(\ref {over.ics.ref})}} {\memgloref{}}|memjustarg}{349} +\glossaryentry{over.ics.list@ {\memgloterm{over.ics.list}}{\memglodesc{(\ref {over.ics.list})}} {\memgloref{}}|memjustarg}{349} +\glossaryentry{over.ics.rank@ {\memgloterm{over.ics.rank}}{\memglodesc{(\ref {over.ics.rank})}} {\memgloref{}}|memjustarg}{352} +\glossaryentry{over.over@ {\memgloterm{over.over}}{\memglodesc{(\ref {over.over})}} {\memgloref{}}|memjustarg}{355} +\glossaryentry{over.oper@ {\memgloterm{over.oper}}{\memglodesc{(\ref {over.oper})}} {\memgloref{}}|memjustarg}{356} +\glossaryentry{over.oper.general@ {\memgloterm{over.oper.general}}{\memglodesc{(\ref {over.oper.general})}} {\memgloref{}}|memjustarg}{356} +\glossaryentry{over.unary@ {\memgloterm{over.unary}}{\memglodesc{(\ref {over.unary})}} {\memgloref{}}|memjustarg}{358} +\glossaryentry{over.binary@ {\memgloterm{over.binary}}{\memglodesc{(\ref {over.binary})}} {\memgloref{}}|memjustarg}{358} +\glossaryentry{over.binary.general@ {\memgloterm{over.binary.general}}{\memglodesc{(\ref {over.binary.general})}} {\memgloref{}}|memjustarg}{358} +\glossaryentry{over.ass@ {\memgloterm{over.ass}}{\memglodesc{(\ref {over.ass})}} {\memgloref{}}|memjustarg}{358} +\glossaryentry{over.call@ {\memgloterm{over.call}}{\memglodesc{(\ref {over.call})}} {\memgloref{}}|memjustarg}{359} +\glossaryentry{over.sub@ {\memgloterm{over.sub}}{\memglodesc{(\ref {over.sub})}} {\memgloref{}}|memjustarg}{359} +\glossaryentry{over.ref@ {\memgloterm{over.ref}}{\memglodesc{(\ref {over.ref})}} {\memgloref{}}|memjustarg}{359} +\glossaryentry{over.inc@ {\memgloterm{over.inc}}{\memglodesc{(\ref {over.inc})}} {\memgloref{}}|memjustarg}{359} +\glossaryentry{over.built@ {\memgloterm{over.built}}{\memglodesc{(\ref {over.built})}} {\memgloref{}}|memjustarg}{360} +\glossaryentry{over.literal@ {\memgloterm{over.literal}}{\memglodesc{(\ref {over.literal})}} {\memgloref{}}|memjustarg}{362} +\glossaryentry{temp@ {\memgloterm{temp}}{\memglodesc{(\ref {temp})}} {\memgloref{}}|memjustarg}{364} +\glossaryentry{temp.pre@ {\memgloterm{temp.pre}}{\memglodesc{(\ref {temp.pre})}} {\memgloref{}}|memjustarg}{364} +\glossaryentry{temp.param@ {\memgloterm{temp.param}}{\memglodesc{(\ref {temp.param})}} {\memgloref{}}|memjustarg}{365} +\glossaryentry{temp.names@ {\memgloterm{temp.names}}{\memglodesc{(\ref {temp.names})}} {\memgloref{}}|memjustarg}{369} +\glossaryentry{temp.arg@ {\memgloterm{temp.arg}}{\memglodesc{(\ref {temp.arg})}} {\memgloref{}}|memjustarg}{372} +\glossaryentry{temp.arg.general@ {\memgloterm{temp.arg.general}}{\memglodesc{(\ref {temp.arg.general})}} {\memgloref{}}|memjustarg}{372} +\glossaryentry{temp.arg.type@ {\memgloterm{temp.arg.type}}{\memglodesc{(\ref {temp.arg.type})}} {\memgloref{}}|memjustarg}{374} +\glossaryentry{temp.arg.nontype@ {\memgloterm{temp.arg.nontype}}{\memglodesc{(\ref {temp.arg.nontype})}} {\memgloref{}}|memjustarg}{374} +\glossaryentry{temp.arg.template@ {\memgloterm{temp.arg.template}}{\memglodesc{(\ref {temp.arg.template})}} {\memgloref{}}|memjustarg}{376} +\glossaryentry{temp.constr@ {\memgloterm{temp.constr}}{\memglodesc{(\ref {temp.constr})}} {\memgloref{}}|memjustarg}{377} +\glossaryentry{temp.constr.general@ {\memgloterm{temp.constr.general}}{\memglodesc{(\ref {temp.constr.general})}} {\memgloref{}}|memjustarg}{377} +\glossaryentry{temp.constr.constr@ {\memgloterm{temp.constr.constr}}{\memglodesc{(\ref {temp.constr.constr})}} {\memgloref{}}|memjustarg}{377} +\glossaryentry{temp.constr.constr.general@ {\memgloterm{temp.constr.constr.general}}{\memglodesc{(\ref {temp.constr.constr.general})}} {\memgloref{}}|memjustarg}{377} +\glossaryentry{temp.constr.op@ {\memgloterm{temp.constr.op}}{\memglodesc{(\ref {temp.constr.op})}} {\memgloref{}}|memjustarg}{378} +\glossaryentry{temp.constr.atomic@ {\memgloterm{temp.constr.atomic}}{\memglodesc{(\ref {temp.constr.atomic})}} {\memgloref{}}|memjustarg}{379} +\glossaryentry{temp.constr.decl@ {\memgloterm{temp.constr.decl}}{\memglodesc{(\ref {temp.constr.decl})}} {\memgloref{}}|memjustarg}{380} +\glossaryentry{temp.constr.normal@ {\memgloterm{temp.constr.normal}}{\memglodesc{(\ref {temp.constr.normal})}} {\memgloref{}}|memjustarg}{381} +\glossaryentry{temp.constr.order@ {\memgloterm{temp.constr.order}}{\memglodesc{(\ref {temp.constr.order})}} {\memgloref{}}|memjustarg}{382} +\glossaryentry{temp.type@ {\memgloterm{temp.type}}{\memglodesc{(\ref {temp.type})}} {\memgloref{}}|memjustarg}{382} +\glossaryentry{temp.decls@ {\memgloterm{temp.decls}}{\memglodesc{(\ref {temp.decls})}} {\memgloref{}}|memjustarg}{383} +\glossaryentry{temp.decls.general@ {\memgloterm{temp.decls.general}}{\memglodesc{(\ref {temp.decls.general})}} {\memgloref{}}|memjustarg}{383} +\glossaryentry{temp.class@ {\memgloterm{temp.class}}{\memglodesc{(\ref {temp.class})}} {\memgloref{}}|memjustarg}{384} +\glossaryentry{temp.class.general@ {\memgloterm{temp.class.general}}{\memglodesc{(\ref {temp.class.general})}} {\memgloref{}}|memjustarg}{384} +\glossaryentry{temp.mem.func@ {\memgloterm{temp.mem.func}}{\memglodesc{(\ref {temp.mem.func})}} {\memgloref{}}|memjustarg}{385} +\glossaryentry{temp.deduct.guide@ {\memgloterm{temp.deduct.guide}}{\memglodesc{(\ref {temp.deduct.guide})}} {\memgloref{}}|memjustarg}{385} +\glossaryentry{temp.mem.class@ {\memgloterm{temp.mem.class}}{\memglodesc{(\ref {temp.mem.class})}} {\memgloref{}}|memjustarg}{386} +\glossaryentry{temp.static@ {\memgloterm{temp.static}}{\memglodesc{(\ref {temp.static})}} {\memgloref{}}|memjustarg}{386} +\glossaryentry{temp.mem.enum@ {\memgloterm{temp.mem.enum}}{\memglodesc{(\ref {temp.mem.enum})}} {\memgloref{}}|memjustarg}{387} +\glossaryentry{temp.mem@ {\memgloterm{temp.mem}}{\memglodesc{(\ref {temp.mem})}} {\memgloref{}}|memjustarg}{387} +\glossaryentry{temp.variadic@ {\memgloterm{temp.variadic}}{\memglodesc{(\ref {temp.variadic})}} {\memgloref{}}|memjustarg}{388} +\glossaryentry{temp.friend@ {\memgloterm{temp.friend}}{\memglodesc{(\ref {temp.friend})}} {\memgloref{}}|memjustarg}{391} +\glossaryentry{temp.spec.partial@ {\memgloterm{temp.spec.partial}}{\memglodesc{(\ref {temp.spec.partial})}} {\memgloref{}}|memjustarg}{393} +\glossaryentry{temp.spec.partial.general@ {\memgloterm{temp.spec.partial.general}}{\memglodesc{(\ref {temp.spec.partial.general})}} {\memgloref{}}|memjustarg}{393} +\glossaryentry{temp.spec.partial.match@ {\memgloterm{temp.spec.partial.match}}{\memglodesc{(\ref {temp.spec.partial.match})}} {\memgloref{}}|memjustarg}{395} +\glossaryentry{temp.spec.partial.order@ {\memgloterm{temp.spec.partial.order}}{\memglodesc{(\ref {temp.spec.partial.order})}} {\memgloref{}}|memjustarg}{396} +\glossaryentry{temp.spec.partial.member@ {\memgloterm{temp.spec.partial.member}}{\memglodesc{(\ref {temp.spec.partial.member})}} {\memgloref{}}|memjustarg}{396} +\glossaryentry{temp.fct@ {\memgloterm{temp.fct}}{\memglodesc{(\ref {temp.fct})}} {\memgloref{}}|memjustarg}{397} +\glossaryentry{temp.fct.general@ {\memgloterm{temp.fct.general}}{\memglodesc{(\ref {temp.fct.general})}} {\memgloref{}}|memjustarg}{397} +\glossaryentry{temp.over.link@ {\memgloterm{temp.over.link}}{\memglodesc{(\ref {temp.over.link})}} {\memgloref{}}|memjustarg}{398} +\glossaryentry{temp.func.order@ {\memgloterm{temp.func.order}}{\memglodesc{(\ref {temp.func.order})}} {\memgloref{}}|memjustarg}{400} +\glossaryentry{temp.alias@ {\memgloterm{temp.alias}}{\memglodesc{(\ref {temp.alias})}} {\memgloref{}}|memjustarg}{403} +\glossaryentry{temp.concept@ {\memgloterm{temp.concept}}{\memglodesc{(\ref {temp.concept})}} {\memgloref{}}|memjustarg}{404} +\glossaryentry{temp.res@ {\memgloterm{temp.res}}{\memglodesc{(\ref {temp.res})}} {\memgloref{}}|memjustarg}{404} +\glossaryentry{temp.res.general@ {\memgloterm{temp.res.general}}{\memglodesc{(\ref {temp.res.general})}} {\memgloref{}}|memjustarg}{404} +\glossaryentry{temp.local@ {\memgloterm{temp.local}}{\memglodesc{(\ref {temp.local})}} {\memgloref{}}|memjustarg}{408} +\glossaryentry{temp.dep@ {\memgloterm{temp.dep}}{\memglodesc{(\ref {temp.dep})}} {\memgloref{}}|memjustarg}{410} +\glossaryentry{temp.dep.general@ {\memgloterm{temp.dep.general}}{\memglodesc{(\ref {temp.dep.general})}} {\memgloref{}}|memjustarg}{410} +\glossaryentry{temp.dep.type@ {\memgloterm{temp.dep.type}}{\memglodesc{(\ref {temp.dep.type})}} {\memgloref{}}|memjustarg}{410} +\glossaryentry{temp.dep.expr@ {\memgloterm{temp.dep.expr}}{\memglodesc{(\ref {temp.dep.expr})}} {\memgloref{}}|memjustarg}{413} +\glossaryentry{temp.dep.constexpr@ {\memgloterm{temp.dep.constexpr}}{\memglodesc{(\ref {temp.dep.constexpr})}} {\memgloref{}}|memjustarg}{414} +\glossaryentry{temp.dep.temp@ {\memgloterm{temp.dep.temp}}{\memglodesc{(\ref {temp.dep.temp})}} {\memgloref{}}|memjustarg}{415} +\glossaryentry{temp.dep.res@ {\memgloterm{temp.dep.res}}{\memglodesc{(\ref {temp.dep.res})}} {\memgloref{}}|memjustarg}{415} +\glossaryentry{temp.point@ {\memgloterm{temp.point}}{\memglodesc{(\ref {temp.point})}} {\memgloref{}}|memjustarg}{415} +\glossaryentry{temp.dep.candidate@ {\memgloterm{temp.dep.candidate}}{\memglodesc{(\ref {temp.dep.candidate})}} {\memgloref{}}|memjustarg}{416} +\glossaryentry{temp.spec@ {\memgloterm{temp.spec}}{\memglodesc{(\ref {temp.spec})}} {\memgloref{}}|memjustarg}{418} +\glossaryentry{temp.spec.general@ {\memgloterm{temp.spec.general}}{\memglodesc{(\ref {temp.spec.general})}} {\memgloref{}}|memjustarg}{418} +\glossaryentry{temp.inst@ {\memgloterm{temp.inst}}{\memglodesc{(\ref {temp.inst})}} {\memgloref{}}|memjustarg}{420} +\glossaryentry{temp.explicit@ {\memgloterm{temp.explicit}}{\memglodesc{(\ref {temp.explicit})}} {\memgloref{}}|memjustarg}{424} +\glossaryentry{temp.expl.spec@ {\memgloterm{temp.expl.spec}}{\memglodesc{(\ref {temp.expl.spec})}} {\memgloref{}}|memjustarg}{426} +\glossaryentry{temp.fct.spec@ {\memgloterm{temp.fct.spec}}{\memglodesc{(\ref {temp.fct.spec})}} {\memgloref{}}|memjustarg}{431} +\glossaryentry{temp.fct.spec.general@ {\memgloterm{temp.fct.spec.general}}{\memglodesc{(\ref {temp.fct.spec.general})}} {\memgloref{}}|memjustarg}{431} +\glossaryentry{temp.arg.explicit@ {\memgloterm{temp.arg.explicit}}{\memglodesc{(\ref {temp.arg.explicit})}} {\memgloref{}}|memjustarg}{431} +\glossaryentry{temp.deduct@ {\memgloterm{temp.deduct}}{\memglodesc{(\ref {temp.deduct})}} {\memgloref{}}|memjustarg}{433} +\glossaryentry{temp.deduct.general@ {\memgloterm{temp.deduct.general}}{\memglodesc{(\ref {temp.deduct.general})}} {\memgloref{}}|memjustarg}{433} +\glossaryentry{temp.deduct.call@ {\memgloterm{temp.deduct.call}}{\memglodesc{(\ref {temp.deduct.call})}} {\memgloref{}}|memjustarg}{437} +\glossaryentry{temp.deduct.funcaddr@ {\memgloterm{temp.deduct.funcaddr}}{\memglodesc{(\ref {temp.deduct.funcaddr})}} {\memgloref{}}|memjustarg}{440} +\glossaryentry{temp.deduct.conv@ {\memgloterm{temp.deduct.conv}}{\memglodesc{(\ref {temp.deduct.conv})}} {\memgloref{}}|memjustarg}{441} +\glossaryentry{temp.deduct.partial@ {\memgloterm{temp.deduct.partial}}{\memglodesc{(\ref {temp.deduct.partial})}} {\memgloref{}}|memjustarg}{441} +\glossaryentry{temp.deduct.type@ {\memgloterm{temp.deduct.type}}{\memglodesc{(\ref {temp.deduct.type})}} {\memgloref{}}|memjustarg}{443} +\glossaryentry{temp.deduct.decl@ {\memgloterm{temp.deduct.decl}}{\memglodesc{(\ref {temp.deduct.decl})}} {\memgloref{}}|memjustarg}{449} +\glossaryentry{temp.over@ {\memgloterm{temp.over}}{\memglodesc{(\ref {temp.over})}} {\memgloref{}}|memjustarg}{449} +\glossaryentry{except@ {\memgloterm{except}}{\memglodesc{(\ref {except})}} {\memgloref{}}|memjustarg}{452} +\glossaryentry{except.pre@ {\memgloterm{except.pre}}{\memglodesc{(\ref {except.pre})}} {\memgloref{}}|memjustarg}{452} +\glossaryentry{except.throw@ {\memgloterm{except.throw}}{\memglodesc{(\ref {except.throw})}} {\memgloref{}}|memjustarg}{453} +\glossaryentry{except.ctor@ {\memgloterm{except.ctor}}{\memglodesc{(\ref {except.ctor})}} {\memgloref{}}|memjustarg}{454} +\glossaryentry{except.handle@ {\memgloterm{except.handle}}{\memglodesc{(\ref {except.handle})}} {\memgloref{}}|memjustarg}{455} +\glossaryentry{except.spec@ {\memgloterm{except.spec}}{\memglodesc{(\ref {except.spec})}} {\memgloref{}}|memjustarg}{457} +\glossaryentry{except.special@ {\memgloterm{except.special}}{\memglodesc{(\ref {except.special})}} {\memgloref{}}|memjustarg}{459} +\glossaryentry{except.special.general@ {\memgloterm{except.special.general}}{\memglodesc{(\ref {except.special.general})}} {\memgloref{}}|memjustarg}{459} +\glossaryentry{except.terminate@ {\memgloterm{except.terminate}}{\memglodesc{(\ref {except.terminate})}} {\memgloref{}}|memjustarg}{459} +\glossaryentry{except.uncaught@ {\memgloterm{except.uncaught}}{\memglodesc{(\ref {except.uncaught})}} {\memgloref{}}|memjustarg}{460} +\glossaryentry{cpp@ {\memgloterm{cpp}}{\memglodesc{(\ref {cpp})}} {\memgloref{}}|memjustarg}{461} +\glossaryentry{cpp.pre@ {\memgloterm{cpp.pre}}{\memglodesc{(\ref {cpp.pre})}} {\memgloref{}}|memjustarg}{461} +\glossaryentry{cpp.cond@ {\memgloterm{cpp.cond}}{\memglodesc{(\ref {cpp.cond})}} {\memgloref{}}|memjustarg}{463} +\glossaryentry{cpp.include@ {\memgloterm{cpp.include}}{\memglodesc{(\ref {cpp.include})}} {\memgloref{}}|memjustarg}{465} +\glossaryentry{cpp.module@ {\memgloterm{cpp.module}}{\memglodesc{(\ref {cpp.module})}} {\memgloref{}}|memjustarg}{466} +\glossaryentry{cpp.import@ {\memgloterm{cpp.import}}{\memglodesc{(\ref {cpp.import})}} {\memgloref{}}|memjustarg}{467} +\glossaryentry{cpp.replace@ {\memgloterm{cpp.replace}}{\memglodesc{(\ref {cpp.replace})}} {\memgloref{}}|memjustarg}{468} +\glossaryentry{cpp.replace.general@ {\memgloterm{cpp.replace.general}}{\memglodesc{(\ref {cpp.replace.general})}} {\memgloref{}}|memjustarg}{468} +\glossaryentry{cpp.subst@ {\memgloterm{cpp.subst}}{\memglodesc{(\ref {cpp.subst})}} {\memgloref{}}|memjustarg}{470} +\glossaryentry{cpp.stringize@ {\memgloterm{cpp.stringize}}{\memglodesc{(\ref {cpp.stringize})}} {\memgloref{}}|memjustarg}{471} +\glossaryentry{cpp.concat@ {\memgloterm{cpp.concat}}{\memglodesc{(\ref {cpp.concat})}} {\memgloref{}}|memjustarg}{471} +\glossaryentry{cpp.rescan@ {\memgloterm{cpp.rescan}}{\memglodesc{(\ref {cpp.rescan})}} {\memgloref{}}|memjustarg}{473} +\glossaryentry{cpp.scope@ {\memgloterm{cpp.scope}}{\memglodesc{(\ref {cpp.scope})}} {\memgloref{}}|memjustarg}{473} +\glossaryentry{cpp.line@ {\memgloterm{cpp.line}}{\memglodesc{(\ref {cpp.line})}} {\memgloref{}}|memjustarg}{473} +\glossaryentry{cpp.error@ {\memgloterm{cpp.error}}{\memglodesc{(\ref {cpp.error})}} {\memgloref{}}|memjustarg}{474} +\glossaryentry{cpp.pragma@ {\memgloterm{cpp.pragma}}{\memglodesc{(\ref {cpp.pragma})}} {\memgloref{}}|memjustarg}{474} +\glossaryentry{cpp.null@ {\memgloterm{cpp.null}}{\memglodesc{(\ref {cpp.null})}} {\memgloref{}}|memjustarg}{474} +\glossaryentry{cpp.predefined@ {\memgloterm{cpp.predefined}}{\memglodesc{(\ref {cpp.predefined})}} {\memgloref{}}|memjustarg}{474} +\glossaryentry{cpp.pragma.op@ {\memgloterm{cpp.pragma.op}}{\memglodesc{(\ref {cpp.pragma.op})}} {\memgloref{}}|memjustarg}{477} +\glossaryentry{library@ {\memgloterm{library}}{\memglodesc{(\ref {library})}} {\memgloref{}}|memjustarg}{478} +\glossaryentry{library.general@ {\memgloterm{library.general}}{\memglodesc{(\ref {library.general})}} {\memgloref{}}|memjustarg}{478} +\glossaryentry{library.c@ {\memgloterm{library.c}}{\memglodesc{(\ref {library.c})}} {\memgloref{}}|memjustarg}{479} +\glossaryentry{description@ {\memgloterm{description}}{\memglodesc{(\ref {description})}} {\memgloref{}}|memjustarg}{479} +\glossaryentry{description.general@ {\memgloterm{description.general}}{\memglodesc{(\ref {description.general})}} {\memgloref{}}|memjustarg}{479} +\glossaryentry{structure@ {\memgloterm{structure}}{\memglodesc{(\ref {structure})}} {\memgloref{}}|memjustarg}{479} +\glossaryentry{structure.elements@ {\memgloterm{structure.elements}}{\memglodesc{(\ref {structure.elements})}} {\memgloref{}}|memjustarg}{479} +\glossaryentry{structure.summary@ {\memgloterm{structure.summary}}{\memglodesc{(\ref {structure.summary})}} {\memgloref{}}|memjustarg}{479} +\glossaryentry{structure.requirements@ {\memgloterm{structure.requirements}}{\memglodesc{(\ref {structure.requirements})}} {\memgloref{}}|memjustarg}{480} +\glossaryentry{structure.specifications@ {\memgloterm{structure.specifications}}{\memglodesc{(\ref {structure.specifications})}} {\memgloref{}}|memjustarg}{480} +\glossaryentry{structure.see.also@ {\memgloterm{structure.see.also}}{\memglodesc{(\ref {structure.see.also})}} {\memgloref{}}|memjustarg}{482} +\glossaryentry{conventions@ {\memgloterm{conventions}}{\memglodesc{(\ref {conventions})}} {\memgloref{}}|memjustarg}{482} +\glossaryentry{conventions.general@ {\memgloterm{conventions.general}}{\memglodesc{(\ref {conventions.general})}} {\memgloref{}}|memjustarg}{482} +\glossaryentry{expos.only.entity@ {\memgloterm{expos.only.entity}}{\memglodesc{(\ref {expos.only.entity})}} {\memgloref{}}|memjustarg}{482} +\glossaryentry{type.descriptions@ {\memgloterm{type.descriptions}}{\memglodesc{(\ref {type.descriptions})}} {\memgloref{}}|memjustarg}{482} +\glossaryentry{type.descriptions.general@ {\memgloterm{type.descriptions.general}}{\memglodesc{(\ref {type.descriptions.general})}} {\memgloref{}}|memjustarg}{482} +\glossaryentry{enumerated.types@ {\memgloterm{enumerated.types}}{\memglodesc{(\ref {enumerated.types})}} {\memgloref{}}|memjustarg}{483} +\glossaryentry{bitmask.types@ {\memgloterm{bitmask.types}}{\memglodesc{(\ref {bitmask.types})}} {\memgloref{}}|memjustarg}{483} +\glossaryentry{character.seq@ {\memgloterm{character.seq}}{\memglodesc{(\ref {character.seq})}} {\memgloref{}}|memjustarg}{484} +\glossaryentry{character.seq.general@ {\memgloterm{character.seq.general}}{\memglodesc{(\ref {character.seq.general})}} {\memgloref{}}|memjustarg}{484} +\glossaryentry{byte.strings@ {\memgloterm{byte.strings}}{\memglodesc{(\ref {byte.strings})}} {\memgloref{}}|memjustarg}{484} +\glossaryentry{multibyte.strings@ {\memgloterm{multibyte.strings}}{\memglodesc{(\ref {multibyte.strings})}} {\memgloref{}}|memjustarg}{484} +\glossaryentry{customization.point.object@ {\memgloterm{customization.point.object}}{\memglodesc{(\ref {customization.point.object})}} {\memgloref{}}|memjustarg}{485} +\glossaryentry{functions.within.classes@ {\memgloterm{functions.within.classes}}{\memglodesc{(\ref {functions.within.classes})}} {\memgloref{}}|memjustarg}{485} +\glossaryentry{objects.within.classes@ {\memgloterm{objects.within.classes}}{\memglodesc{(\ref {objects.within.classes})}} {\memgloref{}}|memjustarg}{485} +\glossaryentry{freestanding.item@ {\memgloterm{freestanding.item}}{\memglodesc{(\ref {freestanding.item})}} {\memgloref{}}|memjustarg}{485} +\glossaryentry{requirements@ {\memgloterm{requirements}}{\memglodesc{(\ref {requirements})}} {\memgloref{}}|memjustarg}{486} +\glossaryentry{requirements.general@ {\memgloterm{requirements.general}}{\memglodesc{(\ref {requirements.general})}} {\memgloref{}}|memjustarg}{486} +\glossaryentry{organization@ {\memgloterm{organization}}{\memglodesc{(\ref {organization})}} {\memgloref{}}|memjustarg}{486} +\glossaryentry{organization.general@ {\memgloterm{organization.general}}{\memglodesc{(\ref {organization.general})}} {\memgloref{}}|memjustarg}{486} +\glossaryentry{contents@ {\memgloterm{contents}}{\memglodesc{(\ref {contents})}} {\memgloref{}}|memjustarg}{486} +\glossaryentry{headers@ {\memgloterm{headers}}{\memglodesc{(\ref {headers})}} {\memgloref{}}|memjustarg}{487} +\glossaryentry{std.modules@ {\memgloterm{std.modules}}{\memglodesc{(\ref {std.modules})}} {\memgloref{}}|memjustarg}{488} +\glossaryentry{compliance@ {\memgloterm{compliance}}{\memglodesc{(\ref {compliance})}} {\memgloref{}}|memjustarg}{489} +\glossaryentry{using@ {\memgloterm{using}}{\memglodesc{(\ref {using})}} {\memgloref{}}|memjustarg}{489} +\glossaryentry{using.overview@ {\memgloterm{using.overview}}{\memglodesc{(\ref {using.overview})}} {\memgloref{}}|memjustarg}{489} +\glossaryentry{using.headers@ {\memgloterm{using.headers}}{\memglodesc{(\ref {using.headers})}} {\memgloref{}}|memjustarg}{489} +\glossaryentry{using.linkage@ {\memgloterm{using.linkage}}{\memglodesc{(\ref {using.linkage})}} {\memgloref{}}|memjustarg}{490} +\glossaryentry{utility.requirements@ {\memgloterm{utility.requirements}}{\memglodesc{(\ref {utility.requirements})}} {\memgloref{}}|memjustarg}{490} +\glossaryentry{utility.requirements.general@ {\memgloterm{utility.requirements.general}}{\memglodesc{(\ref {utility.requirements.general})}} {\memgloref{}}|memjustarg}{490} +\glossaryentry{utility.arg.requirements@ {\memgloterm{utility.arg.requirements}}{\memglodesc{(\ref {utility.arg.requirements})}} {\memgloref{}}|memjustarg}{490} +\glossaryentry{swappable.requirements@ {\memgloterm{swappable.requirements}}{\memglodesc{(\ref {swappable.requirements})}} {\memgloref{}}|memjustarg}{492} +\glossaryentry{nullablepointer.requirements@ {\memgloterm{nullablepointer.requirements}}{\memglodesc{(\ref {nullablepointer.requirements})}} {\memgloref{}}|memjustarg}{493} +\glossaryentry{hash.requirements@ {\memgloterm{hash.requirements}}{\memglodesc{(\ref {hash.requirements})}} {\memgloref{}}|memjustarg}{493} +\glossaryentry{allocator.requirements@ {\memgloterm{allocator.requirements}}{\memglodesc{(\ref {allocator.requirements})}} {\memgloref{}}|memjustarg}{494} +\glossaryentry{allocator.requirements.general@ {\memgloterm{allocator.requirements.general}}{\memglodesc{(\ref {allocator.requirements.general})}} {\memgloref{}}|memjustarg}{494} +\glossaryentry{allocator.requirements.completeness@ {\memgloterm{allocator.requirements.completeness}}{\memglodesc{(\ref {allocator.requirements.completeness})}} {\memgloref{}}|memjustarg}{499} +\glossaryentry{constraints@ {\memgloterm{constraints}}{\memglodesc{(\ref {constraints})}} {\memgloref{}}|memjustarg}{499} +\glossaryentry{constraints.overview@ {\memgloterm{constraints.overview}}{\memglodesc{(\ref {constraints.overview})}} {\memgloref{}}|memjustarg}{499} +\glossaryentry{namespace.constraints@ {\memgloterm{namespace.constraints}}{\memglodesc{(\ref {namespace.constraints})}} {\memgloref{}}|memjustarg}{499} +\glossaryentry{namespace.std@ {\memgloterm{namespace.std}}{\memglodesc{(\ref {namespace.std})}} {\memgloref{}}|memjustarg}{499} +\glossaryentry{namespace.posix@ {\memgloterm{namespace.posix}}{\memglodesc{(\ref {namespace.posix})}} {\memgloref{}}|memjustarg}{500} +\glossaryentry{namespace.future@ {\memgloterm{namespace.future}}{\memglodesc{(\ref {namespace.future})}} {\memgloref{}}|memjustarg}{500} +\glossaryentry{reserved.names@ {\memgloterm{reserved.names}}{\memglodesc{(\ref {reserved.names})}} {\memgloref{}}|memjustarg}{500} +\glossaryentry{reserved.names.general@ {\memgloterm{reserved.names.general}}{\memglodesc{(\ref {reserved.names.general})}} {\memgloref{}}|memjustarg}{500} +\glossaryentry{zombie.names@ {\memgloterm{zombie.names}}{\memglodesc{(\ref {zombie.names})}} {\memgloref{}}|memjustarg}{501} +\glossaryentry{macro.names@ {\memgloterm{macro.names}}{\memglodesc{(\ref {macro.names})}} {\memgloref{}}|memjustarg}{502} +\glossaryentry{extern.names@ {\memgloterm{extern.names}}{\memglodesc{(\ref {extern.names})}} {\memgloref{}}|memjustarg}{502} +\glossaryentry{extern.types@ {\memgloterm{extern.types}}{\memglodesc{(\ref {extern.types})}} {\memgloref{}}|memjustarg}{502} +\glossaryentry{usrlit.suffix@ {\memgloterm{usrlit.suffix}}{\memglodesc{(\ref {usrlit.suffix})}} {\memgloref{}}|memjustarg}{502} +\glossaryentry{alt.headers@ {\memgloterm{alt.headers}}{\memglodesc{(\ref {alt.headers})}} {\memgloref{}}|memjustarg}{502} +\glossaryentry{derived.classes@ {\memgloterm{derived.classes}}{\memglodesc{(\ref {derived.classes})}} {\memgloref{}}|memjustarg}{503} +\glossaryentry{replacement.functions@ {\memgloterm{replacement.functions}}{\memglodesc{(\ref {replacement.functions})}} {\memgloref{}}|memjustarg}{503} +\glossaryentry{handler.functions@ {\memgloterm{handler.functions}}{\memglodesc{(\ref {handler.functions})}} {\memgloref{}}|memjustarg}{503} +\glossaryentry{res.on.functions@ {\memgloterm{res.on.functions}}{\memglodesc{(\ref {res.on.functions})}} {\memgloref{}}|memjustarg}{503} +\glossaryentry{res.on.arguments@ {\memgloterm{res.on.arguments}}{\memglodesc{(\ref {res.on.arguments})}} {\memgloref{}}|memjustarg}{504} +\glossaryentry{res.on.objects@ {\memgloterm{res.on.objects}}{\memglodesc{(\ref {res.on.objects})}} {\memgloref{}}|memjustarg}{504} +\glossaryentry{res.on.requirements@ {\memgloterm{res.on.requirements}}{\memglodesc{(\ref {res.on.requirements})}} {\memgloref{}}|memjustarg}{504} +\glossaryentry{conforming@ {\memgloterm{conforming}}{\memglodesc{(\ref {conforming})}} {\memgloref{}}|memjustarg}{504} +\glossaryentry{conforming.overview@ {\memgloterm{conforming.overview}}{\memglodesc{(\ref {conforming.overview})}} {\memgloref{}}|memjustarg}{504} +\glossaryentry{res.on.headers@ {\memgloterm{res.on.headers}}{\memglodesc{(\ref {res.on.headers})}} {\memgloref{}}|memjustarg}{505} +\glossaryentry{res.on.macro.definitions@ {\memgloterm{res.on.macro.definitions}}{\memglodesc{(\ref {res.on.macro.definitions})}} {\memgloref{}}|memjustarg}{505} +\glossaryentry{global.functions@ {\memgloterm{global.functions}}{\memglodesc{(\ref {global.functions})}} {\memgloref{}}|memjustarg}{505} +\glossaryentry{member.functions@ {\memgloterm{member.functions}}{\memglodesc{(\ref {member.functions})}} {\memgloref{}}|memjustarg}{505} +\glossaryentry{hidden.friends@ {\memgloterm{hidden.friends}}{\memglodesc{(\ref {hidden.friends})}} {\memgloref{}}|memjustarg}{505} +\glossaryentry{constexpr.functions@ {\memgloterm{constexpr.functions}}{\memglodesc{(\ref {constexpr.functions})}} {\memgloref{}}|memjustarg}{506} +\glossaryentry{algorithm.stable@ {\memgloterm{algorithm.stable}}{\memglodesc{(\ref {algorithm.stable})}} {\memgloref{}}|memjustarg}{506} +\glossaryentry{reentrancy@ {\memgloterm{reentrancy}}{\memglodesc{(\ref {reentrancy})}} {\memgloref{}}|memjustarg}{506} +\glossaryentry{res.on.data.races@ {\memgloterm{res.on.data.races}}{\memglodesc{(\ref {res.on.data.races})}} {\memgloref{}}|memjustarg}{506} +\glossaryentry{protection.within.classes@ {\memgloterm{protection.within.classes}}{\memglodesc{(\ref {protection.within.classes})}} {\memgloref{}}|memjustarg}{506} +\glossaryentry{derivation@ {\memgloterm{derivation}}{\memglodesc{(\ref {derivation})}} {\memgloref{}}|memjustarg}{506} +\glossaryentry{res.on.exception.handling@ {\memgloterm{res.on.exception.handling}}{\memglodesc{(\ref {res.on.exception.handling})}} {\memgloref{}}|memjustarg}{507} +\glossaryentry{value.error.codes@ {\memgloterm{value.error.codes}}{\memglodesc{(\ref {value.error.codes})}} {\memgloref{}}|memjustarg}{507} +\glossaryentry{lib.types.movedfrom@ {\memgloterm{lib.types.movedfrom}}{\memglodesc{(\ref {lib.types.movedfrom})}} {\memgloref{}}|memjustarg}{507} +\glossaryentry{support@ {\memgloterm{support}}{\memglodesc{(\ref {support})}} {\memgloref{}}|memjustarg}{508} +\glossaryentry{support.general@ {\memgloterm{support.general}}{\memglodesc{(\ref {support.general})}} {\memgloref{}}|memjustarg}{508} +\glossaryentry{support.types@ {\memgloterm{support.types}}{\memglodesc{(\ref {support.types})}} {\memgloref{}}|memjustarg}{508} +\glossaryentry{cstddef.syn@ {\memgloterm{cstddef.syn}}{\memglodesc{(\ref {cstddef.syn})}} {\memgloref{}}|memjustarg}{508} +\glossaryentry{cstdlib.syn@ {\memgloterm{cstdlib.syn}}{\memglodesc{(\ref {cstdlib.syn})}} {\memgloref{}}|memjustarg}{509} +\glossaryentry{support.types.nullptr@ {\memgloterm{support.types.nullptr}}{\memglodesc{(\ref {support.types.nullptr})}} {\memgloref{}}|memjustarg}{510} +\glossaryentry{support.types.layout@ {\memgloterm{support.types.layout}}{\memglodesc{(\ref {support.types.layout})}} {\memgloref{}}|memjustarg}{510} +\glossaryentry{support.types.byteops@ {\memgloterm{support.types.byteops}}{\memglodesc{(\ref {support.types.byteops})}} {\memgloref{}}|memjustarg}{511} +\glossaryentry{support.limits@ {\memgloterm{support.limits}}{\memglodesc{(\ref {support.limits})}} {\memgloref{}}|memjustarg}{512} +\glossaryentry{support.limits.general@ {\memgloterm{support.limits.general}}{\memglodesc{(\ref {support.limits.general})}} {\memgloref{}}|memjustarg}{512} +\glossaryentry{version.syn@ {\memgloterm{version.syn}}{\memglodesc{(\ref {version.syn})}} {\memgloref{}}|memjustarg}{512} +\glossaryentry{limits.syn@ {\memgloterm{limits.syn}}{\memglodesc{(\ref {limits.syn})}} {\memgloref{}}|memjustarg}{515} +\glossaryentry{round.style@ {\memgloterm{round.style}}{\memglodesc{(\ref {round.style})}} {\memgloref{}}|memjustarg}{516} +\glossaryentry{numeric.limits@ {\memgloterm{numeric.limits}}{\memglodesc{(\ref {numeric.limits})}} {\memgloref{}}|memjustarg}{516} +\glossaryentry{numeric.limits.general@ {\memgloterm{numeric.limits.general}}{\memglodesc{(\ref {numeric.limits.general})}} {\memgloref{}}|memjustarg}{516} +\glossaryentry{numeric.limits.members@ {\memgloterm{numeric.limits.members}}{\memglodesc{(\ref {numeric.limits.members})}} {\memgloref{}}|memjustarg}{517} +\glossaryentry{numeric.special@ {\memgloterm{numeric.special}}{\memglodesc{(\ref {numeric.special})}} {\memgloref{}}|memjustarg}{520} +\glossaryentry{climits.syn@ {\memgloterm{climits.syn}}{\memglodesc{(\ref {climits.syn})}} {\memgloref{}}|memjustarg}{522} +\glossaryentry{cfloat.syn@ {\memgloterm{cfloat.syn}}{\memglodesc{(\ref {cfloat.syn})}} {\memgloref{}}|memjustarg}{522} +\glossaryentry{support.arith.types@ {\memgloterm{support.arith.types}}{\memglodesc{(\ref {support.arith.types})}} {\memgloref{}}|memjustarg}{523} +\glossaryentry{cstdint.syn@ {\memgloterm{cstdint.syn}}{\memglodesc{(\ref {cstdint.syn})}} {\memgloref{}}|memjustarg}{523} +\glossaryentry{stdfloat.syn@ {\memgloterm{stdfloat.syn}}{\memglodesc{(\ref {stdfloat.syn})}} {\memgloref{}}|memjustarg}{524} +\glossaryentry{support.start.term@ {\memgloterm{support.start.term}}{\memglodesc{(\ref {support.start.term})}} {\memgloref{}}|memjustarg}{525} +\glossaryentry{support.dynamic@ {\memgloterm{support.dynamic}}{\memglodesc{(\ref {support.dynamic})}} {\memgloref{}}|memjustarg}{526} +\glossaryentry{support.dynamic.general@ {\memgloterm{support.dynamic.general}}{\memglodesc{(\ref {support.dynamic.general})}} {\memgloref{}}|memjustarg}{526} +\glossaryentry{new.syn@ {\memgloterm{new.syn}}{\memglodesc{(\ref {new.syn})}} {\memgloref{}}|memjustarg}{526} +\glossaryentry{new.delete@ {\memgloterm{new.delete}}{\memglodesc{(\ref {new.delete})}} {\memgloref{}}|memjustarg}{527} +\glossaryentry{new.delete.general@ {\memgloterm{new.delete.general}}{\memglodesc{(\ref {new.delete.general})}} {\memgloref{}}|memjustarg}{527} +\glossaryentry{new.delete.single@ {\memgloterm{new.delete.single}}{\memglodesc{(\ref {new.delete.single})}} {\memgloref{}}|memjustarg}{527} +\glossaryentry{new.delete.array@ {\memgloterm{new.delete.array}}{\memglodesc{(\ref {new.delete.array})}} {\memgloref{}}|memjustarg}{529} +\glossaryentry{new.delete.placement@ {\memgloterm{new.delete.placement}}{\memglodesc{(\ref {new.delete.placement})}} {\memgloref{}}|memjustarg}{530} +\glossaryentry{new.delete.dataraces@ {\memgloterm{new.delete.dataraces}}{\memglodesc{(\ref {new.delete.dataraces})}} {\memgloref{}}|memjustarg}{531} +\glossaryentry{alloc.errors@ {\memgloterm{alloc.errors}}{\memglodesc{(\ref {alloc.errors})}} {\memgloref{}}|memjustarg}{531} +\glossaryentry{bad.alloc@ {\memgloterm{bad.alloc}}{\memglodesc{(\ref {bad.alloc})}} {\memgloref{}}|memjustarg}{531} +\glossaryentry{new.badlength@ {\memgloterm{new.badlength}}{\memglodesc{(\ref {new.badlength})}} {\memgloref{}}|memjustarg}{531} +\glossaryentry{new.handler@ {\memgloterm{new.handler}}{\memglodesc{(\ref {new.handler})}} {\memgloref{}}|memjustarg}{531} +\glossaryentry{set.new.handler@ {\memgloterm{set.new.handler}}{\memglodesc{(\ref {set.new.handler})}} {\memgloref{}}|memjustarg}{532} +\glossaryentry{get.new.handler@ {\memgloterm{get.new.handler}}{\memglodesc{(\ref {get.new.handler})}} {\memgloref{}}|memjustarg}{532} +\glossaryentry{ptr.launder@ {\memgloterm{ptr.launder}}{\memglodesc{(\ref {ptr.launder})}} {\memgloref{}}|memjustarg}{532} +\glossaryentry{hardware.interference@ {\memgloterm{hardware.interference}}{\memglodesc{(\ref {hardware.interference})}} {\memgloref{}}|memjustarg}{532} +\glossaryentry{support.rtti@ {\memgloterm{support.rtti}}{\memglodesc{(\ref {support.rtti})}} {\memgloref{}}|memjustarg}{533} +\glossaryentry{support.rtti.general@ {\memgloterm{support.rtti.general}}{\memglodesc{(\ref {support.rtti.general})}} {\memgloref{}}|memjustarg}{533} +\glossaryentry{typeinfo.syn@ {\memgloterm{typeinfo.syn}}{\memglodesc{(\ref {typeinfo.syn})}} {\memgloref{}}|memjustarg}{533} +\glossaryentry{type.info@ {\memgloterm{type.info}}{\memglodesc{(\ref {type.info})}} {\memgloref{}}|memjustarg}{533} +\glossaryentry{bad.cast@ {\memgloterm{bad.cast}}{\memglodesc{(\ref {bad.cast})}} {\memgloref{}}|memjustarg}{534} +\glossaryentry{bad.typeid@ {\memgloterm{bad.typeid}}{\memglodesc{(\ref {bad.typeid})}} {\memgloref{}}|memjustarg}{534} +\glossaryentry{support.srcloc@ {\memgloterm{support.srcloc}}{\memglodesc{(\ref {support.srcloc})}} {\memgloref{}}|memjustarg}{534} +\glossaryentry{source.location.syn@ {\memgloterm{source.location.syn}}{\memglodesc{(\ref {source.location.syn})}} {\memgloref{}}|memjustarg}{534} +\glossaryentry{support.srcloc.class@ {\memgloterm{support.srcloc.class}}{\memglodesc{(\ref {support.srcloc.class})}} {\memgloref{}}|memjustarg}{534} +\glossaryentry{support.srcloc.class.general@ {\memgloterm{support.srcloc.class.general}}{\memglodesc{(\ref {support.srcloc.class.general})}} {\memgloref{}}|memjustarg}{534} +\glossaryentry{support.srcloc.cons@ {\memgloterm{support.srcloc.cons}}{\memglodesc{(\ref {support.srcloc.cons})}} {\memgloref{}}|memjustarg}{535} +\glossaryentry{support.srcloc.obs@ {\memgloterm{support.srcloc.obs}}{\memglodesc{(\ref {support.srcloc.obs})}} {\memgloref{}}|memjustarg}{536} +\glossaryentry{support.exception@ {\memgloterm{support.exception}}{\memglodesc{(\ref {support.exception})}} {\memgloref{}}|memjustarg}{536} +\glossaryentry{support.exception.general@ {\memgloterm{support.exception.general}}{\memglodesc{(\ref {support.exception.general})}} {\memgloref{}}|memjustarg}{536} +\glossaryentry{exception.syn@ {\memgloterm{exception.syn}}{\memglodesc{(\ref {exception.syn})}} {\memgloref{}}|memjustarg}{537} +\glossaryentry{exception@ {\memgloterm{exception}}{\memglodesc{(\ref {exception})}} {\memgloref{}}|memjustarg}{537} +\glossaryentry{bad.exception@ {\memgloterm{bad.exception}}{\memglodesc{(\ref {bad.exception})}} {\memgloref{}}|memjustarg}{538} +\glossaryentry{exception.terminate@ {\memgloterm{exception.terminate}}{\memglodesc{(\ref {exception.terminate})}} {\memgloref{}}|memjustarg}{538} +\glossaryentry{terminate.handler@ {\memgloterm{terminate.handler}}{\memglodesc{(\ref {terminate.handler})}} {\memgloref{}}|memjustarg}{538} +\glossaryentry{set.terminate@ {\memgloterm{set.terminate}}{\memglodesc{(\ref {set.terminate})}} {\memgloref{}}|memjustarg}{538} +\glossaryentry{get.terminate@ {\memgloterm{get.terminate}}{\memglodesc{(\ref {get.terminate})}} {\memgloref{}}|memjustarg}{538} +\glossaryentry{terminate@ {\memgloterm{terminate}}{\memglodesc{(\ref {terminate})}} {\memgloref{}}|memjustarg}{538} +\glossaryentry{uncaught.exceptions@ {\memgloterm{uncaught.exceptions}}{\memglodesc{(\ref {uncaught.exceptions})}} {\memgloref{}}|memjustarg}{538} +\glossaryentry{propagation@ {\memgloterm{propagation}}{\memglodesc{(\ref {propagation})}} {\memgloref{}}|memjustarg}{539} +\glossaryentry{except.nested@ {\memgloterm{except.nested}}{\memglodesc{(\ref {except.nested})}} {\memgloref{}}|memjustarg}{539} +\glossaryentry{support.initlist@ {\memgloterm{support.initlist}}{\memglodesc{(\ref {support.initlist})}} {\memgloref{}}|memjustarg}{540} +\glossaryentry{support.initlist.general@ {\memgloterm{support.initlist.general}}{\memglodesc{(\ref {support.initlist.general})}} {\memgloref{}}|memjustarg}{540} +\glossaryentry{initializer.list.syn@ {\memgloterm{initializer.list.syn}}{\memglodesc{(\ref {initializer.list.syn})}} {\memgloref{}}|memjustarg}{540} +\glossaryentry{support.initlist.cons@ {\memgloterm{support.initlist.cons}}{\memglodesc{(\ref {support.initlist.cons})}} {\memgloref{}}|memjustarg}{541} +\glossaryentry{support.initlist.access@ {\memgloterm{support.initlist.access}}{\memglodesc{(\ref {support.initlist.access})}} {\memgloref{}}|memjustarg}{541} +\glossaryentry{support.initlist.range@ {\memgloterm{support.initlist.range}}{\memglodesc{(\ref {support.initlist.range})}} {\memgloref{}}|memjustarg}{541} +\glossaryentry{cmp@ {\memgloterm{cmp}}{\memglodesc{(\ref {cmp})}} {\memgloref{}}|memjustarg}{541} +\glossaryentry{compare.syn@ {\memgloterm{compare.syn}}{\memglodesc{(\ref {compare.syn})}} {\memgloref{}}|memjustarg}{541} +\glossaryentry{cmp.categories@ {\memgloterm{cmp.categories}}{\memglodesc{(\ref {cmp.categories})}} {\memgloref{}}|memjustarg}{542} +\glossaryentry{cmp.categories.pre@ {\memgloterm{cmp.categories.pre}}{\memglodesc{(\ref {cmp.categories.pre})}} {\memgloref{}}|memjustarg}{542} +\glossaryentry{cmp.partialord@ {\memgloterm{cmp.partialord}}{\memglodesc{(\ref {cmp.partialord})}} {\memgloref{}}|memjustarg}{542} +\glossaryentry{cmp.weakord@ {\memgloterm{cmp.weakord}}{\memglodesc{(\ref {cmp.weakord})}} {\memgloref{}}|memjustarg}{544} +\glossaryentry{cmp.strongord@ {\memgloterm{cmp.strongord}}{\memglodesc{(\ref {cmp.strongord})}} {\memgloref{}}|memjustarg}{545} +\glossaryentry{cmp.common@ {\memgloterm{cmp.common}}{\memglodesc{(\ref {cmp.common})}} {\memgloref{}}|memjustarg}{546} +\glossaryentry{cmp.concept@ {\memgloterm{cmp.concept}}{\memglodesc{(\ref {cmp.concept})}} {\memgloref{}}|memjustarg}{546} +\glossaryentry{cmp.result@ {\memgloterm{cmp.result}}{\memglodesc{(\ref {cmp.result})}} {\memgloref{}}|memjustarg}{547} +\glossaryentry{cmp.alg@ {\memgloterm{cmp.alg}}{\memglodesc{(\ref {cmp.alg})}} {\memgloref{}}|memjustarg}{548} +\glossaryentry{support.coroutine@ {\memgloterm{support.coroutine}}{\memglodesc{(\ref {support.coroutine})}} {\memgloref{}}|memjustarg}{549} +\glossaryentry{support.coroutine.general@ {\memgloterm{support.coroutine.general}}{\memglodesc{(\ref {support.coroutine.general})}} {\memgloref{}}|memjustarg}{549} +\glossaryentry{coroutine.syn@ {\memgloterm{coroutine.syn}}{\memglodesc{(\ref {coroutine.syn})}} {\memgloref{}}|memjustarg}{550} +\glossaryentry{coroutine.traits@ {\memgloterm{coroutine.traits}}{\memglodesc{(\ref {coroutine.traits})}} {\memgloref{}}|memjustarg}{550} +\glossaryentry{coroutine.traits.general@ {\memgloterm{coroutine.traits.general}}{\memglodesc{(\ref {coroutine.traits.general})}} {\memgloref{}}|memjustarg}{550} +\glossaryentry{coroutine.traits.primary@ {\memgloterm{coroutine.traits.primary}}{\memglodesc{(\ref {coroutine.traits.primary})}} {\memgloref{}}|memjustarg}{550} +\glossaryentry{coroutine.handle@ {\memgloterm{coroutine.handle}}{\memglodesc{(\ref {coroutine.handle})}} {\memgloref{}}|memjustarg}{550} +\glossaryentry{coroutine.handle.general@ {\memgloterm{coroutine.handle.general}}{\memglodesc{(\ref {coroutine.handle.general})}} {\memgloref{}}|memjustarg}{550} +\glossaryentry{coroutine.handle.con@ {\memgloterm{coroutine.handle.con}}{\memglodesc{(\ref {coroutine.handle.con})}} {\memgloref{}}|memjustarg}{551} +\glossaryentry{coroutine.handle.conv@ {\memgloterm{coroutine.handle.conv}}{\memglodesc{(\ref {coroutine.handle.conv})}} {\memgloref{}}|memjustarg}{552} +\glossaryentry{coroutine.handle.export.import@ {\memgloterm{coroutine.handle.export.import}}{\memglodesc{(\ref {coroutine.handle.export.import})}} {\memgloref{}}|memjustarg}{552} +\glossaryentry{coroutine.handle.observers@ {\memgloterm{coroutine.handle.observers}}{\memglodesc{(\ref {coroutine.handle.observers})}} {\memgloref{}}|memjustarg}{552} +\glossaryentry{coroutine.handle.resumption@ {\memgloterm{coroutine.handle.resumption}}{\memglodesc{(\ref {coroutine.handle.resumption})}} {\memgloref{}}|memjustarg}{552} +\glossaryentry{coroutine.handle.promise@ {\memgloterm{coroutine.handle.promise}}{\memglodesc{(\ref {coroutine.handle.promise})}} {\memgloref{}}|memjustarg}{553} +\glossaryentry{coroutine.handle.compare@ {\memgloterm{coroutine.handle.compare}}{\memglodesc{(\ref {coroutine.handle.compare})}} {\memgloref{}}|memjustarg}{553} +\glossaryentry{coroutine.handle.hash@ {\memgloterm{coroutine.handle.hash}}{\memglodesc{(\ref {coroutine.handle.hash})}} {\memgloref{}}|memjustarg}{553} +\glossaryentry{coroutine.noop@ {\memgloterm{coroutine.noop}}{\memglodesc{(\ref {coroutine.noop})}} {\memgloref{}}|memjustarg}{553} +\glossaryentry{coroutine.promise.noop@ {\memgloterm{coroutine.promise.noop}}{\memglodesc{(\ref {coroutine.promise.noop})}} {\memgloref{}}|memjustarg}{553} +\glossaryentry{coroutine.handle.noop@ {\memgloterm{coroutine.handle.noop}}{\memglodesc{(\ref {coroutine.handle.noop})}} {\memgloref{}}|memjustarg}{553} +\glossaryentry{coroutine.handle.noop.conv@ {\memgloterm{coroutine.handle.noop.conv}}{\memglodesc{(\ref {coroutine.handle.noop.conv})}} {\memgloref{}}|memjustarg}{553} +\glossaryentry{coroutine.handle.noop.observers@ {\memgloterm{coroutine.handle.noop.observers}}{\memglodesc{(\ref {coroutine.handle.noop.observers})}} {\memgloref{}}|memjustarg}{554} +\glossaryentry{coroutine.handle.noop.resumption@ {\memgloterm{coroutine.handle.noop.resumption}}{\memglodesc{(\ref {coroutine.handle.noop.resumption})}} {\memgloref{}}|memjustarg}{554} +\glossaryentry{coroutine.handle.noop.promise@ {\memgloterm{coroutine.handle.noop.promise}}{\memglodesc{(\ref {coroutine.handle.noop.promise})}} {\memgloref{}}|memjustarg}{554} +\glossaryentry{coroutine.handle.noop.address@ {\memgloterm{coroutine.handle.noop.address}}{\memglodesc{(\ref {coroutine.handle.noop.address})}} {\memgloref{}}|memjustarg}{554} +\glossaryentry{coroutine.noop.coroutine@ {\memgloterm{coroutine.noop.coroutine}}{\memglodesc{(\ref {coroutine.noop.coroutine})}} {\memgloref{}}|memjustarg}{554} +\glossaryentry{coroutine.trivial.awaitables@ {\memgloterm{coroutine.trivial.awaitables}}{\memglodesc{(\ref {coroutine.trivial.awaitables})}} {\memgloref{}}|memjustarg}{554} +\glossaryentry{support.runtime@ {\memgloterm{support.runtime}}{\memglodesc{(\ref {support.runtime})}} {\memgloref{}}|memjustarg}{554} +\glossaryentry{support.runtime.general@ {\memgloterm{support.runtime.general}}{\memglodesc{(\ref {support.runtime.general})}} {\memgloref{}}|memjustarg}{554} +\glossaryentry{cstdarg.syn@ {\memgloterm{cstdarg.syn}}{\memglodesc{(\ref {cstdarg.syn})}} {\memgloref{}}|memjustarg}{555} +\glossaryentry{csetjmp.syn@ {\memgloterm{csetjmp.syn}}{\memglodesc{(\ref {csetjmp.syn})}} {\memgloref{}}|memjustarg}{555} +\glossaryentry{csignal.syn@ {\memgloterm{csignal.syn}}{\memglodesc{(\ref {csignal.syn})}} {\memgloref{}}|memjustarg}{555} +\glossaryentry{support.signal@ {\memgloterm{support.signal}}{\memglodesc{(\ref {support.signal})}} {\memgloref{}}|memjustarg}{556} +\glossaryentry{support.c.headers@ {\memgloterm{support.c.headers}}{\memglodesc{(\ref {support.c.headers})}} {\memgloref{}}|memjustarg}{556} +\glossaryentry{support.c.headers.general@ {\memgloterm{support.c.headers.general}}{\memglodesc{(\ref {support.c.headers.general})}} {\memgloref{}}|memjustarg}{556} +\glossaryentry{complex.h.syn@ {\memgloterm{complex.h.syn}}{\memglodesc{(\ref {complex.h.syn})}} {\memgloref{}}|memjustarg}{557} +\glossaryentry{iso646.h.syn@ {\memgloterm{iso646.h.syn}}{\memglodesc{(\ref {iso646.h.syn})}} {\memgloref{}}|memjustarg}{557} +\glossaryentry{stdalign.h.syn@ {\memgloterm{stdalign.h.syn}}{\memglodesc{(\ref {stdalign.h.syn})}} {\memgloref{}}|memjustarg}{557} +\glossaryentry{stdbool.h.syn@ {\memgloterm{stdbool.h.syn}}{\memglodesc{(\ref {stdbool.h.syn})}} {\memgloref{}}|memjustarg}{557} +\glossaryentry{tgmath.h.syn@ {\memgloterm{tgmath.h.syn}}{\memglodesc{(\ref {tgmath.h.syn})}} {\memgloref{}}|memjustarg}{557} +\glossaryentry{support.c.headers.other@ {\memgloterm{support.c.headers.other}}{\memglodesc{(\ref {support.c.headers.other})}} {\memgloref{}}|memjustarg}{557} +\glossaryentry{concepts@ {\memgloterm{concepts}}{\memglodesc{(\ref {concepts})}} {\memgloref{}}|memjustarg}{559} +\glossaryentry{concepts.general@ {\memgloterm{concepts.general}}{\memglodesc{(\ref {concepts.general})}} {\memgloref{}}|memjustarg}{559} +\glossaryentry{concepts.equality@ {\memgloterm{concepts.equality}}{\memglodesc{(\ref {concepts.equality})}} {\memgloref{}}|memjustarg}{559} +\glossaryentry{concepts.syn@ {\memgloterm{concepts.syn}}{\memglodesc{(\ref {concepts.syn})}} {\memgloref{}}|memjustarg}{560} +\glossaryentry{concepts.lang@ {\memgloterm{concepts.lang}}{\memglodesc{(\ref {concepts.lang})}} {\memgloref{}}|memjustarg}{562} +\glossaryentry{concepts.lang.general@ {\memgloterm{concepts.lang.general}}{\memglodesc{(\ref {concepts.lang.general})}} {\memgloref{}}|memjustarg}{562} +\glossaryentry{concept.same@ {\memgloterm{concept.same}}{\memglodesc{(\ref {concept.same})}} {\memgloref{}}|memjustarg}{562} +\glossaryentry{concept.derived@ {\memgloterm{concept.derived}}{\memglodesc{(\ref {concept.derived})}} {\memgloref{}}|memjustarg}{562} +\glossaryentry{concept.convertible@ {\memgloterm{concept.convertible}}{\memglodesc{(\ref {concept.convertible})}} {\memgloref{}}|memjustarg}{563} +\glossaryentry{concept.commonref@ {\memgloterm{concept.commonref}}{\memglodesc{(\ref {concept.commonref})}} {\memgloref{}}|memjustarg}{563} +\glossaryentry{concept.common@ {\memgloterm{concept.common}}{\memglodesc{(\ref {concept.common})}} {\memgloref{}}|memjustarg}{563} +\glossaryentry{concepts.arithmetic@ {\memgloterm{concepts.arithmetic}}{\memglodesc{(\ref {concepts.arithmetic})}} {\memgloref{}}|memjustarg}{564} +\glossaryentry{concept.assignable@ {\memgloterm{concept.assignable}}{\memglodesc{(\ref {concept.assignable})}} {\memgloref{}}|memjustarg}{564} +\glossaryentry{concept.swappable@ {\memgloterm{concept.swappable}}{\memglodesc{(\ref {concept.swappable})}} {\memgloref{}}|memjustarg}{565} +\glossaryentry{concept.destructible@ {\memgloterm{concept.destructible}}{\memglodesc{(\ref {concept.destructible})}} {\memgloref{}}|memjustarg}{566} +\glossaryentry{concept.constructible@ {\memgloterm{concept.constructible}}{\memglodesc{(\ref {concept.constructible})}} {\memgloref{}}|memjustarg}{566} +\glossaryentry{concept.default.init@ {\memgloterm{concept.default.init}}{\memglodesc{(\ref {concept.default.init})}} {\memgloref{}}|memjustarg}{567} +\glossaryentry{concept.moveconstructible@ {\memgloterm{concept.moveconstructible}}{\memglodesc{(\ref {concept.moveconstructible})}} {\memgloref{}}|memjustarg}{567} +\glossaryentry{concept.copyconstructible@ {\memgloterm{concept.copyconstructible}}{\memglodesc{(\ref {concept.copyconstructible})}} {\memgloref{}}|memjustarg}{567} +\glossaryentry{concepts.compare@ {\memgloterm{concepts.compare}}{\memglodesc{(\ref {concepts.compare})}} {\memgloref{}}|memjustarg}{567} +\glossaryentry{concepts.compare.general@ {\memgloterm{concepts.compare.general}}{\memglodesc{(\ref {concepts.compare.general})}} {\memgloref{}}|memjustarg}{567} +\glossaryentry{concept.booleantestable@ {\memgloterm{concept.booleantestable}}{\memglodesc{(\ref {concept.booleantestable})}} {\memgloref{}}|memjustarg}{567} +\glossaryentry{concept.comparisoncommontype@ {\memgloterm{concept.comparisoncommontype}}{\memglodesc{(\ref {concept.comparisoncommontype})}} {\memgloref{}}|memjustarg}{568} +\glossaryentry{concept.equalitycomparable@ {\memgloterm{concept.equalitycomparable}}{\memglodesc{(\ref {concept.equalitycomparable})}} {\memgloref{}}|memjustarg}{569} +\glossaryentry{concept.totallyordered@ {\memgloterm{concept.totallyordered}}{\memglodesc{(\ref {concept.totallyordered})}} {\memgloref{}}|memjustarg}{569} +\glossaryentry{concepts.object@ {\memgloterm{concepts.object}}{\memglodesc{(\ref {concepts.object})}} {\memgloref{}}|memjustarg}{570} +\glossaryentry{concepts.callable@ {\memgloterm{concepts.callable}}{\memglodesc{(\ref {concepts.callable})}} {\memgloref{}}|memjustarg}{570} +\glossaryentry{concepts.callable.general@ {\memgloterm{concepts.callable.general}}{\memglodesc{(\ref {concepts.callable.general})}} {\memgloref{}}|memjustarg}{570} +\glossaryentry{concept.invocable@ {\memgloterm{concept.invocable}}{\memglodesc{(\ref {concept.invocable})}} {\memgloref{}}|memjustarg}{571} +\glossaryentry{concept.regularinvocable@ {\memgloterm{concept.regularinvocable}}{\memglodesc{(\ref {concept.regularinvocable})}} {\memgloref{}}|memjustarg}{571} +\glossaryentry{concept.predicate@ {\memgloterm{concept.predicate}}{\memglodesc{(\ref {concept.predicate})}} {\memgloref{}}|memjustarg}{571} +\glossaryentry{concept.relation@ {\memgloterm{concept.relation}}{\memglodesc{(\ref {concept.relation})}} {\memgloref{}}|memjustarg}{571} +\glossaryentry{concept.equiv@ {\memgloterm{concept.equiv}}{\memglodesc{(\ref {concept.equiv})}} {\memgloref{}}|memjustarg}{571} +\glossaryentry{concept.strictweakorder@ {\memgloterm{concept.strictweakorder}}{\memglodesc{(\ref {concept.strictweakorder})}} {\memgloref{}}|memjustarg}{571} +\glossaryentry{diagnostics@ {\memgloterm{diagnostics}}{\memglodesc{(\ref {diagnostics})}} {\memgloref{}}|memjustarg}{572} +\glossaryentry{diagnostics.general@ {\memgloterm{diagnostics.general}}{\memglodesc{(\ref {diagnostics.general})}} {\memgloref{}}|memjustarg}{572} +\glossaryentry{std.exceptions@ {\memgloterm{std.exceptions}}{\memglodesc{(\ref {std.exceptions})}} {\memgloref{}}|memjustarg}{572} +\glossaryentry{std.exceptions.general@ {\memgloterm{std.exceptions.general}}{\memglodesc{(\ref {std.exceptions.general})}} {\memgloref{}}|memjustarg}{572} +\glossaryentry{stdexcept.syn@ {\memgloterm{stdexcept.syn}}{\memglodesc{(\ref {stdexcept.syn})}} {\memgloref{}}|memjustarg}{572} +\glossaryentry{logic.error@ {\memgloterm{logic.error}}{\memglodesc{(\ref {logic.error})}} {\memgloref{}}|memjustarg}{572} +\glossaryentry{domain.error@ {\memgloterm{domain.error}}{\memglodesc{(\ref {domain.error})}} {\memgloref{}}|memjustarg}{573} +\glossaryentry{invalid.argument@ {\memgloterm{invalid.argument}}{\memglodesc{(\ref {invalid.argument})}} {\memgloref{}}|memjustarg}{573} +\glossaryentry{length.error@ {\memgloterm{length.error}}{\memglodesc{(\ref {length.error})}} {\memgloref{}}|memjustarg}{573} +\glossaryentry{out.of.range@ {\memgloterm{out.of.range}}{\memglodesc{(\ref {out.of.range})}} {\memgloref{}}|memjustarg}{574} +\glossaryentry{runtime.error@ {\memgloterm{runtime.error}}{\memglodesc{(\ref {runtime.error})}} {\memgloref{}}|memjustarg}{574} +\glossaryentry{range.error@ {\memgloterm{range.error}}{\memglodesc{(\ref {range.error})}} {\memgloref{}}|memjustarg}{574} +\glossaryentry{overflow.error@ {\memgloterm{overflow.error}}{\memglodesc{(\ref {overflow.error})}} {\memgloref{}}|memjustarg}{574} +\glossaryentry{underflow.error@ {\memgloterm{underflow.error}}{\memglodesc{(\ref {underflow.error})}} {\memgloref{}}|memjustarg}{575} +\glossaryentry{assertions@ {\memgloterm{assertions}}{\memglodesc{(\ref {assertions})}} {\memgloref{}}|memjustarg}{575} +\glossaryentry{assertions.general@ {\memgloterm{assertions.general}}{\memglodesc{(\ref {assertions.general})}} {\memgloref{}}|memjustarg}{575} +\glossaryentry{cassert.syn@ {\memgloterm{cassert.syn}}{\memglodesc{(\ref {cassert.syn})}} {\memgloref{}}|memjustarg}{575} +\glossaryentry{assertions.assert@ {\memgloterm{assertions.assert}}{\memglodesc{(\ref {assertions.assert})}} {\memgloref{}}|memjustarg}{575} +\glossaryentry{errno@ {\memgloterm{errno}}{\memglodesc{(\ref {errno})}} {\memgloref{}}|memjustarg}{575} +\glossaryentry{errno.general@ {\memgloterm{errno.general}}{\memglodesc{(\ref {errno.general})}} {\memgloref{}}|memjustarg}{575} +\glossaryentry{cerrno.syn@ {\memgloterm{cerrno.syn}}{\memglodesc{(\ref {cerrno.syn})}} {\memgloref{}}|memjustarg}{575} +\glossaryentry{syserr@ {\memgloterm{syserr}}{\memglodesc{(\ref {syserr})}} {\memgloref{}}|memjustarg}{577} +\glossaryentry{syserr.general@ {\memgloterm{syserr.general}}{\memglodesc{(\ref {syserr.general})}} {\memgloref{}}|memjustarg}{577} +\glossaryentry{system.error.syn@ {\memgloterm{system.error.syn}}{\memglodesc{(\ref {system.error.syn})}} {\memgloref{}}|memjustarg}{577} +\glossaryentry{syserr.errcat@ {\memgloterm{syserr.errcat}}{\memglodesc{(\ref {syserr.errcat})}} {\memgloref{}}|memjustarg}{579} +\glossaryentry{syserr.errcat.overview@ {\memgloterm{syserr.errcat.overview}}{\memglodesc{(\ref {syserr.errcat.overview})}} {\memgloref{}}|memjustarg}{579} +\glossaryentry{syserr.errcat.virtuals@ {\memgloterm{syserr.errcat.virtuals}}{\memglodesc{(\ref {syserr.errcat.virtuals})}} {\memgloref{}}|memjustarg}{579} +\glossaryentry{syserr.errcat.nonvirtuals@ {\memgloterm{syserr.errcat.nonvirtuals}}{\memglodesc{(\ref {syserr.errcat.nonvirtuals})}} {\memgloref{}}|memjustarg}{580} +\glossaryentry{syserr.errcat.derived@ {\memgloterm{syserr.errcat.derived}}{\memglodesc{(\ref {syserr.errcat.derived})}} {\memgloref{}}|memjustarg}{580} +\glossaryentry{syserr.errcat.objects@ {\memgloterm{syserr.errcat.objects}}{\memglodesc{(\ref {syserr.errcat.objects})}} {\memgloref{}}|memjustarg}{580} +\glossaryentry{syserr.errcode@ {\memgloterm{syserr.errcode}}{\memglodesc{(\ref {syserr.errcode})}} {\memgloref{}}|memjustarg}{581} +\glossaryentry{syserr.errcode.overview@ {\memgloterm{syserr.errcode.overview}}{\memglodesc{(\ref {syserr.errcode.overview})}} {\memgloref{}}|memjustarg}{581} +\glossaryentry{syserr.errcode.constructors@ {\memgloterm{syserr.errcode.constructors}}{\memglodesc{(\ref {syserr.errcode.constructors})}} {\memgloref{}}|memjustarg}{581} +\glossaryentry{syserr.errcode.modifiers@ {\memgloterm{syserr.errcode.modifiers}}{\memglodesc{(\ref {syserr.errcode.modifiers})}} {\memgloref{}}|memjustarg}{582} +\glossaryentry{syserr.errcode.observers@ {\memgloterm{syserr.errcode.observers}}{\memglodesc{(\ref {syserr.errcode.observers})}} {\memgloref{}}|memjustarg}{582} +\glossaryentry{syserr.errcode.nonmembers@ {\memgloterm{syserr.errcode.nonmembers}}{\memglodesc{(\ref {syserr.errcode.nonmembers})}} {\memgloref{}}|memjustarg}{582} +\glossaryentry{syserr.errcondition@ {\memgloterm{syserr.errcondition}}{\memglodesc{(\ref {syserr.errcondition})}} {\memgloref{}}|memjustarg}{582} +\glossaryentry{syserr.errcondition.overview@ {\memgloterm{syserr.errcondition.overview}}{\memglodesc{(\ref {syserr.errcondition.overview})}} {\memgloref{}}|memjustarg}{582} +\glossaryentry{syserr.errcondition.constructors@ {\memgloterm{syserr.errcondition.constructors}}{\memglodesc{(\ref {syserr.errcondition.constructors})}} {\memgloref{}}|memjustarg}{583} +\glossaryentry{syserr.errcondition.modifiers@ {\memgloterm{syserr.errcondition.modifiers}}{\memglodesc{(\ref {syserr.errcondition.modifiers})}} {\memgloref{}}|memjustarg}{583} +\glossaryentry{syserr.errcondition.observers@ {\memgloterm{syserr.errcondition.observers}}{\memglodesc{(\ref {syserr.errcondition.observers})}} {\memgloref{}}|memjustarg}{583} +\glossaryentry{syserr.errcondition.nonmembers@ {\memgloterm{syserr.errcondition.nonmembers}}{\memglodesc{(\ref {syserr.errcondition.nonmembers})}} {\memgloref{}}|memjustarg}{584} +\glossaryentry{syserr.compare@ {\memgloterm{syserr.compare}}{\memglodesc{(\ref {syserr.compare})}} {\memgloref{}}|memjustarg}{584} +\glossaryentry{syserr.hash@ {\memgloterm{syserr.hash}}{\memglodesc{(\ref {syserr.hash})}} {\memgloref{}}|memjustarg}{584} +\glossaryentry{syserr.syserr@ {\memgloterm{syserr.syserr}}{\memglodesc{(\ref {syserr.syserr})}} {\memgloref{}}|memjustarg}{584} +\glossaryentry{syserr.syserr.overview@ {\memgloterm{syserr.syserr.overview}}{\memglodesc{(\ref {syserr.syserr.overview})}} {\memgloref{}}|memjustarg}{584} +\glossaryentry{syserr.syserr.members@ {\memgloterm{syserr.syserr.members}}{\memglodesc{(\ref {syserr.syserr.members})}} {\memgloref{}}|memjustarg}{585} +\glossaryentry{stacktrace@ {\memgloterm{stacktrace}}{\memglodesc{(\ref {stacktrace})}} {\memgloref{}}|memjustarg}{585} +\glossaryentry{stacktrace.general@ {\memgloterm{stacktrace.general}}{\memglodesc{(\ref {stacktrace.general})}} {\memgloref{}}|memjustarg}{585} +\glossaryentry{stacktrace.syn@ {\memgloterm{stacktrace.syn}}{\memglodesc{(\ref {stacktrace.syn})}} {\memgloref{}}|memjustarg}{585} +\glossaryentry{stacktrace.entry@ {\memgloterm{stacktrace.entry}}{\memglodesc{(\ref {stacktrace.entry})}} {\memgloref{}}|memjustarg}{586} +\glossaryentry{stacktrace.entry.overview@ {\memgloterm{stacktrace.entry.overview}}{\memglodesc{(\ref {stacktrace.entry.overview})}} {\memgloref{}}|memjustarg}{586} +\glossaryentry{stacktrace.entry.cons@ {\memgloterm{stacktrace.entry.cons}}{\memglodesc{(\ref {stacktrace.entry.cons})}} {\memgloref{}}|memjustarg}{586} +\glossaryentry{stacktrace.entry.obs@ {\memgloterm{stacktrace.entry.obs}}{\memglodesc{(\ref {stacktrace.entry.obs})}} {\memgloref{}}|memjustarg}{587} +\glossaryentry{stacktrace.entry.query@ {\memgloterm{stacktrace.entry.query}}{\memglodesc{(\ref {stacktrace.entry.query})}} {\memgloref{}}|memjustarg}{587} +\glossaryentry{stacktrace.entry.cmp@ {\memgloterm{stacktrace.entry.cmp}}{\memglodesc{(\ref {stacktrace.entry.cmp})}} {\memgloref{}}|memjustarg}{587} +\glossaryentry{stacktrace.basic@ {\memgloterm{stacktrace.basic}}{\memglodesc{(\ref {stacktrace.basic})}} {\memgloref{}}|memjustarg}{587} +\glossaryentry{stacktrace.basic.overview@ {\memgloterm{stacktrace.basic.overview}}{\memglodesc{(\ref {stacktrace.basic.overview})}} {\memgloref{}}|memjustarg}{587} +\glossaryentry{stacktrace.basic.cons@ {\memgloterm{stacktrace.basic.cons}}{\memglodesc{(\ref {stacktrace.basic.cons})}} {\memgloref{}}|memjustarg}{588} +\glossaryentry{stacktrace.basic.obs@ {\memgloterm{stacktrace.basic.obs}}{\memglodesc{(\ref {stacktrace.basic.obs})}} {\memgloref{}}|memjustarg}{589} +\glossaryentry{stacktrace.basic.cmp@ {\memgloterm{stacktrace.basic.cmp}}{\memglodesc{(\ref {stacktrace.basic.cmp})}} {\memgloref{}}|memjustarg}{590} +\glossaryentry{stacktrace.basic.mod@ {\memgloterm{stacktrace.basic.mod}}{\memglodesc{(\ref {stacktrace.basic.mod})}} {\memgloref{}}|memjustarg}{590} +\glossaryentry{stacktrace.basic.nonmem@ {\memgloterm{stacktrace.basic.nonmem}}{\memglodesc{(\ref {stacktrace.basic.nonmem})}} {\memgloref{}}|memjustarg}{590} +\glossaryentry{stacktrace.format@ {\memgloterm{stacktrace.format}}{\memglodesc{(\ref {stacktrace.format})}} {\memgloref{}}|memjustarg}{591} +\glossaryentry{stacktrace.basic.hash@ {\memgloterm{stacktrace.basic.hash}}{\memglodesc{(\ref {stacktrace.basic.hash})}} {\memgloref{}}|memjustarg}{591} +\glossaryentry{mem@ {\memgloterm{mem}}{\memglodesc{(\ref {mem})}} {\memgloref{}}|memjustarg}{592} +\glossaryentry{mem.general@ {\memgloterm{mem.general}}{\memglodesc{(\ref {mem.general})}} {\memgloref{}}|memjustarg}{592} +\glossaryentry{memory@ {\memgloterm{memory}}{\memglodesc{(\ref {memory})}} {\memgloref{}}|memjustarg}{592} +\glossaryentry{memory.general@ {\memgloterm{memory.general}}{\memglodesc{(\ref {memory.general})}} {\memgloref{}}|memjustarg}{592} +\glossaryentry{memory.syn@ {\memgloterm{memory.syn}}{\memglodesc{(\ref {memory.syn})}} {\memgloref{}}|memjustarg}{592} +\glossaryentry{pointer.traits@ {\memgloterm{pointer.traits}}{\memglodesc{(\ref {pointer.traits})}} {\memgloref{}}|memjustarg}{600} +\glossaryentry{pointer.traits.general@ {\memgloterm{pointer.traits.general}}{\memglodesc{(\ref {pointer.traits.general})}} {\memgloref{}}|memjustarg}{600} +\glossaryentry{pointer.traits.types@ {\memgloterm{pointer.traits.types}}{\memglodesc{(\ref {pointer.traits.types})}} {\memgloref{}}|memjustarg}{601} +\glossaryentry{pointer.traits.functions@ {\memgloterm{pointer.traits.functions}}{\memglodesc{(\ref {pointer.traits.functions})}} {\memgloref{}}|memjustarg}{601} +\glossaryentry{pointer.traits.optmem@ {\memgloterm{pointer.traits.optmem}}{\memglodesc{(\ref {pointer.traits.optmem})}} {\memgloref{}}|memjustarg}{602} +\glossaryentry{pointer.conversion@ {\memgloterm{pointer.conversion}}{\memglodesc{(\ref {pointer.conversion})}} {\memgloref{}}|memjustarg}{602} +\glossaryentry{ptr.align@ {\memgloterm{ptr.align}}{\memglodesc{(\ref {ptr.align})}} {\memgloref{}}|memjustarg}{602} +\glossaryentry{obj.lifetime@ {\memgloterm{obj.lifetime}}{\memglodesc{(\ref {obj.lifetime})}} {\memgloref{}}|memjustarg}{602} +\glossaryentry{allocator.tag@ {\memgloterm{allocator.tag}}{\memglodesc{(\ref {allocator.tag})}} {\memgloref{}}|memjustarg}{603} +\glossaryentry{allocator.uses@ {\memgloterm{allocator.uses}}{\memglodesc{(\ref {allocator.uses})}} {\memgloref{}}|memjustarg}{603} +\glossaryentry{allocator.uses.trait@ {\memgloterm{allocator.uses.trait}}{\memglodesc{(\ref {allocator.uses.trait})}} {\memgloref{}}|memjustarg}{603} +\glossaryentry{allocator.uses.construction@ {\memgloterm{allocator.uses.construction}}{\memglodesc{(\ref {allocator.uses.construction})}} {\memgloref{}}|memjustarg}{603} +\glossaryentry{allocator.traits@ {\memgloterm{allocator.traits}}{\memglodesc{(\ref {allocator.traits})}} {\memgloref{}}|memjustarg}{606} +\glossaryentry{allocator.traits.general@ {\memgloterm{allocator.traits.general}}{\memglodesc{(\ref {allocator.traits.general})}} {\memgloref{}}|memjustarg}{606} +\glossaryentry{allocator.traits.types@ {\memgloterm{allocator.traits.types}}{\memglodesc{(\ref {allocator.traits.types})}} {\memgloref{}}|memjustarg}{607} +\glossaryentry{allocator.traits.members@ {\memgloterm{allocator.traits.members}}{\memglodesc{(\ref {allocator.traits.members})}} {\memgloref{}}|memjustarg}{608} +\glossaryentry{allocator.traits.other@ {\memgloterm{allocator.traits.other}}{\memglodesc{(\ref {allocator.traits.other})}} {\memgloref{}}|memjustarg}{608} +\glossaryentry{default.allocator@ {\memgloterm{default.allocator}}{\memglodesc{(\ref {default.allocator})}} {\memgloref{}}|memjustarg}{608} +\glossaryentry{default.allocator.general@ {\memgloterm{default.allocator.general}}{\memglodesc{(\ref {default.allocator.general})}} {\memgloref{}}|memjustarg}{608} +\glossaryentry{allocator.members@ {\memgloterm{allocator.members}}{\memglodesc{(\ref {allocator.members})}} {\memgloref{}}|memjustarg}{609} +\glossaryentry{allocator.globals@ {\memgloterm{allocator.globals}}{\memglodesc{(\ref {allocator.globals})}} {\memgloref{}}|memjustarg}{609} +\glossaryentry{specialized.addressof@ {\memgloterm{specialized.addressof}}{\memglodesc{(\ref {specialized.addressof})}} {\memgloref{}}|memjustarg}{610} +\glossaryentry{c.malloc@ {\memgloterm{c.malloc}}{\memglodesc{(\ref {c.malloc})}} {\memgloref{}}|memjustarg}{610} +\glossaryentry{smartptr@ {\memgloterm{smartptr}}{\memglodesc{(\ref {smartptr})}} {\memgloref{}}|memjustarg}{610} +\glossaryentry{unique.ptr@ {\memgloterm{unique.ptr}}{\memglodesc{(\ref {unique.ptr})}} {\memgloref{}}|memjustarg}{610} +\glossaryentry{unique.ptr.general@ {\memgloterm{unique.ptr.general}}{\memglodesc{(\ref {unique.ptr.general})}} {\memgloref{}}|memjustarg}{610} +\glossaryentry{unique.ptr.dltr@ {\memgloterm{unique.ptr.dltr}}{\memglodesc{(\ref {unique.ptr.dltr})}} {\memgloref{}}|memjustarg}{610} +\glossaryentry{unique.ptr.dltr.general@ {\memgloterm{unique.ptr.dltr.general}}{\memglodesc{(\ref {unique.ptr.dltr.general})}} {\memgloref{}}|memjustarg}{610} +\glossaryentry{unique.ptr.dltr.dflt@ {\memgloterm{unique.ptr.dltr.dflt}}{\memglodesc{(\ref {unique.ptr.dltr.dflt})}} {\memgloref{}}|memjustarg}{611} +\glossaryentry{unique.ptr.dltr.dflt1@ {\memgloterm{unique.ptr.dltr.dflt1}}{\memglodesc{(\ref {unique.ptr.dltr.dflt1})}} {\memgloref{}}|memjustarg}{611} +\glossaryentry{unique.ptr.single@ {\memgloterm{unique.ptr.single}}{\memglodesc{(\ref {unique.ptr.single})}} {\memgloref{}}|memjustarg}{611} +\glossaryentry{unique.ptr.single.general@ {\memgloterm{unique.ptr.single.general}}{\memglodesc{(\ref {unique.ptr.single.general})}} {\memgloref{}}|memjustarg}{611} +\glossaryentry{unique.ptr.single.ctor@ {\memgloterm{unique.ptr.single.ctor}}{\memglodesc{(\ref {unique.ptr.single.ctor})}} {\memgloref{}}|memjustarg}{612} +\glossaryentry{unique.ptr.single.dtor@ {\memgloterm{unique.ptr.single.dtor}}{\memglodesc{(\ref {unique.ptr.single.dtor})}} {\memgloref{}}|memjustarg}{613} +\glossaryentry{unique.ptr.single.asgn@ {\memgloterm{unique.ptr.single.asgn}}{\memglodesc{(\ref {unique.ptr.single.asgn})}} {\memgloref{}}|memjustarg}{614} +\glossaryentry{unique.ptr.single.observers@ {\memgloterm{unique.ptr.single.observers}}{\memglodesc{(\ref {unique.ptr.single.observers})}} {\memgloref{}}|memjustarg}{614} +\glossaryentry{unique.ptr.single.modifiers@ {\memgloterm{unique.ptr.single.modifiers}}{\memglodesc{(\ref {unique.ptr.single.modifiers})}} {\memgloref{}}|memjustarg}{615} +\glossaryentry{unique.ptr.runtime@ {\memgloterm{unique.ptr.runtime}}{\memglodesc{(\ref {unique.ptr.runtime})}} {\memgloref{}}|memjustarg}{615} +\glossaryentry{unique.ptr.runtime.general@ {\memgloterm{unique.ptr.runtime.general}}{\memglodesc{(\ref {unique.ptr.runtime.general})}} {\memgloref{}}|memjustarg}{615} +\glossaryentry{unique.ptr.runtime.ctor@ {\memgloterm{unique.ptr.runtime.ctor}}{\memglodesc{(\ref {unique.ptr.runtime.ctor})}} {\memgloref{}}|memjustarg}{616} +\glossaryentry{unique.ptr.runtime.asgn@ {\memgloterm{unique.ptr.runtime.asgn}}{\memglodesc{(\ref {unique.ptr.runtime.asgn})}} {\memgloref{}}|memjustarg}{616} +\glossaryentry{unique.ptr.runtime.observers@ {\memgloterm{unique.ptr.runtime.observers}}{\memglodesc{(\ref {unique.ptr.runtime.observers})}} {\memgloref{}}|memjustarg}{617} +\glossaryentry{unique.ptr.runtime.modifiers@ {\memgloterm{unique.ptr.runtime.modifiers}}{\memglodesc{(\ref {unique.ptr.runtime.modifiers})}} {\memgloref{}}|memjustarg}{617} +\glossaryentry{unique.ptr.create@ {\memgloterm{unique.ptr.create}}{\memglodesc{(\ref {unique.ptr.create})}} {\memgloref{}}|memjustarg}{617} +\glossaryentry{unique.ptr.special@ {\memgloterm{unique.ptr.special}}{\memglodesc{(\ref {unique.ptr.special})}} {\memgloref{}}|memjustarg}{617} +\glossaryentry{unique.ptr.io@ {\memgloterm{unique.ptr.io}}{\memglodesc{(\ref {unique.ptr.io})}} {\memgloref{}}|memjustarg}{619} +\glossaryentry{util.sharedptr@ {\memgloterm{util.sharedptr}}{\memglodesc{(\ref {util.sharedptr})}} {\memgloref{}}|memjustarg}{619} +\glossaryentry{util.smartptr.weak.bad@ {\memgloterm{util.smartptr.weak.bad}}{\memglodesc{(\ref {util.smartptr.weak.bad})}} {\memgloref{}}|memjustarg}{619} +\glossaryentry{util.smartptr.shared@ {\memgloterm{util.smartptr.shared}}{\memglodesc{(\ref {util.smartptr.shared})}} {\memgloref{}}|memjustarg}{619} +\glossaryentry{util.smartptr.shared.general@ {\memgloterm{util.smartptr.shared.general}}{\memglodesc{(\ref {util.smartptr.shared.general})}} {\memgloref{}}|memjustarg}{619} +\glossaryentry{util.smartptr.shared.const@ {\memgloterm{util.smartptr.shared.const}}{\memglodesc{(\ref {util.smartptr.shared.const})}} {\memgloref{}}|memjustarg}{621} +\glossaryentry{util.smartptr.shared.dest@ {\memgloterm{util.smartptr.shared.dest}}{\memglodesc{(\ref {util.smartptr.shared.dest})}} {\memgloref{}}|memjustarg}{623} +\glossaryentry{util.smartptr.shared.assign@ {\memgloterm{util.smartptr.shared.assign}}{\memglodesc{(\ref {util.smartptr.shared.assign})}} {\memgloref{}}|memjustarg}{623} +\glossaryentry{util.smartptr.shared.mod@ {\memgloterm{util.smartptr.shared.mod}}{\memglodesc{(\ref {util.smartptr.shared.mod})}} {\memgloref{}}|memjustarg}{623} +\glossaryentry{util.smartptr.shared.obs@ {\memgloterm{util.smartptr.shared.obs}}{\memglodesc{(\ref {util.smartptr.shared.obs})}} {\memgloref{}}|memjustarg}{624} +\glossaryentry{util.smartptr.shared.create@ {\memgloterm{util.smartptr.shared.create}}{\memglodesc{(\ref {util.smartptr.shared.create})}} {\memgloref{}}|memjustarg}{624} +\glossaryentry{util.smartptr.shared.cmp@ {\memgloterm{util.smartptr.shared.cmp}}{\memglodesc{(\ref {util.smartptr.shared.cmp})}} {\memgloref{}}|memjustarg}{627} +\glossaryentry{util.smartptr.shared.spec@ {\memgloterm{util.smartptr.shared.spec}}{\memglodesc{(\ref {util.smartptr.shared.spec})}} {\memgloref{}}|memjustarg}{628} +\glossaryentry{util.smartptr.shared.cast@ {\memgloterm{util.smartptr.shared.cast}}{\memglodesc{(\ref {util.smartptr.shared.cast})}} {\memgloref{}}|memjustarg}{628} +\glossaryentry{util.smartptr.getdeleter@ {\memgloterm{util.smartptr.getdeleter}}{\memglodesc{(\ref {util.smartptr.getdeleter})}} {\memgloref{}}|memjustarg}{629} +\glossaryentry{util.smartptr.shared.io@ {\memgloterm{util.smartptr.shared.io}}{\memglodesc{(\ref {util.smartptr.shared.io})}} {\memgloref{}}|memjustarg}{629} +\glossaryentry{util.smartptr.weak@ {\memgloterm{util.smartptr.weak}}{\memglodesc{(\ref {util.smartptr.weak})}} {\memgloref{}}|memjustarg}{629} +\glossaryentry{util.smartptr.weak.general@ {\memgloterm{util.smartptr.weak.general}}{\memglodesc{(\ref {util.smartptr.weak.general})}} {\memgloref{}}|memjustarg}{629} +\glossaryentry{util.smartptr.weak.const@ {\memgloterm{util.smartptr.weak.const}}{\memglodesc{(\ref {util.smartptr.weak.const})}} {\memgloref{}}|memjustarg}{630} +\glossaryentry{util.smartptr.weak.dest@ {\memgloterm{util.smartptr.weak.dest}}{\memglodesc{(\ref {util.smartptr.weak.dest})}} {\memgloref{}}|memjustarg}{630} +\glossaryentry{util.smartptr.weak.assign@ {\memgloterm{util.smartptr.weak.assign}}{\memglodesc{(\ref {util.smartptr.weak.assign})}} {\memgloref{}}|memjustarg}{631} +\glossaryentry{util.smartptr.weak.mod@ {\memgloterm{util.smartptr.weak.mod}}{\memglodesc{(\ref {util.smartptr.weak.mod})}} {\memgloref{}}|memjustarg}{631} +\glossaryentry{util.smartptr.weak.obs@ {\memgloterm{util.smartptr.weak.obs}}{\memglodesc{(\ref {util.smartptr.weak.obs})}} {\memgloref{}}|memjustarg}{631} +\glossaryentry{util.smartptr.weak.spec@ {\memgloterm{util.smartptr.weak.spec}}{\memglodesc{(\ref {util.smartptr.weak.spec})}} {\memgloref{}}|memjustarg}{631} +\glossaryentry{util.smartptr.ownerless@ {\memgloterm{util.smartptr.ownerless}}{\memglodesc{(\ref {util.smartptr.ownerless})}} {\memgloref{}}|memjustarg}{631} +\glossaryentry{util.smartptr.enab@ {\memgloterm{util.smartptr.enab}}{\memglodesc{(\ref {util.smartptr.enab})}} {\memgloref{}}|memjustarg}{632} +\glossaryentry{util.smartptr.hash@ {\memgloterm{util.smartptr.hash}}{\memglodesc{(\ref {util.smartptr.hash})}} {\memgloref{}}|memjustarg}{633} +\glossaryentry{smartptr.adapt@ {\memgloterm{smartptr.adapt}}{\memglodesc{(\ref {smartptr.adapt})}} {\memgloref{}}|memjustarg}{633} +\glossaryentry{out.ptr.t@ {\memgloterm{out.ptr.t}}{\memglodesc{(\ref {out.ptr.t})}} {\memgloref{}}|memjustarg}{633} +\glossaryentry{out.ptr@ {\memgloterm{out.ptr}}{\memglodesc{(\ref {out.ptr})}} {\memgloref{}}|memjustarg}{635} +\glossaryentry{inout.ptr.t@ {\memgloterm{inout.ptr.t}}{\memglodesc{(\ref {inout.ptr.t})}} {\memgloref{}}|memjustarg}{635} +\glossaryentry{inout.ptr@ {\memgloterm{inout.ptr}}{\memglodesc{(\ref {inout.ptr})}} {\memgloref{}}|memjustarg}{637} +\glossaryentry{mem.res@ {\memgloterm{mem.res}}{\memglodesc{(\ref {mem.res})}} {\memgloref{}}|memjustarg}{637} +\glossaryentry{mem.res.syn@ {\memgloterm{mem.res.syn}}{\memglodesc{(\ref {mem.res.syn})}} {\memgloref{}}|memjustarg}{637} +\glossaryentry{mem.res.class@ {\memgloterm{mem.res.class}}{\memglodesc{(\ref {mem.res.class})}} {\memgloref{}}|memjustarg}{637} +\glossaryentry{mem.res.class.general@ {\memgloterm{mem.res.class.general}}{\memglodesc{(\ref {mem.res.class.general})}} {\memgloref{}}|memjustarg}{637} +\glossaryentry{mem.res.public@ {\memgloterm{mem.res.public}}{\memglodesc{(\ref {mem.res.public})}} {\memgloref{}}|memjustarg}{638} +\glossaryentry{mem.res.private@ {\memgloterm{mem.res.private}}{\memglodesc{(\ref {mem.res.private})}} {\memgloref{}}|memjustarg}{638} +\glossaryentry{mem.res.eq@ {\memgloterm{mem.res.eq}}{\memglodesc{(\ref {mem.res.eq})}} {\memgloref{}}|memjustarg}{639} +\glossaryentry{mem.poly.allocator.class@ {\memgloterm{mem.poly.allocator.class}}{\memglodesc{(\ref {mem.poly.allocator.class})}} {\memgloref{}}|memjustarg}{639} +\glossaryentry{mem.poly.allocator.class.general@ {\memgloterm{mem.poly.allocator.class.general}}{\memglodesc{(\ref {mem.poly.allocator.class.general})}} {\memgloref{}}|memjustarg}{639} +\glossaryentry{mem.poly.allocator.ctor@ {\memgloterm{mem.poly.allocator.ctor}}{\memglodesc{(\ref {mem.poly.allocator.ctor})}} {\memgloref{}}|memjustarg}{640} +\glossaryentry{mem.poly.allocator.mem@ {\memgloterm{mem.poly.allocator.mem}}{\memglodesc{(\ref {mem.poly.allocator.mem})}} {\memgloref{}}|memjustarg}{640} +\glossaryentry{mem.poly.allocator.eq@ {\memgloterm{mem.poly.allocator.eq}}{\memglodesc{(\ref {mem.poly.allocator.eq})}} {\memgloref{}}|memjustarg}{641} +\glossaryentry{mem.res.global@ {\memgloterm{mem.res.global}}{\memglodesc{(\ref {mem.res.global})}} {\memgloref{}}|memjustarg}{641} +\glossaryentry{mem.res.pool@ {\memgloterm{mem.res.pool}}{\memglodesc{(\ref {mem.res.pool})}} {\memgloref{}}|memjustarg}{642} +\glossaryentry{mem.res.pool.overview@ {\memgloterm{mem.res.pool.overview}}{\memglodesc{(\ref {mem.res.pool.overview})}} {\memgloref{}}|memjustarg}{642} +\glossaryentry{mem.res.pool.options@ {\memgloterm{mem.res.pool.options}}{\memglodesc{(\ref {mem.res.pool.options})}} {\memgloref{}}|memjustarg}{643} +\glossaryentry{mem.res.pool.ctor@ {\memgloterm{mem.res.pool.ctor}}{\memglodesc{(\ref {mem.res.pool.ctor})}} {\memgloref{}}|memjustarg}{643} +\glossaryentry{mem.res.pool.mem@ {\memgloterm{mem.res.pool.mem}}{\memglodesc{(\ref {mem.res.pool.mem})}} {\memgloref{}}|memjustarg}{644} +\glossaryentry{mem.res.monotonic.buffer@ {\memgloterm{mem.res.monotonic.buffer}}{\memglodesc{(\ref {mem.res.monotonic.buffer})}} {\memgloref{}}|memjustarg}{644} +\glossaryentry{mem.res.monotonic.buffer.general@ {\memgloterm{mem.res.monotonic.buffer.general}}{\memglodesc{(\ref {mem.res.monotonic.buffer.general})}} {\memgloref{}}|memjustarg}{644} +\glossaryentry{mem.res.monotonic.buffer.ctor@ {\memgloterm{mem.res.monotonic.buffer.ctor}}{\memglodesc{(\ref {mem.res.monotonic.buffer.ctor})}} {\memgloref{}}|memjustarg}{645} +\glossaryentry{mem.res.monotonic.buffer.mem@ {\memgloterm{mem.res.monotonic.buffer.mem}}{\memglodesc{(\ref {mem.res.monotonic.buffer.mem})}} {\memgloref{}}|memjustarg}{645} +\glossaryentry{allocator.adaptor@ {\memgloterm{allocator.adaptor}}{\memglodesc{(\ref {allocator.adaptor})}} {\memgloref{}}|memjustarg}{646} +\glossaryentry{allocator.adaptor.syn@ {\memgloterm{allocator.adaptor.syn}}{\memglodesc{(\ref {allocator.adaptor.syn})}} {\memgloref{}}|memjustarg}{646} +\glossaryentry{allocator.adaptor.types@ {\memgloterm{allocator.adaptor.types}}{\memglodesc{(\ref {allocator.adaptor.types})}} {\memgloref{}}|memjustarg}{647} +\glossaryentry{allocator.adaptor.cnstr@ {\memgloterm{allocator.adaptor.cnstr}}{\memglodesc{(\ref {allocator.adaptor.cnstr})}} {\memgloref{}}|memjustarg}{648} +\glossaryentry{allocator.adaptor.members@ {\memgloterm{allocator.adaptor.members}}{\memglodesc{(\ref {allocator.adaptor.members})}} {\memgloref{}}|memjustarg}{648} +\glossaryentry{scoped.adaptor.operators@ {\memgloterm{scoped.adaptor.operators}}{\memglodesc{(\ref {scoped.adaptor.operators})}} {\memgloref{}}|memjustarg}{649} +\glossaryentry{meta@ {\memgloterm{meta}}{\memglodesc{(\ref {meta})}} {\memgloref{}}|memjustarg}{650} +\glossaryentry{meta.general@ {\memgloterm{meta.general}}{\memglodesc{(\ref {meta.general})}} {\memgloref{}}|memjustarg}{650} +\glossaryentry{intseq@ {\memgloterm{intseq}}{\memglodesc{(\ref {intseq})}} {\memgloref{}}|memjustarg}{650} +\glossaryentry{intseq.general@ {\memgloterm{intseq.general}}{\memglodesc{(\ref {intseq.general})}} {\memgloref{}}|memjustarg}{650} +\glossaryentry{intseq.intseq@ {\memgloterm{intseq.intseq}}{\memglodesc{(\ref {intseq.intseq})}} {\memgloref{}}|memjustarg}{650} +\glossaryentry{intseq.make@ {\memgloterm{intseq.make}}{\memglodesc{(\ref {intseq.make})}} {\memgloref{}}|memjustarg}{650} +\glossaryentry{type.traits@ {\memgloterm{type.traits}}{\memglodesc{(\ref {type.traits})}} {\memgloref{}}|memjustarg}{650} +\glossaryentry{type.traits.general@ {\memgloterm{type.traits.general}}{\memglodesc{(\ref {type.traits.general})}} {\memgloref{}}|memjustarg}{650} +\glossaryentry{meta.rqmts@ {\memgloterm{meta.rqmts}}{\memglodesc{(\ref {meta.rqmts})}} {\memgloref{}}|memjustarg}{651} +\glossaryentry{meta.type.synop@ {\memgloterm{meta.type.synop}}{\memglodesc{(\ref {meta.type.synop})}} {\memgloref{}}|memjustarg}{651} +\glossaryentry{meta.help@ {\memgloterm{meta.help}}{\memglodesc{(\ref {meta.help})}} {\memgloref{}}|memjustarg}{658} +\glossaryentry{meta.unary@ {\memgloterm{meta.unary}}{\memglodesc{(\ref {meta.unary})}} {\memgloref{}}|memjustarg}{658} +\glossaryentry{meta.unary.general@ {\memgloterm{meta.unary.general}}{\memglodesc{(\ref {meta.unary.general})}} {\memgloref{}}|memjustarg}{658} +\glossaryentry{meta.unary.cat@ {\memgloterm{meta.unary.cat}}{\memglodesc{(\ref {meta.unary.cat})}} {\memgloref{}}|memjustarg}{658} +\glossaryentry{meta.unary.comp@ {\memgloterm{meta.unary.comp}}{\memglodesc{(\ref {meta.unary.comp})}} {\memgloref{}}|memjustarg}{659} +\glossaryentry{meta.unary.prop@ {\memgloterm{meta.unary.prop}}{\memglodesc{(\ref {meta.unary.prop})}} {\memgloref{}}|memjustarg}{659} +\glossaryentry{meta.unary.prop.query@ {\memgloterm{meta.unary.prop.query}}{\memglodesc{(\ref {meta.unary.prop.query})}} {\memgloref{}}|memjustarg}{666} +\glossaryentry{meta.rel@ {\memgloterm{meta.rel}}{\memglodesc{(\ref {meta.rel})}} {\memgloref{}}|memjustarg}{667} +\glossaryentry{meta.trans@ {\memgloterm{meta.trans}}{\memglodesc{(\ref {meta.trans})}} {\memgloref{}}|memjustarg}{669} +\glossaryentry{meta.trans.general@ {\memgloterm{meta.trans.general}}{\memglodesc{(\ref {meta.trans.general})}} {\memgloref{}}|memjustarg}{669} +\glossaryentry{meta.trans.cv@ {\memgloterm{meta.trans.cv}}{\memglodesc{(\ref {meta.trans.cv})}} {\memgloref{}}|memjustarg}{669} +\glossaryentry{meta.trans.ref@ {\memgloterm{meta.trans.ref}}{\memglodesc{(\ref {meta.trans.ref})}} {\memgloref{}}|memjustarg}{669} +\glossaryentry{meta.trans.sign@ {\memgloterm{meta.trans.sign}}{\memglodesc{(\ref {meta.trans.sign})}} {\memgloref{}}|memjustarg}{670} +\glossaryentry{meta.trans.arr@ {\memgloterm{meta.trans.arr}}{\memglodesc{(\ref {meta.trans.arr})}} {\memgloref{}}|memjustarg}{670} +\glossaryentry{meta.trans.ptr@ {\memgloterm{meta.trans.ptr}}{\memglodesc{(\ref {meta.trans.ptr})}} {\memgloref{}}|memjustarg}{671} +\glossaryentry{meta.trans.other@ {\memgloterm{meta.trans.other}}{\memglodesc{(\ref {meta.trans.other})}} {\memgloref{}}|memjustarg}{671} +\glossaryentry{meta.logical@ {\memgloterm{meta.logical}}{\memglodesc{(\ref {meta.logical})}} {\memgloref{}}|memjustarg}{674} +\glossaryentry{meta.member@ {\memgloterm{meta.member}}{\memglodesc{(\ref {meta.member})}} {\memgloref{}}|memjustarg}{675} +\glossaryentry{meta.const.eval@ {\memgloterm{meta.const.eval}}{\memglodesc{(\ref {meta.const.eval})}} {\memgloref{}}|memjustarg}{675} +\glossaryentry{ratio@ {\memgloterm{ratio}}{\memglodesc{(\ref {ratio})}} {\memgloref{}}|memjustarg}{676} +\glossaryentry{ratio.general@ {\memgloterm{ratio.general}}{\memglodesc{(\ref {ratio.general})}} {\memgloref{}}|memjustarg}{676} +\glossaryentry{ratio.syn@ {\memgloterm{ratio.syn}}{\memglodesc{(\ref {ratio.syn})}} {\memgloref{}}|memjustarg}{676} +\glossaryentry{ratio.ratio@ {\memgloterm{ratio.ratio}}{\memglodesc{(\ref {ratio.ratio})}} {\memgloref{}}|memjustarg}{677} +\glossaryentry{ratio.arithmetic@ {\memgloterm{ratio.arithmetic}}{\memglodesc{(\ref {ratio.arithmetic})}} {\memgloref{}}|memjustarg}{677} +\glossaryentry{ratio.comparison@ {\memgloterm{ratio.comparison}}{\memglodesc{(\ref {ratio.comparison})}} {\memgloref{}}|memjustarg}{678} +\glossaryentry{ratio.si@ {\memgloterm{ratio.si}}{\memglodesc{(\ref {ratio.si})}} {\memgloref{}}|memjustarg}{678} +\glossaryentry{utilities@ {\memgloterm{utilities}}{\memglodesc{(\ref {utilities})}} {\memgloref{}}|memjustarg}{679} +\glossaryentry{utilities.general@ {\memgloterm{utilities.general}}{\memglodesc{(\ref {utilities.general})}} {\memgloref{}}|memjustarg}{679} +\glossaryentry{utility@ {\memgloterm{utility}}{\memglodesc{(\ref {utility})}} {\memgloref{}}|memjustarg}{679} +\glossaryentry{utility.syn@ {\memgloterm{utility.syn}}{\memglodesc{(\ref {utility.syn})}} {\memgloref{}}|memjustarg}{679} +\glossaryentry{utility.swap@ {\memgloterm{utility.swap}}{\memglodesc{(\ref {utility.swap})}} {\memgloref{}}|memjustarg}{682} +\glossaryentry{utility.exchange@ {\memgloterm{utility.exchange}}{\memglodesc{(\ref {utility.exchange})}} {\memgloref{}}|memjustarg}{682} +\glossaryentry{forward@ {\memgloterm{forward}}{\memglodesc{(\ref {forward})}} {\memgloref{}}|memjustarg}{682} +\glossaryentry{utility.as.const@ {\memgloterm{utility.as.const}}{\memglodesc{(\ref {utility.as.const})}} {\memgloref{}}|memjustarg}{684} +\glossaryentry{declval@ {\memgloterm{declval}}{\memglodesc{(\ref {declval})}} {\memgloref{}}|memjustarg}{684} +\glossaryentry{utility.intcmp@ {\memgloterm{utility.intcmp}}{\memglodesc{(\ref {utility.intcmp})}} {\memgloref{}}|memjustarg}{684} +\glossaryentry{utility.underlying@ {\memgloterm{utility.underlying}}{\memglodesc{(\ref {utility.underlying})}} {\memgloref{}}|memjustarg}{685} +\glossaryentry{utility.unreachable@ {\memgloterm{utility.unreachable}}{\memglodesc{(\ref {utility.unreachable})}} {\memgloref{}}|memjustarg}{685} +\glossaryentry{pairs@ {\memgloterm{pairs}}{\memglodesc{(\ref {pairs})}} {\memgloref{}}|memjustarg}{686} +\glossaryentry{pairs.general@ {\memgloterm{pairs.general}}{\memglodesc{(\ref {pairs.general})}} {\memgloref{}}|memjustarg}{686} +\glossaryentry{pairs.pair@ {\memgloterm{pairs.pair}}{\memglodesc{(\ref {pairs.pair})}} {\memgloref{}}|memjustarg}{686} +\glossaryentry{pairs.spec@ {\memgloterm{pairs.spec}}{\memglodesc{(\ref {pairs.spec})}} {\memgloref{}}|memjustarg}{690} +\glossaryentry{pair.astuple@ {\memgloterm{pair.astuple}}{\memglodesc{(\ref {pair.astuple})}} {\memgloref{}}|memjustarg}{690} +\glossaryentry{pair.piecewise@ {\memgloterm{pair.piecewise}}{\memglodesc{(\ref {pair.piecewise})}} {\memgloref{}}|memjustarg}{691} +\glossaryentry{tuple@ {\memgloterm{tuple}}{\memglodesc{(\ref {tuple})}} {\memgloref{}}|memjustarg}{691} +\glossaryentry{tuple.general@ {\memgloterm{tuple.general}}{\memglodesc{(\ref {tuple.general})}} {\memgloref{}}|memjustarg}{691} +\glossaryentry{tuple.syn@ {\memgloterm{tuple.syn}}{\memglodesc{(\ref {tuple.syn})}} {\memgloref{}}|memjustarg}{692} +\glossaryentry{tuple.like@ {\memgloterm{tuple.like}}{\memglodesc{(\ref {tuple.like})}} {\memgloref{}}|memjustarg}{693} +\glossaryentry{tuple.tuple@ {\memgloterm{tuple.tuple}}{\memglodesc{(\ref {tuple.tuple})}} {\memgloref{}}|memjustarg}{693} +\glossaryentry{tuple.cnstr@ {\memgloterm{tuple.cnstr}}{\memglodesc{(\ref {tuple.cnstr})}} {\memgloref{}}|memjustarg}{695} +\glossaryentry{tuple.assign@ {\memgloterm{tuple.assign}}{\memglodesc{(\ref {tuple.assign})}} {\memgloref{}}|memjustarg}{698} +\glossaryentry{tuple.swap@ {\memgloterm{tuple.swap}}{\memglodesc{(\ref {tuple.swap})}} {\memgloref{}}|memjustarg}{700} +\glossaryentry{tuple.creation@ {\memgloterm{tuple.creation}}{\memglodesc{(\ref {tuple.creation})}} {\memgloref{}}|memjustarg}{701} +\glossaryentry{tuple.apply@ {\memgloterm{tuple.apply}}{\memglodesc{(\ref {tuple.apply})}} {\memgloref{}}|memjustarg}{702} +\glossaryentry{tuple.helper@ {\memgloterm{tuple.helper}}{\memglodesc{(\ref {tuple.helper})}} {\memgloref{}}|memjustarg}{702} +\glossaryentry{tuple.elem@ {\memgloterm{tuple.elem}}{\memglodesc{(\ref {tuple.elem})}} {\memgloref{}}|memjustarg}{703} +\glossaryentry{tuple.rel@ {\memgloterm{tuple.rel}}{\memglodesc{(\ref {tuple.rel})}} {\memgloref{}}|memjustarg}{704} +\glossaryentry{tuple.common.ref@ {\memgloterm{tuple.common.ref}}{\memglodesc{(\ref {tuple.common.ref})}} {\memgloref{}}|memjustarg}{704} +\glossaryentry{tuple.traits@ {\memgloterm{tuple.traits}}{\memglodesc{(\ref {tuple.traits})}} {\memgloref{}}|memjustarg}{705} +\glossaryentry{tuple.special@ {\memgloterm{tuple.special}}{\memglodesc{(\ref {tuple.special})}} {\memgloref{}}|memjustarg}{705} +\glossaryentry{optional@ {\memgloterm{optional}}{\memglodesc{(\ref {optional})}} {\memgloref{}}|memjustarg}{705} +\glossaryentry{optional.general@ {\memgloterm{optional.general}}{\memglodesc{(\ref {optional.general})}} {\memgloref{}}|memjustarg}{705} +\glossaryentry{optional.syn@ {\memgloterm{optional.syn}}{\memglodesc{(\ref {optional.syn})}} {\memgloref{}}|memjustarg}{705} +\glossaryentry{optional.optional@ {\memgloterm{optional.optional}}{\memglodesc{(\ref {optional.optional})}} {\memgloref{}}|memjustarg}{707} +\glossaryentry{optional.optional.general@ {\memgloterm{optional.optional.general}}{\memglodesc{(\ref {optional.optional.general})}} {\memgloref{}}|memjustarg}{707} +\glossaryentry{optional.ctor@ {\memgloterm{optional.ctor}}{\memglodesc{(\ref {optional.ctor})}} {\memgloref{}}|memjustarg}{708} +\glossaryentry{optional.dtor@ {\memgloterm{optional.dtor}}{\memglodesc{(\ref {optional.dtor})}} {\memgloref{}}|memjustarg}{710} +\glossaryentry{optional.assign@ {\memgloterm{optional.assign}}{\memglodesc{(\ref {optional.assign})}} {\memgloref{}}|memjustarg}{710} +\glossaryentry{optional.swap@ {\memgloterm{optional.swap}}{\memglodesc{(\ref {optional.swap})}} {\memgloref{}}|memjustarg}{713} +\glossaryentry{optional.observe@ {\memgloterm{optional.observe}}{\memglodesc{(\ref {optional.observe})}} {\memgloref{}}|memjustarg}{713} +\glossaryentry{optional.monadic@ {\memgloterm{optional.monadic}}{\memglodesc{(\ref {optional.monadic})}} {\memgloref{}}|memjustarg}{714} +\glossaryentry{optional.mod@ {\memgloterm{optional.mod}}{\memglodesc{(\ref {optional.mod})}} {\memgloref{}}|memjustarg}{715} +\glossaryentry{optional.nullopt@ {\memgloterm{optional.nullopt}}{\memglodesc{(\ref {optional.nullopt})}} {\memgloref{}}|memjustarg}{715} +\glossaryentry{optional.bad.access@ {\memgloterm{optional.bad.access}}{\memglodesc{(\ref {optional.bad.access})}} {\memgloref{}}|memjustarg}{716} +\glossaryentry{optional.relops@ {\memgloterm{optional.relops}}{\memglodesc{(\ref {optional.relops})}} {\memgloref{}}|memjustarg}{716} +\glossaryentry{optional.nullops@ {\memgloterm{optional.nullops}}{\memglodesc{(\ref {optional.nullops})}} {\memgloref{}}|memjustarg}{717} +\glossaryentry{optional.comp.with.t@ {\memgloterm{optional.comp.with.t}}{\memglodesc{(\ref {optional.comp.with.t})}} {\memgloref{}}|memjustarg}{717} +\glossaryentry{optional.specalg@ {\memgloterm{optional.specalg}}{\memglodesc{(\ref {optional.specalg})}} {\memgloref{}}|memjustarg}{718} +\glossaryentry{optional.hash@ {\memgloterm{optional.hash}}{\memglodesc{(\ref {optional.hash})}} {\memgloref{}}|memjustarg}{718} +\glossaryentry{variant@ {\memgloterm{variant}}{\memglodesc{(\ref {variant})}} {\memgloref{}}|memjustarg}{718} +\glossaryentry{variant.general@ {\memgloterm{variant.general}}{\memglodesc{(\ref {variant.general})}} {\memgloref{}}|memjustarg}{718} +\glossaryentry{variant.syn@ {\memgloterm{variant.syn}}{\memglodesc{(\ref {variant.syn})}} {\memgloref{}}|memjustarg}{718} +\glossaryentry{variant.variant@ {\memgloterm{variant.variant}}{\memglodesc{(\ref {variant.variant})}} {\memgloref{}}|memjustarg}{720} +\glossaryentry{variant.variant.general@ {\memgloterm{variant.variant.general}}{\memglodesc{(\ref {variant.variant.general})}} {\memgloref{}}|memjustarg}{720} +\glossaryentry{variant.ctor@ {\memgloterm{variant.ctor}}{\memglodesc{(\ref {variant.ctor})}} {\memgloref{}}|memjustarg}{721} +\glossaryentry{variant.dtor@ {\memgloterm{variant.dtor}}{\memglodesc{(\ref {variant.dtor})}} {\memgloref{}}|memjustarg}{723} +\glossaryentry{variant.assign@ {\memgloterm{variant.assign}}{\memglodesc{(\ref {variant.assign})}} {\memgloref{}}|memjustarg}{723} +\glossaryentry{variant.mod@ {\memgloterm{variant.mod}}{\memglodesc{(\ref {variant.mod})}} {\memgloref{}}|memjustarg}{725} +\glossaryentry{variant.status@ {\memgloterm{variant.status}}{\memglodesc{(\ref {variant.status})}} {\memgloref{}}|memjustarg}{725} +\glossaryentry{variant.swap@ {\memgloterm{variant.swap}}{\memglodesc{(\ref {variant.swap})}} {\memgloref{}}|memjustarg}{726} +\glossaryentry{variant.helper@ {\memgloterm{variant.helper}}{\memglodesc{(\ref {variant.helper})}} {\memgloref{}}|memjustarg}{726} +\glossaryentry{variant.get@ {\memgloterm{variant.get}}{\memglodesc{(\ref {variant.get})}} {\memgloref{}}|memjustarg}{726} +\glossaryentry{variant.relops@ {\memgloterm{variant.relops}}{\memglodesc{(\ref {variant.relops})}} {\memgloref{}}|memjustarg}{727} +\glossaryentry{variant.visit@ {\memgloterm{variant.visit}}{\memglodesc{(\ref {variant.visit})}} {\memgloref{}}|memjustarg}{728} +\glossaryentry{variant.monostate@ {\memgloterm{variant.monostate}}{\memglodesc{(\ref {variant.monostate})}} {\memgloref{}}|memjustarg}{729} +\glossaryentry{variant.monostate.relops@ {\memgloterm{variant.monostate.relops}}{\memglodesc{(\ref {variant.monostate.relops})}} {\memgloref{}}|memjustarg}{729} +\glossaryentry{variant.specalg@ {\memgloterm{variant.specalg}}{\memglodesc{(\ref {variant.specalg})}} {\memgloref{}}|memjustarg}{729} +\glossaryentry{variant.bad.access@ {\memgloterm{variant.bad.access}}{\memglodesc{(\ref {variant.bad.access})}} {\memgloref{}}|memjustarg}{729} +\glossaryentry{variant.hash@ {\memgloterm{variant.hash}}{\memglodesc{(\ref {variant.hash})}} {\memgloref{}}|memjustarg}{729} +\glossaryentry{any@ {\memgloterm{any}}{\memglodesc{(\ref {any})}} {\memgloref{}}|memjustarg}{730} +\glossaryentry{any.general@ {\memgloterm{any.general}}{\memglodesc{(\ref {any.general})}} {\memgloref{}}|memjustarg}{730} +\glossaryentry{any.synop@ {\memgloterm{any.synop}}{\memglodesc{(\ref {any.synop})}} {\memgloref{}}|memjustarg}{730} +\glossaryentry{any.bad.any.cast@ {\memgloterm{any.bad.any.cast}}{\memglodesc{(\ref {any.bad.any.cast})}} {\memgloref{}}|memjustarg}{730} +\glossaryentry{any.class@ {\memgloterm{any.class}}{\memglodesc{(\ref {any.class})}} {\memgloref{}}|memjustarg}{730} +\glossaryentry{any.class.general@ {\memgloterm{any.class.general}}{\memglodesc{(\ref {any.class.general})}} {\memgloref{}}|memjustarg}{730} +\glossaryentry{any.cons@ {\memgloterm{any.cons}}{\memglodesc{(\ref {any.cons})}} {\memgloref{}}|memjustarg}{731} +\glossaryentry{any.assign@ {\memgloterm{any.assign}}{\memglodesc{(\ref {any.assign})}} {\memgloref{}}|memjustarg}{732} +\glossaryentry{any.modifiers@ {\memgloterm{any.modifiers}}{\memglodesc{(\ref {any.modifiers})}} {\memgloref{}}|memjustarg}{733} +\glossaryentry{any.observers@ {\memgloterm{any.observers}}{\memglodesc{(\ref {any.observers})}} {\memgloref{}}|memjustarg}{733} +\glossaryentry{any.nonmembers@ {\memgloterm{any.nonmembers}}{\memglodesc{(\ref {any.nonmembers})}} {\memgloref{}}|memjustarg}{734} +\glossaryentry{expected@ {\memgloterm{expected}}{\memglodesc{(\ref {expected})}} {\memgloref{}}|memjustarg}{735} +\glossaryentry{expected.general@ {\memgloterm{expected.general}}{\memglodesc{(\ref {expected.general})}} {\memgloref{}}|memjustarg}{735} +\glossaryentry{expected.syn@ {\memgloterm{expected.syn}}{\memglodesc{(\ref {expected.syn})}} {\memgloref{}}|memjustarg}{735} +\glossaryentry{expected.unexpected@ {\memgloterm{expected.unexpected}}{\memglodesc{(\ref {expected.unexpected})}} {\memgloref{}}|memjustarg}{735} +\glossaryentry{expected.un.general@ {\memgloterm{expected.un.general}}{\memglodesc{(\ref {expected.un.general})}} {\memgloref{}}|memjustarg}{735} +\glossaryentry{expected.un.cons@ {\memgloterm{expected.un.cons}}{\memglodesc{(\ref {expected.un.cons})}} {\memgloref{}}|memjustarg}{736} +\glossaryentry{expected.un.obs@ {\memgloterm{expected.un.obs}}{\memglodesc{(\ref {expected.un.obs})}} {\memgloref{}}|memjustarg}{736} +\glossaryentry{expected.un.swap@ {\memgloterm{expected.un.swap}}{\memglodesc{(\ref {expected.un.swap})}} {\memgloref{}}|memjustarg}{736} +\glossaryentry{expected.un.eq@ {\memgloterm{expected.un.eq}}{\memglodesc{(\ref {expected.un.eq})}} {\memgloref{}}|memjustarg}{737} +\glossaryentry{expected.bad@ {\memgloterm{expected.bad}}{\memglodesc{(\ref {expected.bad})}} {\memgloref{}}|memjustarg}{737} +\glossaryentry{expected.bad.void@ {\memgloterm{expected.bad.void}}{\memglodesc{(\ref {expected.bad.void})}} {\memgloref{}}|memjustarg}{737} +\glossaryentry{expected.expected@ {\memgloterm{expected.expected}}{\memglodesc{(\ref {expected.expected})}} {\memgloref{}}|memjustarg}{738} +\glossaryentry{expected.object.general@ {\memgloterm{expected.object.general}}{\memglodesc{(\ref {expected.object.general})}} {\memgloref{}}|memjustarg}{738} +\glossaryentry{expected.object.cons@ {\memgloterm{expected.object.cons}}{\memglodesc{(\ref {expected.object.cons})}} {\memgloref{}}|memjustarg}{740} +\glossaryentry{expected.object.dtor@ {\memgloterm{expected.object.dtor}}{\memglodesc{(\ref {expected.object.dtor})}} {\memgloref{}}|memjustarg}{742} +\glossaryentry{expected.object.assign@ {\memgloterm{expected.object.assign}}{\memglodesc{(\ref {expected.object.assign})}} {\memgloref{}}|memjustarg}{742} +\glossaryentry{expected.object.swap@ {\memgloterm{expected.object.swap}}{\memglodesc{(\ref {expected.object.swap})}} {\memgloref{}}|memjustarg}{744} +\glossaryentry{expected.object.obs@ {\memgloterm{expected.object.obs}}{\memglodesc{(\ref {expected.object.obs})}} {\memgloref{}}|memjustarg}{745} +\glossaryentry{expected.object.monadic@ {\memgloterm{expected.object.monadic}}{\memglodesc{(\ref {expected.object.monadic})}} {\memgloref{}}|memjustarg}{746} +\glossaryentry{expected.object.eq@ {\memgloterm{expected.object.eq}}{\memglodesc{(\ref {expected.object.eq})}} {\memgloref{}}|memjustarg}{748} +\glossaryentry{expected.void@ {\memgloterm{expected.void}}{\memglodesc{(\ref {expected.void})}} {\memgloref{}}|memjustarg}{749} +\glossaryentry{expected.void.general@ {\memgloterm{expected.void.general}}{\memglodesc{(\ref {expected.void.general})}} {\memgloref{}}|memjustarg}{749} +\glossaryentry{expected.void.cons@ {\memgloterm{expected.void.cons}}{\memglodesc{(\ref {expected.void.cons})}} {\memgloref{}}|memjustarg}{750} +\glossaryentry{expected.void.dtor@ {\memgloterm{expected.void.dtor}}{\memglodesc{(\ref {expected.void.dtor})}} {\memgloref{}}|memjustarg}{751} +\glossaryentry{expected.void.assign@ {\memgloterm{expected.void.assign}}{\memglodesc{(\ref {expected.void.assign})}} {\memgloref{}}|memjustarg}{752} +\glossaryentry{expected.void.swap@ {\memgloterm{expected.void.swap}}{\memglodesc{(\ref {expected.void.swap})}} {\memgloref{}}|memjustarg}{752} +\glossaryentry{expected.void.obs@ {\memgloterm{expected.void.obs}}{\memglodesc{(\ref {expected.void.obs})}} {\memgloref{}}|memjustarg}{753} +\glossaryentry{expected.void.monadic@ {\memgloterm{expected.void.monadic}}{\memglodesc{(\ref {expected.void.monadic})}} {\memgloref{}}|memjustarg}{753} +\glossaryentry{expected.void.eq@ {\memgloterm{expected.void.eq}}{\memglodesc{(\ref {expected.void.eq})}} {\memgloref{}}|memjustarg}{755} +\glossaryentry{bitset@ {\memgloterm{bitset}}{\memglodesc{(\ref {bitset})}} {\memgloref{}}|memjustarg}{755} +\glossaryentry{bitset.syn@ {\memgloterm{bitset.syn}}{\memglodesc{(\ref {bitset.syn})}} {\memgloref{}}|memjustarg}{755} +\glossaryentry{template.bitset@ {\memgloterm{template.bitset}}{\memglodesc{(\ref {template.bitset})}} {\memgloref{}}|memjustarg}{756} +\glossaryentry{template.bitset.general@ {\memgloterm{template.bitset.general}}{\memglodesc{(\ref {template.bitset.general})}} {\memgloref{}}|memjustarg}{756} +\glossaryentry{bitset.cons@ {\memgloterm{bitset.cons}}{\memglodesc{(\ref {bitset.cons})}} {\memgloref{}}|memjustarg}{757} +\glossaryentry{bitset.members@ {\memgloterm{bitset.members}}{\memglodesc{(\ref {bitset.members})}} {\memgloref{}}|memjustarg}{758} +\glossaryentry{bitset.hash@ {\memgloterm{bitset.hash}}{\memglodesc{(\ref {bitset.hash})}} {\memgloref{}}|memjustarg}{760} +\glossaryentry{bitset.operators@ {\memgloterm{bitset.operators}}{\memglodesc{(\ref {bitset.operators})}} {\memgloref{}}|memjustarg}{760} +\glossaryentry{function.objects@ {\memgloterm{function.objects}}{\memglodesc{(\ref {function.objects})}} {\memgloref{}}|memjustarg}{761} +\glossaryentry{function.objects.general@ {\memgloterm{function.objects.general}}{\memglodesc{(\ref {function.objects.general})}} {\memgloref{}}|memjustarg}{761} +\glossaryentry{functional.syn@ {\memgloterm{functional.syn}}{\memglodesc{(\ref {functional.syn})}} {\memgloref{}}|memjustarg}{761} +\glossaryentry{func.def@ {\memgloterm{func.def}}{\memglodesc{(\ref {func.def})}} {\memgloref{}}|memjustarg}{764} +\glossaryentry{func.require@ {\memgloterm{func.require}}{\memglodesc{(\ref {func.require})}} {\memgloref{}}|memjustarg}{764} +\glossaryentry{func.invoke@ {\memgloterm{func.invoke}}{\memglodesc{(\ref {func.invoke})}} {\memgloref{}}|memjustarg}{765} +\glossaryentry{refwrap@ {\memgloterm{refwrap}}{\memglodesc{(\ref {refwrap})}} {\memgloref{}}|memjustarg}{766} +\glossaryentry{refwrap.general@ {\memgloterm{refwrap.general}}{\memglodesc{(\ref {refwrap.general})}} {\memgloref{}}|memjustarg}{766} +\glossaryentry{refwrap.const@ {\memgloterm{refwrap.const}}{\memglodesc{(\ref {refwrap.const})}} {\memgloref{}}|memjustarg}{766} +\glossaryentry{refwrap.assign@ {\memgloterm{refwrap.assign}}{\memglodesc{(\ref {refwrap.assign})}} {\memgloref{}}|memjustarg}{766} +\glossaryentry{refwrap.access@ {\memgloterm{refwrap.access}}{\memglodesc{(\ref {refwrap.access})}} {\memgloref{}}|memjustarg}{766} +\glossaryentry{refwrap.invoke@ {\memgloterm{refwrap.invoke}}{\memglodesc{(\ref {refwrap.invoke})}} {\memgloref{}}|memjustarg}{767} +\glossaryentry{refwrap.helpers@ {\memgloterm{refwrap.helpers}}{\memglodesc{(\ref {refwrap.helpers})}} {\memgloref{}}|memjustarg}{767} +\glossaryentry{refwrap.common.ref@ {\memgloterm{refwrap.common.ref}}{\memglodesc{(\ref {refwrap.common.ref})}} {\memgloref{}}|memjustarg}{767} +\glossaryentry{arithmetic.operations@ {\memgloterm{arithmetic.operations}}{\memglodesc{(\ref {arithmetic.operations})}} {\memgloref{}}|memjustarg}{767} +\glossaryentry{arithmetic.operations.general@ {\memgloterm{arithmetic.operations.general}}{\memglodesc{(\ref {arithmetic.operations.general})}} {\memgloref{}}|memjustarg}{767} +\glossaryentry{arithmetic.operations.plus@ {\memgloterm{arithmetic.operations.plus}}{\memglodesc{(\ref {arithmetic.operations.plus})}} {\memgloref{}}|memjustarg}{768} +\glossaryentry{arithmetic.operations.minus@ {\memgloterm{arithmetic.operations.minus}}{\memglodesc{(\ref {arithmetic.operations.minus})}} {\memgloref{}}|memjustarg}{768} +\glossaryentry{arithmetic.operations.multiplies@ {\memgloterm{arithmetic.operations.multiplies}}{\memglodesc{(\ref {arithmetic.operations.multiplies})}} {\memgloref{}}|memjustarg}{768} +\glossaryentry{arithmetic.operations.divides@ {\memgloterm{arithmetic.operations.divides}}{\memglodesc{(\ref {arithmetic.operations.divides})}} {\memgloref{}}|memjustarg}{768} +\glossaryentry{arithmetic.operations.modulus@ {\memgloterm{arithmetic.operations.modulus}}{\memglodesc{(\ref {arithmetic.operations.modulus})}} {\memgloref{}}|memjustarg}{769} +\glossaryentry{arithmetic.operations.negate@ {\memgloterm{arithmetic.operations.negate}}{\memglodesc{(\ref {arithmetic.operations.negate})}} {\memgloref{}}|memjustarg}{769} +\glossaryentry{comparisons@ {\memgloterm{comparisons}}{\memglodesc{(\ref {comparisons})}} {\memgloref{}}|memjustarg}{769} +\glossaryentry{comparisons.general@ {\memgloterm{comparisons.general}}{\memglodesc{(\ref {comparisons.general})}} {\memgloref{}}|memjustarg}{769} +\glossaryentry{comparisons.equal.to@ {\memgloterm{comparisons.equal.to}}{\memglodesc{(\ref {comparisons.equal.to})}} {\memgloref{}}|memjustarg}{770} +\glossaryentry{comparisons.not.equal.to@ {\memgloterm{comparisons.not.equal.to}}{\memglodesc{(\ref {comparisons.not.equal.to})}} {\memgloref{}}|memjustarg}{770} +\glossaryentry{comparisons.greater@ {\memgloterm{comparisons.greater}}{\memglodesc{(\ref {comparisons.greater})}} {\memgloref{}}|memjustarg}{770} +\glossaryentry{comparisons.less@ {\memgloterm{comparisons.less}}{\memglodesc{(\ref {comparisons.less})}} {\memgloref{}}|memjustarg}{771} +\glossaryentry{comparisons.greater.equal@ {\memgloterm{comparisons.greater.equal}}{\memglodesc{(\ref {comparisons.greater.equal})}} {\memgloref{}}|memjustarg}{771} +\glossaryentry{comparisons.less.equal@ {\memgloterm{comparisons.less.equal}}{\memglodesc{(\ref {comparisons.less.equal})}} {\memgloref{}}|memjustarg}{771} +\glossaryentry{comparisons.three.way@ {\memgloterm{comparisons.three.way}}{\memglodesc{(\ref {comparisons.three.way})}} {\memgloref{}}|memjustarg}{772} +\glossaryentry{range.cmp@ {\memgloterm{range.cmp}}{\memglodesc{(\ref {range.cmp})}} {\memgloref{}}|memjustarg}{772} +\glossaryentry{logical.operations@ {\memgloterm{logical.operations}}{\memglodesc{(\ref {logical.operations})}} {\memgloref{}}|memjustarg}{774} +\glossaryentry{logical.operations.general@ {\memgloterm{logical.operations.general}}{\memglodesc{(\ref {logical.operations.general})}} {\memgloref{}}|memjustarg}{774} +\glossaryentry{logical.operations.and@ {\memgloterm{logical.operations.and}}{\memglodesc{(\ref {logical.operations.and})}} {\memgloref{}}|memjustarg}{774} +\glossaryentry{logical.operations.or@ {\memgloterm{logical.operations.or}}{\memglodesc{(\ref {logical.operations.or})}} {\memgloref{}}|memjustarg}{774} +\glossaryentry{logical.operations.not@ {\memgloterm{logical.operations.not}}{\memglodesc{(\ref {logical.operations.not})}} {\memgloref{}}|memjustarg}{774} +\glossaryentry{bitwise.operations@ {\memgloterm{bitwise.operations}}{\memglodesc{(\ref {bitwise.operations})}} {\memgloref{}}|memjustarg}{775} +\glossaryentry{bitwise.operations.general@ {\memgloterm{bitwise.operations.general}}{\memglodesc{(\ref {bitwise.operations.general})}} {\memgloref{}}|memjustarg}{775} +\glossaryentry{bitwise.operations.and@ {\memgloterm{bitwise.operations.and}}{\memglodesc{(\ref {bitwise.operations.and})}} {\memgloref{}}|memjustarg}{775} +\glossaryentry{bitwise.operations.or@ {\memgloterm{bitwise.operations.or}}{\memglodesc{(\ref {bitwise.operations.or})}} {\memgloref{}}|memjustarg}{775} +\glossaryentry{bitwise.operations.xor@ {\memgloterm{bitwise.operations.xor}}{\memglodesc{(\ref {bitwise.operations.xor})}} {\memgloref{}}|memjustarg}{775} +\glossaryentry{bitwise.operations.not@ {\memgloterm{bitwise.operations.not}}{\memglodesc{(\ref {bitwise.operations.not})}} {\memgloref{}}|memjustarg}{776} +\glossaryentry{func.identity@ {\memgloterm{func.identity}}{\memglodesc{(\ref {func.identity})}} {\memgloref{}}|memjustarg}{776} +\glossaryentry{func.not.fn@ {\memgloterm{func.not.fn}}{\memglodesc{(\ref {func.not.fn})}} {\memgloref{}}|memjustarg}{776} +\glossaryentry{func.bind.partial@ {\memgloterm{func.bind.partial}}{\memglodesc{(\ref {func.bind.partial})}} {\memgloref{}}|memjustarg}{776} +\glossaryentry{func.bind@ {\memgloterm{func.bind}}{\memglodesc{(\ref {func.bind})}} {\memgloref{}}|memjustarg}{777} +\glossaryentry{func.bind.general@ {\memgloterm{func.bind.general}}{\memglodesc{(\ref {func.bind.general})}} {\memgloref{}}|memjustarg}{777} +\glossaryentry{func.bind.isbind@ {\memgloterm{func.bind.isbind}}{\memglodesc{(\ref {func.bind.isbind})}} {\memgloref{}}|memjustarg}{777} +\glossaryentry{func.bind.isplace@ {\memgloterm{func.bind.isplace}}{\memglodesc{(\ref {func.bind.isplace})}} {\memgloref{}}|memjustarg}{777} +\glossaryentry{func.bind.bind@ {\memgloterm{func.bind.bind}}{\memglodesc{(\ref {func.bind.bind})}} {\memgloref{}}|memjustarg}{777} +\glossaryentry{func.bind.place@ {\memgloterm{func.bind.place}}{\memglodesc{(\ref {func.bind.place})}} {\memgloref{}}|memjustarg}{778} +\glossaryentry{func.memfn@ {\memgloterm{func.memfn}}{\memglodesc{(\ref {func.memfn})}} {\memgloref{}}|memjustarg}{779} +\glossaryentry{func.wrap@ {\memgloterm{func.wrap}}{\memglodesc{(\ref {func.wrap})}} {\memgloref{}}|memjustarg}{779} +\glossaryentry{func.wrap.general@ {\memgloterm{func.wrap.general}}{\memglodesc{(\ref {func.wrap.general})}} {\memgloref{}}|memjustarg}{779} +\glossaryentry{func.wrap.badcall@ {\memgloterm{func.wrap.badcall}}{\memglodesc{(\ref {func.wrap.badcall})}} {\memgloref{}}|memjustarg}{779} +\glossaryentry{func.wrap.func@ {\memgloterm{func.wrap.func}}{\memglodesc{(\ref {func.wrap.func})}} {\memgloref{}}|memjustarg}{779} +\glossaryentry{func.wrap.func.general@ {\memgloterm{func.wrap.func.general}}{\memglodesc{(\ref {func.wrap.func.general})}} {\memgloref{}}|memjustarg}{779} +\glossaryentry{func.wrap.func.con@ {\memgloterm{func.wrap.func.con}}{\memglodesc{(\ref {func.wrap.func.con})}} {\memgloref{}}|memjustarg}{780} +\glossaryentry{func.wrap.func.mod@ {\memgloterm{func.wrap.func.mod}}{\memglodesc{(\ref {func.wrap.func.mod})}} {\memgloref{}}|memjustarg}{782} +\glossaryentry{func.wrap.func.cap@ {\memgloterm{func.wrap.func.cap}}{\memglodesc{(\ref {func.wrap.func.cap})}} {\memgloref{}}|memjustarg}{782} +\glossaryentry{func.wrap.func.inv@ {\memgloterm{func.wrap.func.inv}}{\memglodesc{(\ref {func.wrap.func.inv})}} {\memgloref{}}|memjustarg}{782} +\glossaryentry{func.wrap.func.targ@ {\memgloterm{func.wrap.func.targ}}{\memglodesc{(\ref {func.wrap.func.targ})}} {\memgloref{}}|memjustarg}{782} +\glossaryentry{func.wrap.func.nullptr@ {\memgloterm{func.wrap.func.nullptr}}{\memglodesc{(\ref {func.wrap.func.nullptr})}} {\memgloref{}}|memjustarg}{782} +\glossaryentry{func.wrap.func.alg@ {\memgloterm{func.wrap.func.alg}}{\memglodesc{(\ref {func.wrap.func.alg})}} {\memgloref{}}|memjustarg}{782} +\glossaryentry{func.wrap.move@ {\memgloterm{func.wrap.move}}{\memglodesc{(\ref {func.wrap.move})}} {\memgloref{}}|memjustarg}{782} +\glossaryentry{func.wrap.move.general@ {\memgloterm{func.wrap.move.general}}{\memglodesc{(\ref {func.wrap.move.general})}} {\memgloref{}}|memjustarg}{782} +\glossaryentry{func.wrap.move.class@ {\memgloterm{func.wrap.move.class}}{\memglodesc{(\ref {func.wrap.move.class})}} {\memgloref{}}|memjustarg}{782} +\glossaryentry{func.wrap.move.ctor@ {\memgloterm{func.wrap.move.ctor}}{\memglodesc{(\ref {func.wrap.move.ctor})}} {\memgloref{}}|memjustarg}{783} +\glossaryentry{func.wrap.move.inv@ {\memgloterm{func.wrap.move.inv}}{\memglodesc{(\ref {func.wrap.move.inv})}} {\memgloref{}}|memjustarg}{785} +\glossaryentry{func.wrap.move.util@ {\memgloterm{func.wrap.move.util}}{\memglodesc{(\ref {func.wrap.move.util})}} {\memgloref{}}|memjustarg}{785} +\glossaryentry{func.search@ {\memgloterm{func.search}}{\memglodesc{(\ref {func.search})}} {\memgloref{}}|memjustarg}{785} +\glossaryentry{func.search.general@ {\memgloterm{func.search.general}}{\memglodesc{(\ref {func.search.general})}} {\memgloref{}}|memjustarg}{785} +\glossaryentry{func.search.default@ {\memgloterm{func.search.default}}{\memglodesc{(\ref {func.search.default})}} {\memgloref{}}|memjustarg}{786} +\glossaryentry{func.search.bm@ {\memgloterm{func.search.bm}}{\memglodesc{(\ref {func.search.bm})}} {\memgloref{}}|memjustarg}{786} +\glossaryentry{func.search.bmh@ {\memgloterm{func.search.bmh}}{\memglodesc{(\ref {func.search.bmh})}} {\memgloref{}}|memjustarg}{787} +\glossaryentry{unord.hash@ {\memgloterm{unord.hash}}{\memglodesc{(\ref {unord.hash})}} {\memgloref{}}|memjustarg}{788} +\glossaryentry{type.index@ {\memgloterm{type.index}}{\memglodesc{(\ref {type.index})}} {\memgloref{}}|memjustarg}{789} +\glossaryentry{type.index.synopsis@ {\memgloterm{type.index.synopsis}}{\memglodesc{(\ref {type.index.synopsis})}} {\memgloref{}}|memjustarg}{789} +\glossaryentry{type.index.overview@ {\memgloterm{type.index.overview}}{\memglodesc{(\ref {type.index.overview})}} {\memgloref{}}|memjustarg}{789} +\glossaryentry{type.index.members@ {\memgloterm{type.index.members}}{\memglodesc{(\ref {type.index.members})}} {\memgloref{}}|memjustarg}{789} +\glossaryentry{type.index.hash@ {\memgloterm{type.index.hash}}{\memglodesc{(\ref {type.index.hash})}} {\memgloref{}}|memjustarg}{790} +\glossaryentry{execpol@ {\memgloterm{execpol}}{\memglodesc{(\ref {execpol})}} {\memgloref{}}|memjustarg}{790} +\glossaryentry{execpol.general@ {\memgloterm{execpol.general}}{\memglodesc{(\ref {execpol.general})}} {\memgloref{}}|memjustarg}{790} +\glossaryentry{execution.syn@ {\memgloterm{execution.syn}}{\memglodesc{(\ref {execution.syn})}} {\memgloref{}}|memjustarg}{790} +\glossaryentry{execpol.type@ {\memgloterm{execpol.type}}{\memglodesc{(\ref {execpol.type})}} {\memgloref{}}|memjustarg}{791} +\glossaryentry{execpol.seq@ {\memgloterm{execpol.seq}}{\memglodesc{(\ref {execpol.seq})}} {\memgloref{}}|memjustarg}{791} +\glossaryentry{execpol.par@ {\memgloterm{execpol.par}}{\memglodesc{(\ref {execpol.par})}} {\memgloref{}}|memjustarg}{791} +\glossaryentry{execpol.parunseq@ {\memgloterm{execpol.parunseq}}{\memglodesc{(\ref {execpol.parunseq})}} {\memgloref{}}|memjustarg}{791} +\glossaryentry{execpol.unseq@ {\memgloterm{execpol.unseq}}{\memglodesc{(\ref {execpol.unseq})}} {\memgloref{}}|memjustarg}{791} +\glossaryentry{execpol.objects@ {\memgloterm{execpol.objects}}{\memglodesc{(\ref {execpol.objects})}} {\memgloref{}}|memjustarg}{791} +\glossaryentry{charconv@ {\memgloterm{charconv}}{\memglodesc{(\ref {charconv})}} {\memgloref{}}|memjustarg}{792} +\glossaryentry{charconv.syn@ {\memgloterm{charconv.syn}}{\memglodesc{(\ref {charconv.syn})}} {\memgloref{}}|memjustarg}{792} +\glossaryentry{charconv.to.chars@ {\memgloterm{charconv.to.chars}}{\memglodesc{(\ref {charconv.to.chars})}} {\memgloref{}}|memjustarg}{792} +\glossaryentry{charconv.from.chars@ {\memgloterm{charconv.from.chars}}{\memglodesc{(\ref {charconv.from.chars})}} {\memgloref{}}|memjustarg}{793} +\glossaryentry{format@ {\memgloterm{format}}{\memglodesc{(\ref {format})}} {\memgloref{}}|memjustarg}{794} +\glossaryentry{format.syn@ {\memgloterm{format.syn}}{\memglodesc{(\ref {format.syn})}} {\memgloref{}}|memjustarg}{794} +\glossaryentry{format.string@ {\memgloterm{format.string}}{\memglodesc{(\ref {format.string})}} {\memgloref{}}|memjustarg}{796} +\glossaryentry{format.string.general@ {\memgloterm{format.string.general}}{\memglodesc{(\ref {format.string.general})}} {\memgloref{}}|memjustarg}{796} +\glossaryentry{format.string.std@ {\memgloterm{format.string.std}}{\memglodesc{(\ref {format.string.std})}} {\memgloref{}}|memjustarg}{798} +\glossaryentry{format.err.report@ {\memgloterm{format.err.report}}{\memglodesc{(\ref {format.err.report})}} {\memgloref{}}|memjustarg}{802} +\glossaryentry{format.fmt.string@ {\memgloterm{format.fmt.string}}{\memglodesc{(\ref {format.fmt.string})}} {\memgloref{}}|memjustarg}{802} +\glossaryentry{format.functions@ {\memgloterm{format.functions}}{\memglodesc{(\ref {format.functions})}} {\memgloref{}}|memjustarg}{803} +\glossaryentry{format.formatter@ {\memgloterm{format.formatter}}{\memglodesc{(\ref {format.formatter})}} {\memgloref{}}|memjustarg}{805} +\glossaryentry{formatter.requirements@ {\memgloterm{formatter.requirements}}{\memglodesc{(\ref {formatter.requirements})}} {\memgloref{}}|memjustarg}{805} +\glossaryentry{format.formattable@ {\memgloterm{format.formattable}}{\memglodesc{(\ref {format.formattable})}} {\memgloref{}}|memjustarg}{805} +\glossaryentry{format.formatter.spec@ {\memgloterm{format.formatter.spec}}{\memglodesc{(\ref {format.formatter.spec})}} {\memgloref{}}|memjustarg}{806} +\glossaryentry{format.string.escaped@ {\memgloterm{format.string.escaped}}{\memglodesc{(\ref {format.string.escaped})}} {\memgloref{}}|memjustarg}{807} +\glossaryentry{format.parse.ctx@ {\memgloterm{format.parse.ctx}}{\memglodesc{(\ref {format.parse.ctx})}} {\memgloref{}}|memjustarg}{808} +\glossaryentry{format.context@ {\memgloterm{format.context}}{\memglodesc{(\ref {format.context})}} {\memgloref{}}|memjustarg}{810} +\glossaryentry{format.range@ {\memgloterm{format.range}}{\memglodesc{(\ref {format.range})}} {\memgloref{}}|memjustarg}{811} +\glossaryentry{format.range.fmtkind@ {\memgloterm{format.range.fmtkind}}{\memglodesc{(\ref {format.range.fmtkind})}} {\memgloref{}}|memjustarg}{811} +\glossaryentry{format.range.formatter@ {\memgloterm{format.range.formatter}}{\memglodesc{(\ref {format.range.formatter})}} {\memgloref{}}|memjustarg}{811} +\glossaryentry{format.range.fmtdef@ {\memgloterm{format.range.fmtdef}}{\memglodesc{(\ref {format.range.fmtdef})}} {\memgloref{}}|memjustarg}{813} +\glossaryentry{format.range.fmtmap@ {\memgloterm{format.range.fmtmap}}{\memglodesc{(\ref {format.range.fmtmap})}} {\memgloref{}}|memjustarg}{814} +\glossaryentry{format.range.fmtset@ {\memgloterm{format.range.fmtset}}{\memglodesc{(\ref {format.range.fmtset})}} {\memgloref{}}|memjustarg}{815} +\glossaryentry{format.range.fmtstr@ {\memgloterm{format.range.fmtstr}}{\memglodesc{(\ref {format.range.fmtstr})}} {\memgloref{}}|memjustarg}{815} +\glossaryentry{format.arguments@ {\memgloterm{format.arguments}}{\memglodesc{(\ref {format.arguments})}} {\memgloref{}}|memjustarg}{816} +\glossaryentry{format.arg@ {\memgloterm{format.arg}}{\memglodesc{(\ref {format.arg})}} {\memgloref{}}|memjustarg}{816} +\glossaryentry{format.arg.store@ {\memgloterm{format.arg.store}}{\memglodesc{(\ref {format.arg.store})}} {\memgloref{}}|memjustarg}{818} +\glossaryentry{format.args@ {\memgloterm{format.args}}{\memglodesc{(\ref {format.args})}} {\memgloref{}}|memjustarg}{818} +\glossaryentry{format.tuple@ {\memgloterm{format.tuple}}{\memglodesc{(\ref {format.tuple})}} {\memgloref{}}|memjustarg}{819} +\glossaryentry{format.error@ {\memgloterm{format.error}}{\memglodesc{(\ref {format.error})}} {\memgloref{}}|memjustarg}{820} +\glossaryentry{bit@ {\memgloterm{bit}}{\memglodesc{(\ref {bit})}} {\memgloref{}}|memjustarg}{821} +\glossaryentry{bit.general@ {\memgloterm{bit.general}}{\memglodesc{(\ref {bit.general})}} {\memgloref{}}|memjustarg}{821} +\glossaryentry{bit.syn@ {\memgloterm{bit.syn}}{\memglodesc{(\ref {bit.syn})}} {\memgloref{}}|memjustarg}{821} +\glossaryentry{bit.cast@ {\memgloterm{bit.cast}}{\memglodesc{(\ref {bit.cast})}} {\memgloref{}}|memjustarg}{821} +\glossaryentry{bit.byteswap@ {\memgloterm{bit.byteswap}}{\memglodesc{(\ref {bit.byteswap})}} {\memgloref{}}|memjustarg}{822} +\glossaryentry{bit.pow.two@ {\memgloterm{bit.pow.two}}{\memglodesc{(\ref {bit.pow.two})}} {\memgloref{}}|memjustarg}{822} +\glossaryentry{bit.rotate@ {\memgloterm{bit.rotate}}{\memglodesc{(\ref {bit.rotate})}} {\memgloref{}}|memjustarg}{823} +\glossaryentry{bit.count@ {\memgloterm{bit.count}}{\memglodesc{(\ref {bit.count})}} {\memgloref{}}|memjustarg}{823} +\glossaryentry{bit.endian@ {\memgloterm{bit.endian}}{\memglodesc{(\ref {bit.endian})}} {\memgloref{}}|memjustarg}{824} +\glossaryentry{strings@ {\memgloterm{strings}}{\memglodesc{(\ref {strings})}} {\memgloref{}}|memjustarg}{825} +\glossaryentry{strings.general@ {\memgloterm{strings.general}}{\memglodesc{(\ref {strings.general})}} {\memgloref{}}|memjustarg}{825} +\glossaryentry{char.traits@ {\memgloterm{char.traits}}{\memglodesc{(\ref {char.traits})}} {\memgloref{}}|memjustarg}{825} +\glossaryentry{char.traits.general@ {\memgloterm{char.traits.general}}{\memglodesc{(\ref {char.traits.general})}} {\memgloref{}}|memjustarg}{825} +\glossaryentry{char.traits.require@ {\memgloterm{char.traits.require}}{\memglodesc{(\ref {char.traits.require})}} {\memgloref{}}|memjustarg}{825} +\glossaryentry{char.traits.typedefs@ {\memgloterm{char.traits.typedefs}}{\memglodesc{(\ref {char.traits.typedefs})}} {\memgloref{}}|memjustarg}{827} +\glossaryentry{char.traits.specializations@ {\memgloterm{char.traits.specializations}}{\memglodesc{(\ref {char.traits.specializations})}} {\memgloref{}}|memjustarg}{827} +\glossaryentry{char.traits.specializations.general@ {\memgloterm{char.traits.specializations.general}}{\memglodesc{(\ref {char.traits.specializations.general})}} {\memgloref{}}|memjustarg}{827} +\glossaryentry{char.traits.specializations.char@ {\memgloterm{char.traits.specializations.char}}{\memglodesc{(\ref {char.traits.specializations.char})}} {\memgloref{}}|memjustarg}{827} +\glossaryentry{char.traits.specializations.char8.t@ {\memgloterm{char.traits.specializations.char8.t}}{\memglodesc{(\ref {char.traits.specializations.char8.t})}} {\memgloref{}}|memjustarg}{828} +\glossaryentry{char.traits.specializations.char16.t@ {\memgloterm{char.traits.specializations.char16.t}}{\memglodesc{(\ref {char.traits.specializations.char16.t})}} {\memgloref{}}|memjustarg}{828} +\glossaryentry{char.traits.specializations.char32.t@ {\memgloterm{char.traits.specializations.char32.t}}{\memglodesc{(\ref {char.traits.specializations.char32.t})}} {\memgloref{}}|memjustarg}{829} +\glossaryentry{char.traits.specializations.wchar.t@ {\memgloterm{char.traits.specializations.wchar.t}}{\memglodesc{(\ref {char.traits.specializations.wchar.t})}} {\memgloref{}}|memjustarg}{830} +\glossaryentry{string.view@ {\memgloterm{string.view}}{\memglodesc{(\ref {string.view})}} {\memgloref{}}|memjustarg}{830} +\glossaryentry{string.view.general@ {\memgloterm{string.view.general}}{\memglodesc{(\ref {string.view.general})}} {\memgloref{}}|memjustarg}{830} +\glossaryentry{string.view.synop@ {\memgloterm{string.view.synop}}{\memglodesc{(\ref {string.view.synop})}} {\memgloref{}}|memjustarg}{830} +\glossaryentry{string.view.template@ {\memgloterm{string.view.template}}{\memglodesc{(\ref {string.view.template})}} {\memgloref{}}|memjustarg}{831} +\glossaryentry{string.view.template.general@ {\memgloterm{string.view.template.general}}{\memglodesc{(\ref {string.view.template.general})}} {\memgloref{}}|memjustarg}{831} +\glossaryentry{string.view.cons@ {\memgloterm{string.view.cons}}{\memglodesc{(\ref {string.view.cons})}} {\memgloref{}}|memjustarg}{833} +\glossaryentry{string.view.deduct@ {\memgloterm{string.view.deduct}}{\memglodesc{(\ref {string.view.deduct})}} {\memgloref{}}|memjustarg}{834} +\glossaryentry{string.view.iterators@ {\memgloterm{string.view.iterators}}{\memglodesc{(\ref {string.view.iterators})}} {\memgloref{}}|memjustarg}{834} +\glossaryentry{string.view.capacity@ {\memgloterm{string.view.capacity}}{\memglodesc{(\ref {string.view.capacity})}} {\memgloref{}}|memjustarg}{835} +\glossaryentry{string.view.access@ {\memgloterm{string.view.access}}{\memglodesc{(\ref {string.view.access})}} {\memgloref{}}|memjustarg}{835} +\glossaryentry{string.view.modifiers@ {\memgloterm{string.view.modifiers}}{\memglodesc{(\ref {string.view.modifiers})}} {\memgloref{}}|memjustarg}{836} +\glossaryentry{string.view.ops@ {\memgloterm{string.view.ops}}{\memglodesc{(\ref {string.view.ops})}} {\memgloref{}}|memjustarg}{836} +\glossaryentry{string.view.find@ {\memgloterm{string.view.find}}{\memglodesc{(\ref {string.view.find})}} {\memgloref{}}|memjustarg}{837} +\glossaryentry{string.view.comparison@ {\memgloterm{string.view.comparison}}{\memglodesc{(\ref {string.view.comparison})}} {\memgloref{}}|memjustarg}{838} +\glossaryentry{string.view.io@ {\memgloterm{string.view.io}}{\memglodesc{(\ref {string.view.io})}} {\memgloref{}}|memjustarg}{839} +\glossaryentry{string.view.hash@ {\memgloterm{string.view.hash}}{\memglodesc{(\ref {string.view.hash})}} {\memgloref{}}|memjustarg}{840} +\glossaryentry{string.view.literals@ {\memgloterm{string.view.literals}}{\memglodesc{(\ref {string.view.literals})}} {\memgloref{}}|memjustarg}{840} +\glossaryentry{string.classes@ {\memgloterm{string.classes}}{\memglodesc{(\ref {string.classes})}} {\memgloref{}}|memjustarg}{840} +\glossaryentry{string.classes.general@ {\memgloterm{string.classes.general}}{\memglodesc{(\ref {string.classes.general})}} {\memgloref{}}|memjustarg}{840} +\glossaryentry{string.syn@ {\memgloterm{string.syn}}{\memglodesc{(\ref {string.syn})}} {\memgloref{}}|memjustarg}{840} +\glossaryentry{basic.string@ {\memgloterm{basic.string}}{\memglodesc{(\ref {basic.string})}} {\memgloref{}}|memjustarg}{843} +\glossaryentry{basic.string.general@ {\memgloterm{basic.string.general}}{\memglodesc{(\ref {basic.string.general})}} {\memgloref{}}|memjustarg}{843} +\glossaryentry{string.require@ {\memgloterm{string.require}}{\memglodesc{(\ref {string.require})}} {\memgloref{}}|memjustarg}{848} +\glossaryentry{string.cons@ {\memgloterm{string.cons}}{\memglodesc{(\ref {string.cons})}} {\memgloref{}}|memjustarg}{849} +\glossaryentry{string.iterators@ {\memgloterm{string.iterators}}{\memglodesc{(\ref {string.iterators})}} {\memgloref{}}|memjustarg}{851} +\glossaryentry{string.capacity@ {\memgloterm{string.capacity}}{\memglodesc{(\ref {string.capacity})}} {\memgloref{}}|memjustarg}{852} +\glossaryentry{string.access@ {\memgloterm{string.access}}{\memglodesc{(\ref {string.access})}} {\memgloref{}}|memjustarg}{853} +\glossaryentry{string.modifiers@ {\memgloterm{string.modifiers}}{\memglodesc{(\ref {string.modifiers})}} {\memgloref{}}|memjustarg}{853} +\glossaryentry{string.op.append@ {\memgloterm{string.op.append}}{\memglodesc{(\ref {string.op.append})}} {\memgloref{}}|memjustarg}{853} +\glossaryentry{string.append@ {\memgloterm{string.append}}{\memglodesc{(\ref {string.append})}} {\memgloref{}}|memjustarg}{854} +\glossaryentry{string.assign@ {\memgloterm{string.assign}}{\memglodesc{(\ref {string.assign})}} {\memgloref{}}|memjustarg}{855} +\glossaryentry{string.insert@ {\memgloterm{string.insert}}{\memglodesc{(\ref {string.insert})}} {\memgloref{}}|memjustarg}{856} +\glossaryentry{string.erase@ {\memgloterm{string.erase}}{\memglodesc{(\ref {string.erase})}} {\memgloref{}}|memjustarg}{857} +\glossaryentry{string.replace@ {\memgloterm{string.replace}}{\memglodesc{(\ref {string.replace})}} {\memgloref{}}|memjustarg}{858} +\glossaryentry{string.copy@ {\memgloterm{string.copy}}{\memglodesc{(\ref {string.copy})}} {\memgloref{}}|memjustarg}{860} +\glossaryentry{string.swap@ {\memgloterm{string.swap}}{\memglodesc{(\ref {string.swap})}} {\memgloref{}}|memjustarg}{860} +\glossaryentry{string.ops@ {\memgloterm{string.ops}}{\memglodesc{(\ref {string.ops})}} {\memgloref{}}|memjustarg}{860} +\glossaryentry{string.accessors@ {\memgloterm{string.accessors}}{\memglodesc{(\ref {string.accessors})}} {\memgloref{}}|memjustarg}{860} +\glossaryentry{string.find@ {\memgloterm{string.find}}{\memglodesc{(\ref {string.find})}} {\memgloref{}}|memjustarg}{860} +\glossaryentry{string.substr@ {\memgloterm{string.substr}}{\memglodesc{(\ref {string.substr})}} {\memgloref{}}|memjustarg}{861} +\glossaryentry{string.compare@ {\memgloterm{string.compare}}{\memglodesc{(\ref {string.compare})}} {\memgloref{}}|memjustarg}{861} +\glossaryentry{string.starts.with@ {\memgloterm{string.starts.with}}{\memglodesc{(\ref {string.starts.with})}} {\memgloref{}}|memjustarg}{862} +\glossaryentry{string.ends.with@ {\memgloterm{string.ends.with}}{\memglodesc{(\ref {string.ends.with})}} {\memgloref{}}|memjustarg}{862} +\glossaryentry{string.contains@ {\memgloterm{string.contains}}{\memglodesc{(\ref {string.contains})}} {\memgloref{}}|memjustarg}{862} +\glossaryentry{string.nonmembers@ {\memgloterm{string.nonmembers}}{\memglodesc{(\ref {string.nonmembers})}} {\memgloref{}}|memjustarg}{863} +\glossaryentry{string.op.plus@ {\memgloterm{string.op.plus}}{\memglodesc{(\ref {string.op.plus})}} {\memgloref{}}|memjustarg}{863} +\glossaryentry{string.cmp@ {\memgloterm{string.cmp}}{\memglodesc{(\ref {string.cmp})}} {\memgloref{}}|memjustarg}{864} +\glossaryentry{string.special@ {\memgloterm{string.special}}{\memglodesc{(\ref {string.special})}} {\memgloref{}}|memjustarg}{864} +\glossaryentry{string.io@ {\memgloterm{string.io}}{\memglodesc{(\ref {string.io})}} {\memgloref{}}|memjustarg}{865} +\glossaryentry{string.erasure@ {\memgloterm{string.erasure}}{\memglodesc{(\ref {string.erasure})}} {\memgloref{}}|memjustarg}{866} +\glossaryentry{string.conversions@ {\memgloterm{string.conversions}}{\memglodesc{(\ref {string.conversions})}} {\memgloref{}}|memjustarg}{866} +\glossaryentry{basic.string.hash@ {\memgloterm{basic.string.hash}}{\memglodesc{(\ref {basic.string.hash})}} {\memgloref{}}|memjustarg}{867} +\glossaryentry{basic.string.literals@ {\memgloterm{basic.string.literals}}{\memglodesc{(\ref {basic.string.literals})}} {\memgloref{}}|memjustarg}{868} +\glossaryentry{c.strings@ {\memgloterm{c.strings}}{\memglodesc{(\ref {c.strings})}} {\memgloref{}}|memjustarg}{868} +\glossaryentry{cctype.syn@ {\memgloterm{cctype.syn}}{\memglodesc{(\ref {cctype.syn})}} {\memgloref{}}|memjustarg}{868} +\glossaryentry{cwctype.syn@ {\memgloterm{cwctype.syn}}{\memglodesc{(\ref {cwctype.syn})}} {\memgloref{}}|memjustarg}{868} +\glossaryentry{cstring.syn@ {\memgloterm{cstring.syn}}{\memglodesc{(\ref {cstring.syn})}} {\memgloref{}}|memjustarg}{869} +\glossaryentry{cwchar.syn@ {\memgloterm{cwchar.syn}}{\memglodesc{(\ref {cwchar.syn})}} {\memgloref{}}|memjustarg}{870} +\glossaryentry{cuchar.syn@ {\memgloterm{cuchar.syn}}{\memglodesc{(\ref {cuchar.syn})}} {\memgloref{}}|memjustarg}{871} +\glossaryentry{c.mb.wcs@ {\memgloterm{c.mb.wcs}}{\memglodesc{(\ref {c.mb.wcs})}} {\memgloref{}}|memjustarg}{871} +\glossaryentry{containers@ {\memgloterm{containers}}{\memglodesc{(\ref {containers})}} {\memgloref{}}|memjustarg}{873} +\glossaryentry{containers.general@ {\memgloterm{containers.general}}{\memglodesc{(\ref {containers.general})}} {\memgloref{}}|memjustarg}{873} +\glossaryentry{container.requirements@ {\memgloterm{container.requirements}}{\memglodesc{(\ref {container.requirements})}} {\memgloref{}}|memjustarg}{873} +\glossaryentry{container.requirements.pre@ {\memgloterm{container.requirements.pre}}{\memglodesc{(\ref {container.requirements.pre})}} {\memgloref{}}|memjustarg}{873} +\glossaryentry{container.gen.reqmts@ {\memgloterm{container.gen.reqmts}}{\memglodesc{(\ref {container.gen.reqmts})}} {\memgloref{}}|memjustarg}{873} +\glossaryentry{container.requirements.general@ {\memgloterm{container.requirements.general}}{\memglodesc{(\ref {container.requirements.general})}} {\memgloref{}}|memjustarg}{873} +\glossaryentry{container.reqmts@ {\memgloterm{container.reqmts}}{\memglodesc{(\ref {container.reqmts})}} {\memgloref{}}|memjustarg}{874} +\glossaryentry{container.rev.reqmts@ {\memgloterm{container.rev.reqmts}}{\memglodesc{(\ref {container.rev.reqmts})}} {\memgloref{}}|memjustarg}{877} +\glossaryentry{container.opt.reqmts@ {\memgloterm{container.opt.reqmts}}{\memglodesc{(\ref {container.opt.reqmts})}} {\memgloref{}}|memjustarg}{878} +\glossaryentry{container.alloc.reqmts@ {\memgloterm{container.alloc.reqmts}}{\memglodesc{(\ref {container.alloc.reqmts})}} {\memgloref{}}|memjustarg}{878} +\glossaryentry{container.requirements.dataraces@ {\memgloterm{container.requirements.dataraces}}{\memglodesc{(\ref {container.requirements.dataraces})}} {\memgloref{}}|memjustarg}{880} +\glossaryentry{sequence.reqmts@ {\memgloterm{sequence.reqmts}}{\memglodesc{(\ref {sequence.reqmts})}} {\memgloref{}}|memjustarg}{880} +\glossaryentry{container.node@ {\memgloterm{container.node}}{\memglodesc{(\ref {container.node})}} {\memgloref{}}|memjustarg}{886} +\glossaryentry{container.node.overview@ {\memgloterm{container.node.overview}}{\memglodesc{(\ref {container.node.overview})}} {\memgloref{}}|memjustarg}{886} +\glossaryentry{container.node.cons@ {\memgloterm{container.node.cons}}{\memglodesc{(\ref {container.node.cons})}} {\memgloref{}}|memjustarg}{887} +\glossaryentry{container.node.dtor@ {\memgloterm{container.node.dtor}}{\memglodesc{(\ref {container.node.dtor})}} {\memgloref{}}|memjustarg}{887} +\glossaryentry{container.node.observers@ {\memgloterm{container.node.observers}}{\memglodesc{(\ref {container.node.observers})}} {\memgloref{}}|memjustarg}{887} +\glossaryentry{container.node.modifiers@ {\memgloterm{container.node.modifiers}}{\memglodesc{(\ref {container.node.modifiers})}} {\memgloref{}}|memjustarg}{888} +\glossaryentry{container.insert.return@ {\memgloterm{container.insert.return}}{\memglodesc{(\ref {container.insert.return})}} {\memgloref{}}|memjustarg}{888} +\glossaryentry{associative.reqmts@ {\memgloterm{associative.reqmts}}{\memglodesc{(\ref {associative.reqmts})}} {\memgloref{}}|memjustarg}{888} +\glossaryentry{associative.reqmts.general@ {\memgloterm{associative.reqmts.general}}{\memglodesc{(\ref {associative.reqmts.general})}} {\memgloref{}}|memjustarg}{888} +\glossaryentry{associative.reqmts.except@ {\memgloterm{associative.reqmts.except}}{\memglodesc{(\ref {associative.reqmts.except})}} {\memgloref{}}|memjustarg}{897} +\glossaryentry{unord.req@ {\memgloterm{unord.req}}{\memglodesc{(\ref {unord.req})}} {\memgloref{}}|memjustarg}{897} +\glossaryentry{unord.req.general@ {\memgloterm{unord.req.general}}{\memglodesc{(\ref {unord.req.general})}} {\memgloref{}}|memjustarg}{897} +\glossaryentry{unord.req.except@ {\memgloterm{unord.req.except}}{\memglodesc{(\ref {unord.req.except})}} {\memgloref{}}|memjustarg}{908} +\glossaryentry{sequences@ {\memgloterm{sequences}}{\memglodesc{(\ref {sequences})}} {\memgloref{}}|memjustarg}{908} +\glossaryentry{sequences.general@ {\memgloterm{sequences.general}}{\memglodesc{(\ref {sequences.general})}} {\memgloref{}}|memjustarg}{908} +\glossaryentry{array.syn@ {\memgloterm{array.syn}}{\memglodesc{(\ref {array.syn})}} {\memgloref{}}|memjustarg}{908} +\glossaryentry{deque.syn@ {\memgloterm{deque.syn}}{\memglodesc{(\ref {deque.syn})}} {\memgloref{}}|memjustarg}{909} +\glossaryentry{forward.list.syn@ {\memgloterm{forward.list.syn}}{\memglodesc{(\ref {forward.list.syn})}} {\memgloref{}}|memjustarg}{909} +\glossaryentry{list.syn@ {\memgloterm{list.syn}}{\memglodesc{(\ref {list.syn})}} {\memgloref{}}|memjustarg}{910} +\glossaryentry{vector.syn@ {\memgloterm{vector.syn}}{\memglodesc{(\ref {vector.syn})}} {\memgloref{}}|memjustarg}{910} +\glossaryentry{array@ {\memgloterm{array}}{\memglodesc{(\ref {array})}} {\memgloref{}}|memjustarg}{911} +\glossaryentry{array.overview@ {\memgloterm{array.overview}}{\memglodesc{(\ref {array.overview})}} {\memgloref{}}|memjustarg}{911} +\glossaryentry{array.cons@ {\memgloterm{array.cons}}{\memglodesc{(\ref {array.cons})}} {\memgloref{}}|memjustarg}{912} +\glossaryentry{array.members@ {\memgloterm{array.members}}{\memglodesc{(\ref {array.members})}} {\memgloref{}}|memjustarg}{913} +\glossaryentry{array.special@ {\memgloterm{array.special}}{\memglodesc{(\ref {array.special})}} {\memgloref{}}|memjustarg}{913} +\glossaryentry{array.zero@ {\memgloterm{array.zero}}{\memglodesc{(\ref {array.zero})}} {\memgloref{}}|memjustarg}{913} +\glossaryentry{array.creation@ {\memgloterm{array.creation}}{\memglodesc{(\ref {array.creation})}} {\memgloref{}}|memjustarg}{913} +\glossaryentry{array.tuple@ {\memgloterm{array.tuple}}{\memglodesc{(\ref {array.tuple})}} {\memgloref{}}|memjustarg}{913} +\glossaryentry{deque@ {\memgloterm{deque}}{\memglodesc{(\ref {deque})}} {\memgloref{}}|memjustarg}{914} +\glossaryentry{deque.overview@ {\memgloterm{deque.overview}}{\memglodesc{(\ref {deque.overview})}} {\memgloref{}}|memjustarg}{914} +\glossaryentry{deque.cons@ {\memgloterm{deque.cons}}{\memglodesc{(\ref {deque.cons})}} {\memgloref{}}|memjustarg}{916} +\glossaryentry{deque.capacity@ {\memgloterm{deque.capacity}}{\memglodesc{(\ref {deque.capacity})}} {\memgloref{}}|memjustarg}{916} +\glossaryentry{deque.modifiers@ {\memgloterm{deque.modifiers}}{\memglodesc{(\ref {deque.modifiers})}} {\memgloref{}}|memjustarg}{917} +\glossaryentry{deque.erasure@ {\memgloterm{deque.erasure}}{\memglodesc{(\ref {deque.erasure})}} {\memgloref{}}|memjustarg}{918} +\glossaryentry{forward.list@ {\memgloterm{forward.list}}{\memglodesc{(\ref {forward.list})}} {\memgloref{}}|memjustarg}{918} +\glossaryentry{forward.list.overview@ {\memgloterm{forward.list.overview}}{\memglodesc{(\ref {forward.list.overview})}} {\memgloref{}}|memjustarg}{918} +\glossaryentry{forward.list.cons@ {\memgloterm{forward.list.cons}}{\memglodesc{(\ref {forward.list.cons})}} {\memgloref{}}|memjustarg}{920} +\glossaryentry{forward.list.iter@ {\memgloterm{forward.list.iter}}{\memglodesc{(\ref {forward.list.iter})}} {\memgloref{}}|memjustarg}{921} +\glossaryentry{forward.list.access@ {\memgloterm{forward.list.access}}{\memglodesc{(\ref {forward.list.access})}} {\memgloref{}}|memjustarg}{921} +\glossaryentry{forward.list.modifiers@ {\memgloterm{forward.list.modifiers}}{\memglodesc{(\ref {forward.list.modifiers})}} {\memgloref{}}|memjustarg}{921} +\glossaryentry{forward.list.ops@ {\memgloterm{forward.list.ops}}{\memglodesc{(\ref {forward.list.ops})}} {\memgloref{}}|memjustarg}{923} +\glossaryentry{forward.list.erasure@ {\memgloterm{forward.list.erasure}}{\memglodesc{(\ref {forward.list.erasure})}} {\memgloref{}}|memjustarg}{925} +\glossaryentry{list@ {\memgloterm{list}}{\memglodesc{(\ref {list})}} {\memgloref{}}|memjustarg}{925} +\glossaryentry{list.overview@ {\memgloterm{list.overview}}{\memglodesc{(\ref {list.overview})}} {\memgloref{}}|memjustarg}{925} +\glossaryentry{list.cons@ {\memgloterm{list.cons}}{\memglodesc{(\ref {list.cons})}} {\memgloref{}}|memjustarg}{927} +\glossaryentry{list.capacity@ {\memgloterm{list.capacity}}{\memglodesc{(\ref {list.capacity})}} {\memgloref{}}|memjustarg}{928} +\glossaryentry{list.modifiers@ {\memgloterm{list.modifiers}}{\memglodesc{(\ref {list.modifiers})}} {\memgloref{}}|memjustarg}{928} +\glossaryentry{list.ops@ {\memgloterm{list.ops}}{\memglodesc{(\ref {list.ops})}} {\memgloref{}}|memjustarg}{929} +\glossaryentry{list.erasure@ {\memgloterm{list.erasure}}{\memglodesc{(\ref {list.erasure})}} {\memgloref{}}|memjustarg}{931} +\glossaryentry{vector@ {\memgloterm{vector}}{\memglodesc{(\ref {vector})}} {\memgloref{}}|memjustarg}{931} +\glossaryentry{vector.overview@ {\memgloterm{vector.overview}}{\memglodesc{(\ref {vector.overview})}} {\memgloref{}}|memjustarg}{931} +\glossaryentry{vector.cons@ {\memgloterm{vector.cons}}{\memglodesc{(\ref {vector.cons})}} {\memgloref{}}|memjustarg}{933} +\glossaryentry{vector.capacity@ {\memgloterm{vector.capacity}}{\memglodesc{(\ref {vector.capacity})}} {\memgloref{}}|memjustarg}{934} +\glossaryentry{vector.data@ {\memgloterm{vector.data}}{\memglodesc{(\ref {vector.data})}} {\memgloref{}}|memjustarg}{935} +\glossaryentry{vector.modifiers@ {\memgloterm{vector.modifiers}}{\memglodesc{(\ref {vector.modifiers})}} {\memgloref{}}|memjustarg}{935} +\glossaryentry{vector.erasure@ {\memgloterm{vector.erasure}}{\memglodesc{(\ref {vector.erasure})}} {\memgloref{}}|memjustarg}{935} +\glossaryentry{vector.bool@ {\memgloterm{vector.bool}}{\memglodesc{(\ref {vector.bool})}} {\memgloref{}}|memjustarg}{936} +\glossaryentry{vector.bool.pspc@ {\memgloterm{vector.bool.pspc}}{\memglodesc{(\ref {vector.bool.pspc})}} {\memgloref{}}|memjustarg}{936} +\glossaryentry{vector.bool.fmt@ {\memgloterm{vector.bool.fmt}}{\memglodesc{(\ref {vector.bool.fmt})}} {\memgloref{}}|memjustarg}{938} +\glossaryentry{associative@ {\memgloterm{associative}}{\memglodesc{(\ref {associative})}} {\memgloref{}}|memjustarg}{939} +\glossaryentry{associative.general@ {\memgloterm{associative.general}}{\memglodesc{(\ref {associative.general})}} {\memgloref{}}|memjustarg}{939} +\glossaryentry{associative.map.syn@ {\memgloterm{associative.map.syn}}{\memglodesc{(\ref {associative.map.syn})}} {\memgloref{}}|memjustarg}{939} +\glossaryentry{associative.set.syn@ {\memgloterm{associative.set.syn}}{\memglodesc{(\ref {associative.set.syn})}} {\memgloref{}}|memjustarg}{940} +\glossaryentry{map@ {\memgloterm{map}}{\memglodesc{(\ref {map})}} {\memgloref{}}|memjustarg}{941} +\glossaryentry{map.overview@ {\memgloterm{map.overview}}{\memglodesc{(\ref {map.overview})}} {\memgloref{}}|memjustarg}{941} +\glossaryentry{map.cons@ {\memgloterm{map.cons}}{\memglodesc{(\ref {map.cons})}} {\memgloref{}}|memjustarg}{945} +\glossaryentry{map.access@ {\memgloterm{map.access}}{\memglodesc{(\ref {map.access})}} {\memgloref{}}|memjustarg}{945} +\glossaryentry{map.modifiers@ {\memgloterm{map.modifiers}}{\memglodesc{(\ref {map.modifiers})}} {\memgloref{}}|memjustarg}{945} +\glossaryentry{map.erasure@ {\memgloterm{map.erasure}}{\memglodesc{(\ref {map.erasure})}} {\memgloref{}}|memjustarg}{946} +\glossaryentry{multimap@ {\memgloterm{multimap}}{\memglodesc{(\ref {multimap})}} {\memgloref{}}|memjustarg}{947} +\glossaryentry{multimap.overview@ {\memgloterm{multimap.overview}}{\memglodesc{(\ref {multimap.overview})}} {\memgloref{}}|memjustarg}{947} +\glossaryentry{multimap.cons@ {\memgloterm{multimap.cons}}{\memglodesc{(\ref {multimap.cons})}} {\memgloref{}}|memjustarg}{950} +\glossaryentry{multimap.modifiers@ {\memgloterm{multimap.modifiers}}{\memglodesc{(\ref {multimap.modifiers})}} {\memgloref{}}|memjustarg}{950} +\glossaryentry{multimap.erasure@ {\memgloterm{multimap.erasure}}{\memglodesc{(\ref {multimap.erasure})}} {\memgloref{}}|memjustarg}{950} +\glossaryentry{set@ {\memgloterm{set}}{\memglodesc{(\ref {set})}} {\memgloref{}}|memjustarg}{951} +\glossaryentry{set.overview@ {\memgloterm{set.overview}}{\memglodesc{(\ref {set.overview})}} {\memgloref{}}|memjustarg}{951} +\glossaryentry{set.cons@ {\memgloterm{set.cons}}{\memglodesc{(\ref {set.cons})}} {\memgloref{}}|memjustarg}{954} +\glossaryentry{set.erasure@ {\memgloterm{set.erasure}}{\memglodesc{(\ref {set.erasure})}} {\memgloref{}}|memjustarg}{954} +\glossaryentry{multiset@ {\memgloterm{multiset}}{\memglodesc{(\ref {multiset})}} {\memgloref{}}|memjustarg}{954} +\glossaryentry{multiset.overview@ {\memgloterm{multiset.overview}}{\memglodesc{(\ref {multiset.overview})}} {\memgloref{}}|memjustarg}{954} +\glossaryentry{multiset.cons@ {\memgloterm{multiset.cons}}{\memglodesc{(\ref {multiset.cons})}} {\memgloref{}}|memjustarg}{957} +\glossaryentry{multiset.erasure@ {\memgloterm{multiset.erasure}}{\memglodesc{(\ref {multiset.erasure})}} {\memgloref{}}|memjustarg}{958} +\glossaryentry{unord@ {\memgloterm{unord}}{\memglodesc{(\ref {unord})}} {\memgloref{}}|memjustarg}{958} +\glossaryentry{unord.general@ {\memgloterm{unord.general}}{\memglodesc{(\ref {unord.general})}} {\memgloref{}}|memjustarg}{958} +\glossaryentry{unord.map.syn@ {\memgloterm{unord.map.syn}}{\memglodesc{(\ref {unord.map.syn})}} {\memgloref{}}|memjustarg}{958} +\glossaryentry{unord.set.syn@ {\memgloterm{unord.set.syn}}{\memglodesc{(\ref {unord.set.syn})}} {\memgloref{}}|memjustarg}{959} +\glossaryentry{unord.map@ {\memgloterm{unord.map}}{\memglodesc{(\ref {unord.map})}} {\memgloref{}}|memjustarg}{960} +\glossaryentry{unord.map.overview@ {\memgloterm{unord.map.overview}}{\memglodesc{(\ref {unord.map.overview})}} {\memgloref{}}|memjustarg}{960} +\glossaryentry{unord.map.cnstr@ {\memgloterm{unord.map.cnstr}}{\memglodesc{(\ref {unord.map.cnstr})}} {\memgloref{}}|memjustarg}{965} +\glossaryentry{unord.map.elem@ {\memgloterm{unord.map.elem}}{\memglodesc{(\ref {unord.map.elem})}} {\memgloref{}}|memjustarg}{965} +\glossaryentry{unord.map.modifiers@ {\memgloterm{unord.map.modifiers}}{\memglodesc{(\ref {unord.map.modifiers})}} {\memgloref{}}|memjustarg}{965} +\glossaryentry{unord.map.erasure@ {\memgloterm{unord.map.erasure}}{\memglodesc{(\ref {unord.map.erasure})}} {\memgloref{}}|memjustarg}{967} +\glossaryentry{unord.multimap@ {\memgloterm{unord.multimap}}{\memglodesc{(\ref {unord.multimap})}} {\memgloref{}}|memjustarg}{967} +\glossaryentry{unord.multimap.overview@ {\memgloterm{unord.multimap.overview}}{\memglodesc{(\ref {unord.multimap.overview})}} {\memgloref{}}|memjustarg}{967} +\glossaryentry{unord.multimap.cnstr@ {\memgloterm{unord.multimap.cnstr}}{\memglodesc{(\ref {unord.multimap.cnstr})}} {\memgloref{}}|memjustarg}{971} +\glossaryentry{unord.multimap.modifiers@ {\memgloterm{unord.multimap.modifiers}}{\memglodesc{(\ref {unord.multimap.modifiers})}} {\memgloref{}}|memjustarg}{972} +\glossaryentry{unord.multimap.erasure@ {\memgloterm{unord.multimap.erasure}}{\memglodesc{(\ref {unord.multimap.erasure})}} {\memgloref{}}|memjustarg}{972} +\glossaryentry{unord.set@ {\memgloterm{unord.set}}{\memglodesc{(\ref {unord.set})}} {\memgloref{}}|memjustarg}{972} +\glossaryentry{unord.set.overview@ {\memgloterm{unord.set.overview}}{\memglodesc{(\ref {unord.set.overview})}} {\memgloref{}}|memjustarg}{972} +\glossaryentry{unord.set.cnstr@ {\memgloterm{unord.set.cnstr}}{\memglodesc{(\ref {unord.set.cnstr})}} {\memgloref{}}|memjustarg}{976} +\glossaryentry{unord.set.erasure@ {\memgloterm{unord.set.erasure}}{\memglodesc{(\ref {unord.set.erasure})}} {\memgloref{}}|memjustarg}{977} +\glossaryentry{unord.multiset@ {\memgloterm{unord.multiset}}{\memglodesc{(\ref {unord.multiset})}} {\memgloref{}}|memjustarg}{977} +\glossaryentry{unord.multiset.overview@ {\memgloterm{unord.multiset.overview}}{\memglodesc{(\ref {unord.multiset.overview})}} {\memgloref{}}|memjustarg}{977} +\glossaryentry{unord.multiset.cnstr@ {\memgloterm{unord.multiset.cnstr}}{\memglodesc{(\ref {unord.multiset.cnstr})}} {\memgloref{}}|memjustarg}{981} +\glossaryentry{unord.multiset.erasure@ {\memgloterm{unord.multiset.erasure}}{\memglodesc{(\ref {unord.multiset.erasure})}} {\memgloref{}}|memjustarg}{982} +\glossaryentry{container.adaptors@ {\memgloterm{container.adaptors}}{\memglodesc{(\ref {container.adaptors})}} {\memgloref{}}|memjustarg}{982} +\glossaryentry{container.adaptors.general@ {\memgloterm{container.adaptors.general}}{\memglodesc{(\ref {container.adaptors.general})}} {\memgloref{}}|memjustarg}{982} +\glossaryentry{queue.syn@ {\memgloterm{queue.syn}}{\memglodesc{(\ref {queue.syn})}} {\memgloref{}}|memjustarg}{983} +\glossaryentry{stack.syn@ {\memgloterm{stack.syn}}{\memglodesc{(\ref {stack.syn})}} {\memgloref{}}|memjustarg}{984} +\glossaryentry{flat.map.syn@ {\memgloterm{flat.map.syn}}{\memglodesc{(\ref {flat.map.syn})}} {\memgloref{}}|memjustarg}{984} +\glossaryentry{flat.set.syn@ {\memgloterm{flat.set.syn}}{\memglodesc{(\ref {flat.set.syn})}} {\memgloref{}}|memjustarg}{985} +\glossaryentry{queue@ {\memgloterm{queue}}{\memglodesc{(\ref {queue})}} {\memgloref{}}|memjustarg}{986} +\glossaryentry{queue.defn@ {\memgloterm{queue.defn}}{\memglodesc{(\ref {queue.defn})}} {\memgloref{}}|memjustarg}{986} +\glossaryentry{queue.cons@ {\memgloterm{queue.cons}}{\memglodesc{(\ref {queue.cons})}} {\memgloref{}}|memjustarg}{987} +\glossaryentry{queue.cons.alloc@ {\memgloterm{queue.cons.alloc}}{\memglodesc{(\ref {queue.cons.alloc})}} {\memgloref{}}|memjustarg}{987} +\glossaryentry{queue.mod@ {\memgloterm{queue.mod}}{\memglodesc{(\ref {queue.mod})}} {\memgloref{}}|memjustarg}{988} +\glossaryentry{queue.ops@ {\memgloterm{queue.ops}}{\memglodesc{(\ref {queue.ops})}} {\memgloref{}}|memjustarg}{988} +\glossaryentry{queue.special@ {\memgloterm{queue.special}}{\memglodesc{(\ref {queue.special})}} {\memgloref{}}|memjustarg}{988} +\glossaryentry{priority.queue@ {\memgloterm{priority.queue}}{\memglodesc{(\ref {priority.queue})}} {\memgloref{}}|memjustarg}{988} +\glossaryentry{priqueue.overview@ {\memgloterm{priqueue.overview}}{\memglodesc{(\ref {priqueue.overview})}} {\memgloref{}}|memjustarg}{988} +\glossaryentry{priqueue.cons@ {\memgloterm{priqueue.cons}}{\memglodesc{(\ref {priqueue.cons})}} {\memgloref{}}|memjustarg}{990} +\glossaryentry{priqueue.cons.alloc@ {\memgloterm{priqueue.cons.alloc}}{\memglodesc{(\ref {priqueue.cons.alloc})}} {\memgloref{}}|memjustarg}{991} +\glossaryentry{priqueue.members@ {\memgloterm{priqueue.members}}{\memglodesc{(\ref {priqueue.members})}} {\memgloref{}}|memjustarg}{992} +\glossaryentry{priqueue.special@ {\memgloterm{priqueue.special}}{\memglodesc{(\ref {priqueue.special})}} {\memgloref{}}|memjustarg}{992} +\glossaryentry{stack@ {\memgloterm{stack}}{\memglodesc{(\ref {stack})}} {\memgloref{}}|memjustarg}{992} +\glossaryentry{stack.general@ {\memgloterm{stack.general}}{\memglodesc{(\ref {stack.general})}} {\memgloref{}}|memjustarg}{992} +\glossaryentry{stack.defn@ {\memgloterm{stack.defn}}{\memglodesc{(\ref {stack.defn})}} {\memgloref{}}|memjustarg}{993} +\glossaryentry{stack.cons@ {\memgloterm{stack.cons}}{\memglodesc{(\ref {stack.cons})}} {\memgloref{}}|memjustarg}{994} +\glossaryentry{stack.cons.alloc@ {\memgloterm{stack.cons.alloc}}{\memglodesc{(\ref {stack.cons.alloc})}} {\memgloref{}}|memjustarg}{994} +\glossaryentry{stack.mod@ {\memgloterm{stack.mod}}{\memglodesc{(\ref {stack.mod})}} {\memgloref{}}|memjustarg}{994} +\glossaryentry{stack.ops@ {\memgloterm{stack.ops}}{\memglodesc{(\ref {stack.ops})}} {\memgloref{}}|memjustarg}{995} +\glossaryentry{stack.special@ {\memgloterm{stack.special}}{\memglodesc{(\ref {stack.special})}} {\memgloref{}}|memjustarg}{995} +\glossaryentry{flat.map@ {\memgloterm{flat.map}}{\memglodesc{(\ref {flat.map})}} {\memgloref{}}|memjustarg}{995} +\glossaryentry{flat.map.overview@ {\memgloterm{flat.map.overview}}{\memglodesc{(\ref {flat.map.overview})}} {\memgloref{}}|memjustarg}{995} +\glossaryentry{flat.map.defn@ {\memgloterm{flat.map.defn}}{\memglodesc{(\ref {flat.map.defn})}} {\memgloref{}}|memjustarg}{996} +\glossaryentry{flat.map.cons@ {\memgloterm{flat.map.cons}}{\memglodesc{(\ref {flat.map.cons})}} {\memgloref{}}|memjustarg}{1001} +\glossaryentry{flat.map.capacity@ {\memgloterm{flat.map.capacity}}{\memglodesc{(\ref {flat.map.capacity})}} {\memgloref{}}|memjustarg}{1003} +\glossaryentry{flat.map.access@ {\memgloterm{flat.map.access}}{\memglodesc{(\ref {flat.map.access})}} {\memgloref{}}|memjustarg}{1003} +\glossaryentry{flat.map.modifiers@ {\memgloterm{flat.map.modifiers}}{\memglodesc{(\ref {flat.map.modifiers})}} {\memgloref{}}|memjustarg}{1003} +\glossaryentry{flat.map.erasure@ {\memgloterm{flat.map.erasure}}{\memglodesc{(\ref {flat.map.erasure})}} {\memgloref{}}|memjustarg}{1006} +\glossaryentry{flat.multimap@ {\memgloterm{flat.multimap}}{\memglodesc{(\ref {flat.multimap})}} {\memgloref{}}|memjustarg}{1007} +\glossaryentry{flat.multimap.overview@ {\memgloterm{flat.multimap.overview}}{\memglodesc{(\ref {flat.multimap.overview})}} {\memgloref{}}|memjustarg}{1007} +\glossaryentry{flat.multimap.defn@ {\memgloterm{flat.multimap.defn}}{\memglodesc{(\ref {flat.multimap.defn})}} {\memgloref{}}|memjustarg}{1008} +\glossaryentry{flat.multimap.cons@ {\memgloterm{flat.multimap.cons}}{\memglodesc{(\ref {flat.multimap.cons})}} {\memgloref{}}|memjustarg}{1012} +\glossaryentry{flat.multimap.erasure@ {\memgloterm{flat.multimap.erasure}}{\memglodesc{(\ref {flat.multimap.erasure})}} {\memgloref{}}|memjustarg}{1014} +\glossaryentry{flat.set@ {\memgloterm{flat.set}}{\memglodesc{(\ref {flat.set})}} {\memgloref{}}|memjustarg}{1014} +\glossaryentry{flat.set.overview@ {\memgloterm{flat.set.overview}}{\memglodesc{(\ref {flat.set.overview})}} {\memgloref{}}|memjustarg}{1014} +\glossaryentry{flat.set.defn@ {\memgloterm{flat.set.defn}}{\memglodesc{(\ref {flat.set.defn})}} {\memgloref{}}|memjustarg}{1015} +\glossaryentry{flat.set.cons@ {\memgloterm{flat.set.cons}}{\memglodesc{(\ref {flat.set.cons})}} {\memgloref{}}|memjustarg}{1019} +\glossaryentry{flat.set.modifiers@ {\memgloterm{flat.set.modifiers}}{\memglodesc{(\ref {flat.set.modifiers})}} {\memgloref{}}|memjustarg}{1020} +\glossaryentry{flat.set.erasure@ {\memgloterm{flat.set.erasure}}{\memglodesc{(\ref {flat.set.erasure})}} {\memgloref{}}|memjustarg}{1021} +\glossaryentry{flat.multiset@ {\memgloterm{flat.multiset}}{\memglodesc{(\ref {flat.multiset})}} {\memgloref{}}|memjustarg}{1021} +\glossaryentry{flat.multiset.overview@ {\memgloterm{flat.multiset.overview}}{\memglodesc{(\ref {flat.multiset.overview})}} {\memgloref{}}|memjustarg}{1021} +\glossaryentry{flat.multiset.defn@ {\memgloterm{flat.multiset.defn}}{\memglodesc{(\ref {flat.multiset.defn})}} {\memgloref{}}|memjustarg}{1021} +\glossaryentry{flat.multiset.cons@ {\memgloterm{flat.multiset.cons}}{\memglodesc{(\ref {flat.multiset.cons})}} {\memgloref{}}|memjustarg}{1026} +\glossaryentry{flat.multiset.modifiers@ {\memgloterm{flat.multiset.modifiers}}{\memglodesc{(\ref {flat.multiset.modifiers})}} {\memgloref{}}|memjustarg}{1027} +\glossaryentry{flat.multiset.erasure@ {\memgloterm{flat.multiset.erasure}}{\memglodesc{(\ref {flat.multiset.erasure})}} {\memgloref{}}|memjustarg}{1027} +\glossaryentry{container.adaptors.format@ {\memgloterm{container.adaptors.format}}{\memglodesc{(\ref {container.adaptors.format})}} {\memgloref{}}|memjustarg}{1027} +\glossaryentry{views@ {\memgloterm{views}}{\memglodesc{(\ref {views})}} {\memgloref{}}|memjustarg}{1028} +\glossaryentry{views.general@ {\memgloterm{views.general}}{\memglodesc{(\ref {views.general})}} {\memgloref{}}|memjustarg}{1028} +\glossaryentry{views.contiguous@ {\memgloterm{views.contiguous}}{\memglodesc{(\ref {views.contiguous})}} {\memgloref{}}|memjustarg}{1028} +\glossaryentry{span.syn@ {\memgloterm{span.syn}}{\memglodesc{(\ref {span.syn})}} {\memgloref{}}|memjustarg}{1028} +\glossaryentry{views.span@ {\memgloterm{views.span}}{\memglodesc{(\ref {views.span})}} {\memgloref{}}|memjustarg}{1029} +\glossaryentry{span.overview@ {\memgloterm{span.overview}}{\memglodesc{(\ref {span.overview})}} {\memgloref{}}|memjustarg}{1029} +\glossaryentry{span.cons@ {\memgloterm{span.cons}}{\memglodesc{(\ref {span.cons})}} {\memgloref{}}|memjustarg}{1030} +\glossaryentry{span.deduct@ {\memgloterm{span.deduct}}{\memglodesc{(\ref {span.deduct})}} {\memgloref{}}|memjustarg}{1032} +\glossaryentry{span.sub@ {\memgloterm{span.sub}}{\memglodesc{(\ref {span.sub})}} {\memgloref{}}|memjustarg}{1032} +\glossaryentry{span.obs@ {\memgloterm{span.obs}}{\memglodesc{(\ref {span.obs})}} {\memgloref{}}|memjustarg}{1033} +\glossaryentry{span.elem@ {\memgloterm{span.elem}}{\memglodesc{(\ref {span.elem})}} {\memgloref{}}|memjustarg}{1033} +\glossaryentry{span.iterators@ {\memgloterm{span.iterators}}{\memglodesc{(\ref {span.iterators})}} {\memgloref{}}|memjustarg}{1033} +\glossaryentry{span.objectrep@ {\memgloterm{span.objectrep}}{\memglodesc{(\ref {span.objectrep})}} {\memgloref{}}|memjustarg}{1034} +\glossaryentry{views.multidim@ {\memgloterm{views.multidim}}{\memglodesc{(\ref {views.multidim})}} {\memgloref{}}|memjustarg}{1034} +\glossaryentry{mdspan.overview@ {\memgloterm{mdspan.overview}}{\memglodesc{(\ref {mdspan.overview})}} {\memgloref{}}|memjustarg}{1034} +\glossaryentry{mdspan.syn@ {\memgloterm{mdspan.syn}}{\memglodesc{(\ref {mdspan.syn})}} {\memgloref{}}|memjustarg}{1034} +\glossaryentry{mdspan.extents@ {\memgloterm{mdspan.extents}}{\memglodesc{(\ref {mdspan.extents})}} {\memgloref{}}|memjustarg}{1035} +\glossaryentry{mdspan.extents.overview@ {\memgloterm{mdspan.extents.overview}}{\memglodesc{(\ref {mdspan.extents.overview})}} {\memgloref{}}|memjustarg}{1035} +\glossaryentry{mdspan.extents.expo@ {\memgloterm{mdspan.extents.expo}}{\memglodesc{(\ref {mdspan.extents.expo})}} {\memgloref{}}|memjustarg}{1036} +\glossaryentry{mdspan.extents.cons@ {\memgloterm{mdspan.extents.cons}}{\memglodesc{(\ref {mdspan.extents.cons})}} {\memgloref{}}|memjustarg}{1036} +\glossaryentry{mdspan.extents.obs@ {\memgloterm{mdspan.extents.obs}}{\memglodesc{(\ref {mdspan.extents.obs})}} {\memgloref{}}|memjustarg}{1038} +\glossaryentry{mdspan.extents.cmp@ {\memgloterm{mdspan.extents.cmp}}{\memglodesc{(\ref {mdspan.extents.cmp})}} {\memgloref{}}|memjustarg}{1038} +\glossaryentry{mdspan.extents.dextents@ {\memgloterm{mdspan.extents.dextents}}{\memglodesc{(\ref {mdspan.extents.dextents})}} {\memgloref{}}|memjustarg}{1038} +\glossaryentry{mdspan.layout@ {\memgloterm{mdspan.layout}}{\memglodesc{(\ref {mdspan.layout})}} {\memgloref{}}|memjustarg}{1038} +\glossaryentry{mdspan.layout.general@ {\memgloterm{mdspan.layout.general}}{\memglodesc{(\ref {mdspan.layout.general})}} {\memgloref{}}|memjustarg}{1038} +\glossaryentry{mdspan.layout.reqmts@ {\memgloterm{mdspan.layout.reqmts}}{\memglodesc{(\ref {mdspan.layout.reqmts})}} {\memgloref{}}|memjustarg}{1038} +\glossaryentry{mdspan.layout.policy.reqmts@ {\memgloterm{mdspan.layout.policy.reqmts}}{\memglodesc{(\ref {mdspan.layout.policy.reqmts})}} {\memgloref{}}|memjustarg}{1040} +\glossaryentry{mdspan.layout.policy.overview@ {\memgloterm{mdspan.layout.policy.overview}}{\memglodesc{(\ref {mdspan.layout.policy.overview})}} {\memgloref{}}|memjustarg}{1040} +\glossaryentry{mdspan.layout.left@ {\memgloterm{mdspan.layout.left}}{\memglodesc{(\ref {mdspan.layout.left})}} {\memgloref{}}|memjustarg}{1040} +\glossaryentry{mdspan.layout.left.overview@ {\memgloterm{mdspan.layout.left.overview}}{\memglodesc{(\ref {mdspan.layout.left.overview})}} {\memgloref{}}|memjustarg}{1040} +\glossaryentry{mdspan.layout.left.cons@ {\memgloterm{mdspan.layout.left.cons}}{\memglodesc{(\ref {mdspan.layout.left.cons})}} {\memgloref{}}|memjustarg}{1041} +\glossaryentry{mdspan.layout.left.obs@ {\memgloterm{mdspan.layout.left.obs}}{\memglodesc{(\ref {mdspan.layout.left.obs})}} {\memgloref{}}|memjustarg}{1042} +\glossaryentry{mdspan.layout.right@ {\memgloterm{mdspan.layout.right}}{\memglodesc{(\ref {mdspan.layout.right})}} {\memgloref{}}|memjustarg}{1042} +\glossaryentry{mdspan.layout.right.overview@ {\memgloterm{mdspan.layout.right.overview}}{\memglodesc{(\ref {mdspan.layout.right.overview})}} {\memgloref{}}|memjustarg}{1042} +\glossaryentry{mdspan.layout.right.cons@ {\memgloterm{mdspan.layout.right.cons}}{\memglodesc{(\ref {mdspan.layout.right.cons})}} {\memgloref{}}|memjustarg}{1043} +\glossaryentry{mdspan.layout.right.obs@ {\memgloterm{mdspan.layout.right.obs}}{\memglodesc{(\ref {mdspan.layout.right.obs})}} {\memgloref{}}|memjustarg}{1044} +\glossaryentry{mdspan.layout.stride@ {\memgloterm{mdspan.layout.stride}}{\memglodesc{(\ref {mdspan.layout.stride})}} {\memgloref{}}|memjustarg}{1044} +\glossaryentry{mdspan.layout.stride.overview@ {\memgloterm{mdspan.layout.stride.overview}}{\memglodesc{(\ref {mdspan.layout.stride.overview})}} {\memgloref{}}|memjustarg}{1044} +\glossaryentry{mdspan.layout.stride.expo@ {\memgloterm{mdspan.layout.stride.expo}}{\memglodesc{(\ref {mdspan.layout.stride.expo})}} {\memgloref{}}|memjustarg}{1045} +\glossaryentry{mdspan.layout.stride.cons@ {\memgloterm{mdspan.layout.stride.cons}}{\memglodesc{(\ref {mdspan.layout.stride.cons})}} {\memgloref{}}|memjustarg}{1046} +\glossaryentry{mdspan.layout.stride.obs@ {\memgloterm{mdspan.layout.stride.obs}}{\memglodesc{(\ref {mdspan.layout.stride.obs})}} {\memgloref{}}|memjustarg}{1047} +\glossaryentry{mdspan.accessor@ {\memgloterm{mdspan.accessor}}{\memglodesc{(\ref {mdspan.accessor})}} {\memgloref{}}|memjustarg}{1048} +\glossaryentry{mdspan.accessor.general@ {\memgloterm{mdspan.accessor.general}}{\memglodesc{(\ref {mdspan.accessor.general})}} {\memgloref{}}|memjustarg}{1048} +\glossaryentry{mdspan.accessor.reqmts@ {\memgloterm{mdspan.accessor.reqmts}}{\memglodesc{(\ref {mdspan.accessor.reqmts})}} {\memgloref{}}|memjustarg}{1048} +\glossaryentry{mdspan.accessor.default@ {\memgloterm{mdspan.accessor.default}}{\memglodesc{(\ref {mdspan.accessor.default})}} {\memgloref{}}|memjustarg}{1049} +\glossaryentry{mdspan.accessor.default.overview@ {\memgloterm{mdspan.accessor.default.overview}}{\memglodesc{(\ref {mdspan.accessor.default.overview})}} {\memgloref{}}|memjustarg}{1049} +\glossaryentry{mdspan.accessor.default.members@ {\memgloterm{mdspan.accessor.default.members}}{\memglodesc{(\ref {mdspan.accessor.default.members})}} {\memgloref{}}|memjustarg}{1049} +\glossaryentry{mdspan.mdspan@ {\memgloterm{mdspan.mdspan}}{\memglodesc{(\ref {mdspan.mdspan})}} {\memgloref{}}|memjustarg}{1049} +\glossaryentry{mdspan.mdspan.overview@ {\memgloterm{mdspan.mdspan.overview}}{\memglodesc{(\ref {mdspan.mdspan.overview})}} {\memgloref{}}|memjustarg}{1049} +\glossaryentry{mdspan.mdspan.cons@ {\memgloterm{mdspan.mdspan.cons}}{\memglodesc{(\ref {mdspan.mdspan.cons})}} {\memgloref{}}|memjustarg}{1052} +\glossaryentry{mdspan.mdspan.members@ {\memgloterm{mdspan.mdspan.members}}{\memglodesc{(\ref {mdspan.mdspan.members})}} {\memgloref{}}|memjustarg}{1054} +\glossaryentry{iterators@ {\memgloterm{iterators}}{\memglodesc{(\ref {iterators})}} {\memgloref{}}|memjustarg}{1055} +\glossaryentry{iterators.general@ {\memgloterm{iterators.general}}{\memglodesc{(\ref {iterators.general})}} {\memgloref{}}|memjustarg}{1055} +\glossaryentry{iterator.synopsis@ {\memgloterm{iterator.synopsis}}{\memglodesc{(\ref {iterator.synopsis})}} {\memgloref{}}|memjustarg}{1055} +\glossaryentry{iterator.requirements@ {\memgloterm{iterator.requirements}}{\memglodesc{(\ref {iterator.requirements})}} {\memgloref{}}|memjustarg}{1063} +\glossaryentry{iterator.requirements.general@ {\memgloterm{iterator.requirements.general}}{\memglodesc{(\ref {iterator.requirements.general})}} {\memgloref{}}|memjustarg}{1063} +\glossaryentry{iterator.assoc.types@ {\memgloterm{iterator.assoc.types}}{\memglodesc{(\ref {iterator.assoc.types})}} {\memgloref{}}|memjustarg}{1064} +\glossaryentry{incrementable.traits@ {\memgloterm{incrementable.traits}}{\memglodesc{(\ref {incrementable.traits})}} {\memgloref{}}|memjustarg}{1064} +\glossaryentry{readable.traits@ {\memgloterm{readable.traits}}{\memglodesc{(\ref {readable.traits})}} {\memgloref{}}|memjustarg}{1065} +\glossaryentry{iterator.traits@ {\memgloterm{iterator.traits}}{\memglodesc{(\ref {iterator.traits})}} {\memgloref{}}|memjustarg}{1066} +\glossaryentry{iterator.cust@ {\memgloterm{iterator.cust}}{\memglodesc{(\ref {iterator.cust})}} {\memgloref{}}|memjustarg}{1068} +\glossaryentry{iterator.cust.move@ {\memgloterm{iterator.cust.move}}{\memglodesc{(\ref {iterator.cust.move})}} {\memgloref{}}|memjustarg}{1068} +\glossaryentry{iterator.cust.swap@ {\memgloterm{iterator.cust.swap}}{\memglodesc{(\ref {iterator.cust.swap})}} {\memgloref{}}|memjustarg}{1069} +\glossaryentry{iterator.concepts@ {\memgloterm{iterator.concepts}}{\memglodesc{(\ref {iterator.concepts})}} {\memgloref{}}|memjustarg}{1069} +\glossaryentry{iterator.concepts.general@ {\memgloterm{iterator.concepts.general}}{\memglodesc{(\ref {iterator.concepts.general})}} {\memgloref{}}|memjustarg}{1069} +\glossaryentry{iterator.concept.readable@ {\memgloterm{iterator.concept.readable}}{\memglodesc{(\ref {iterator.concept.readable})}} {\memgloref{}}|memjustarg}{1070} +\glossaryentry{iterator.concept.writable@ {\memgloterm{iterator.concept.writable}}{\memglodesc{(\ref {iterator.concept.writable})}} {\memgloref{}}|memjustarg}{1070} +\glossaryentry{iterator.concept.winc@ {\memgloterm{iterator.concept.winc}}{\memglodesc{(\ref {iterator.concept.winc})}} {\memgloref{}}|memjustarg}{1071} +\glossaryentry{iterator.concept.inc@ {\memgloterm{iterator.concept.inc}}{\memglodesc{(\ref {iterator.concept.inc})}} {\memgloref{}}|memjustarg}{1072} +\glossaryentry{iterator.concept.iterator@ {\memgloterm{iterator.concept.iterator}}{\memglodesc{(\ref {iterator.concept.iterator})}} {\memgloref{}}|memjustarg}{1073} +\glossaryentry{iterator.concept.sentinel@ {\memgloterm{iterator.concept.sentinel}}{\memglodesc{(\ref {iterator.concept.sentinel})}} {\memgloref{}}|memjustarg}{1073} +\glossaryentry{iterator.concept.sizedsentinel@ {\memgloterm{iterator.concept.sizedsentinel}}{\memglodesc{(\ref {iterator.concept.sizedsentinel})}} {\memgloref{}}|memjustarg}{1073} +\glossaryentry{iterator.concept.input@ {\memgloterm{iterator.concept.input}}{\memglodesc{(\ref {iterator.concept.input})}} {\memgloref{}}|memjustarg}{1074} +\glossaryentry{iterator.concept.output@ {\memgloterm{iterator.concept.output}}{\memglodesc{(\ref {iterator.concept.output})}} {\memgloref{}}|memjustarg}{1074} +\glossaryentry{iterator.concept.forward@ {\memgloterm{iterator.concept.forward}}{\memglodesc{(\ref {iterator.concept.forward})}} {\memgloref{}}|memjustarg}{1074} +\glossaryentry{iterator.concept.bidir@ {\memgloterm{iterator.concept.bidir}}{\memglodesc{(\ref {iterator.concept.bidir})}} {\memgloref{}}|memjustarg}{1075} +\glossaryentry{iterator.concept.random.access@ {\memgloterm{iterator.concept.random.access}}{\memglodesc{(\ref {iterator.concept.random.access})}} {\memgloref{}}|memjustarg}{1075} +\glossaryentry{iterator.concept.contiguous@ {\memgloterm{iterator.concept.contiguous}}{\memglodesc{(\ref {iterator.concept.contiguous})}} {\memgloref{}}|memjustarg}{1076} +\glossaryentry{iterator.cpp17@ {\memgloterm{iterator.cpp17}}{\memglodesc{(\ref {iterator.cpp17})}} {\memgloref{}}|memjustarg}{1076} +\glossaryentry{iterator.cpp17.general@ {\memgloterm{iterator.cpp17.general}}{\memglodesc{(\ref {iterator.cpp17.general})}} {\memgloref{}}|memjustarg}{1076} +\glossaryentry{iterator.iterators@ {\memgloterm{iterator.iterators}}{\memglodesc{(\ref {iterator.iterators})}} {\memgloref{}}|memjustarg}{1076} +\glossaryentry{input.iterators@ {\memgloterm{input.iterators}}{\memglodesc{(\ref {input.iterators})}} {\memgloref{}}|memjustarg}{1076} +\glossaryentry{output.iterators@ {\memgloterm{output.iterators}}{\memglodesc{(\ref {output.iterators})}} {\memgloref{}}|memjustarg}{1078} +\glossaryentry{forward.iterators@ {\memgloterm{forward.iterators}}{\memglodesc{(\ref {forward.iterators})}} {\memgloref{}}|memjustarg}{1078} +\glossaryentry{bidirectional.iterators@ {\memgloterm{bidirectional.iterators}}{\memglodesc{(\ref {bidirectional.iterators})}} {\memgloref{}}|memjustarg}{1079} +\glossaryentry{random.access.iterators@ {\memgloterm{random.access.iterators}}{\memglodesc{(\ref {random.access.iterators})}} {\memgloref{}}|memjustarg}{1079} +\glossaryentry{indirectcallable@ {\memgloterm{indirectcallable}}{\memglodesc{(\ref {indirectcallable})}} {\memgloref{}}|memjustarg}{1080} +\glossaryentry{indirectcallable.general@ {\memgloterm{indirectcallable.general}}{\memglodesc{(\ref {indirectcallable.general})}} {\memgloref{}}|memjustarg}{1080} +\glossaryentry{indirectcallable.traits@ {\memgloterm{indirectcallable.traits}}{\memglodesc{(\ref {indirectcallable.traits})}} {\memgloref{}}|memjustarg}{1080} +\glossaryentry{indirectcallable.indirectinvocable@ {\memgloterm{indirectcallable.indirectinvocable}}{\memglodesc{(\ref {indirectcallable.indirectinvocable})}} {\memgloref{}}|memjustarg}{1081} +\glossaryentry{projected@ {\memgloterm{projected}}{\memglodesc{(\ref {projected})}} {\memgloref{}}|memjustarg}{1082} +\glossaryentry{alg.req@ {\memgloterm{alg.req}}{\memglodesc{(\ref {alg.req})}} {\memgloref{}}|memjustarg}{1082} +\glossaryentry{alg.req.general@ {\memgloterm{alg.req.general}}{\memglodesc{(\ref {alg.req.general})}} {\memgloref{}}|memjustarg}{1082} +\glossaryentry{alg.req.ind.move@ {\memgloterm{alg.req.ind.move}}{\memglodesc{(\ref {alg.req.ind.move})}} {\memgloref{}}|memjustarg}{1082} +\glossaryentry{alg.req.ind.copy@ {\memgloterm{alg.req.ind.copy}}{\memglodesc{(\ref {alg.req.ind.copy})}} {\memgloref{}}|memjustarg}{1082} +\glossaryentry{alg.req.ind.swap@ {\memgloterm{alg.req.ind.swap}}{\memglodesc{(\ref {alg.req.ind.swap})}} {\memgloref{}}|memjustarg}{1083} +\glossaryentry{alg.req.ind.cmp@ {\memgloterm{alg.req.ind.cmp}}{\memglodesc{(\ref {alg.req.ind.cmp})}} {\memgloref{}}|memjustarg}{1083} +\glossaryentry{alg.req.permutable@ {\memgloterm{alg.req.permutable}}{\memglodesc{(\ref {alg.req.permutable})}} {\memgloref{}}|memjustarg}{1083} +\glossaryentry{alg.req.mergeable@ {\memgloterm{alg.req.mergeable}}{\memglodesc{(\ref {alg.req.mergeable})}} {\memgloref{}}|memjustarg}{1083} +\glossaryentry{alg.req.sortable@ {\memgloterm{alg.req.sortable}}{\memglodesc{(\ref {alg.req.sortable})}} {\memgloref{}}|memjustarg}{1084} +\glossaryentry{iterator.primitives@ {\memgloterm{iterator.primitives}}{\memglodesc{(\ref {iterator.primitives})}} {\memgloref{}}|memjustarg}{1084} +\glossaryentry{iterator.primitives.general@ {\memgloterm{iterator.primitives.general}}{\memglodesc{(\ref {iterator.primitives.general})}} {\memgloref{}}|memjustarg}{1084} +\glossaryentry{std.iterator.tags@ {\memgloterm{std.iterator.tags}}{\memglodesc{(\ref {std.iterator.tags})}} {\memgloref{}}|memjustarg}{1084} +\glossaryentry{iterator.operations@ {\memgloterm{iterator.operations}}{\memglodesc{(\ref {iterator.operations})}} {\memgloref{}}|memjustarg}{1085} +\glossaryentry{range.iter.ops@ {\memgloterm{range.iter.ops}}{\memglodesc{(\ref {range.iter.ops})}} {\memgloref{}}|memjustarg}{1085} +\glossaryentry{range.iter.ops.general@ {\memgloterm{range.iter.ops.general}}{\memglodesc{(\ref {range.iter.ops.general})}} {\memgloref{}}|memjustarg}{1085} +\glossaryentry{range.iter.op.advance@ {\memgloterm{range.iter.op.advance}}{\memglodesc{(\ref {range.iter.op.advance})}} {\memgloref{}}|memjustarg}{1086} +\glossaryentry{range.iter.op.distance@ {\memgloterm{range.iter.op.distance}}{\memglodesc{(\ref {range.iter.op.distance})}} {\memgloref{}}|memjustarg}{1086} +\glossaryentry{range.iter.op.next@ {\memgloterm{range.iter.op.next}}{\memglodesc{(\ref {range.iter.op.next})}} {\memgloref{}}|memjustarg}{1087} +\glossaryentry{range.iter.op.prev@ {\memgloterm{range.iter.op.prev}}{\memglodesc{(\ref {range.iter.op.prev})}} {\memgloref{}}|memjustarg}{1087} +\glossaryentry{predef.iterators@ {\memgloterm{predef.iterators}}{\memglodesc{(\ref {predef.iterators})}} {\memgloref{}}|memjustarg}{1087} +\glossaryentry{reverse.iterators@ {\memgloterm{reverse.iterators}}{\memglodesc{(\ref {reverse.iterators})}} {\memgloref{}}|memjustarg}{1087} +\glossaryentry{reverse.iterators.general@ {\memgloterm{reverse.iterators.general}}{\memglodesc{(\ref {reverse.iterators.general})}} {\memgloref{}}|memjustarg}{1087} +\glossaryentry{reverse.iterator@ {\memgloterm{reverse.iterator}}{\memglodesc{(\ref {reverse.iterator})}} {\memgloref{}}|memjustarg}{1087} +\glossaryentry{reverse.iter.requirements@ {\memgloterm{reverse.iter.requirements}}{\memglodesc{(\ref {reverse.iter.requirements})}} {\memgloref{}}|memjustarg}{1088} +\glossaryentry{reverse.iter.cons@ {\memgloterm{reverse.iter.cons}}{\memglodesc{(\ref {reverse.iter.cons})}} {\memgloref{}}|memjustarg}{1088} +\glossaryentry{reverse.iter.conv@ {\memgloterm{reverse.iter.conv}}{\memglodesc{(\ref {reverse.iter.conv})}} {\memgloref{}}|memjustarg}{1089} +\glossaryentry{reverse.iter.elem@ {\memgloterm{reverse.iter.elem}}{\memglodesc{(\ref {reverse.iter.elem})}} {\memgloref{}}|memjustarg}{1089} +\glossaryentry{reverse.iter.nav@ {\memgloterm{reverse.iter.nav}}{\memglodesc{(\ref {reverse.iter.nav})}} {\memgloref{}}|memjustarg}{1089} +\glossaryentry{reverse.iter.cmp@ {\memgloterm{reverse.iter.cmp}}{\memglodesc{(\ref {reverse.iter.cmp})}} {\memgloref{}}|memjustarg}{1090} +\glossaryentry{reverse.iter.nonmember@ {\memgloterm{reverse.iter.nonmember}}{\memglodesc{(\ref {reverse.iter.nonmember})}} {\memgloref{}}|memjustarg}{1091} +\glossaryentry{insert.iterators@ {\memgloterm{insert.iterators}}{\memglodesc{(\ref {insert.iterators})}} {\memgloref{}}|memjustarg}{1091} +\glossaryentry{insert.iterators.general@ {\memgloterm{insert.iterators.general}}{\memglodesc{(\ref {insert.iterators.general})}} {\memgloref{}}|memjustarg}{1091} +\glossaryentry{back.insert.iterator@ {\memgloterm{back.insert.iterator}}{\memglodesc{(\ref {back.insert.iterator})}} {\memgloref{}}|memjustarg}{1092} +\glossaryentry{back.insert.iter.ops@ {\memgloterm{back.insert.iter.ops}}{\memglodesc{(\ref {back.insert.iter.ops})}} {\memgloref{}}|memjustarg}{1092} +\glossaryentry{back.inserter@ {\memgloterm{back.inserter}}{\memglodesc{(\ref {back.inserter})}} {\memgloref{}}|memjustarg}{1093} +\glossaryentry{front.insert.iterator@ {\memgloterm{front.insert.iterator}}{\memglodesc{(\ref {front.insert.iterator})}} {\memgloref{}}|memjustarg}{1093} +\glossaryentry{front.insert.iter.ops@ {\memgloterm{front.insert.iter.ops}}{\memglodesc{(\ref {front.insert.iter.ops})}} {\memgloref{}}|memjustarg}{1093} +\glossaryentry{front.inserter@ {\memgloterm{front.inserter}}{\memglodesc{(\ref {front.inserter})}} {\memgloref{}}|memjustarg}{1093} +\glossaryentry{insert.iterator@ {\memgloterm{insert.iterator}}{\memglodesc{(\ref {insert.iterator})}} {\memgloref{}}|memjustarg}{1094} +\glossaryentry{insert.iter.ops@ {\memgloterm{insert.iter.ops}}{\memglodesc{(\ref {insert.iter.ops})}} {\memgloref{}}|memjustarg}{1094} +\glossaryentry{inserter@ {\memgloterm{inserter}}{\memglodesc{(\ref {inserter})}} {\memgloref{}}|memjustarg}{1094} +\glossaryentry{const.iterators@ {\memgloterm{const.iterators}}{\memglodesc{(\ref {const.iterators})}} {\memgloref{}}|memjustarg}{1095} +\glossaryentry{const.iterators.general@ {\memgloterm{const.iterators.general}}{\memglodesc{(\ref {const.iterators.general})}} {\memgloref{}}|memjustarg}{1095} +\glossaryentry{const.iterators.alias@ {\memgloterm{const.iterators.alias}}{\memglodesc{(\ref {const.iterators.alias})}} {\memgloref{}}|memjustarg}{1095} +\glossaryentry{const.iterators.iterator@ {\memgloterm{const.iterators.iterator}}{\memglodesc{(\ref {const.iterators.iterator})}} {\memgloref{}}|memjustarg}{1095} +\glossaryentry{const.iterators.types@ {\memgloterm{const.iterators.types}}{\memglodesc{(\ref {const.iterators.types})}} {\memgloref{}}|memjustarg}{1097} +\glossaryentry{const.iterators.ops@ {\memgloterm{const.iterators.ops}}{\memglodesc{(\ref {const.iterators.ops})}} {\memgloref{}}|memjustarg}{1097} +\glossaryentry{move.iterators@ {\memgloterm{move.iterators}}{\memglodesc{(\ref {move.iterators})}} {\memgloref{}}|memjustarg}{1100} +\glossaryentry{move.iterators.general@ {\memgloterm{move.iterators.general}}{\memglodesc{(\ref {move.iterators.general})}} {\memgloref{}}|memjustarg}{1100} +\glossaryentry{move.iterator@ {\memgloterm{move.iterator}}{\memglodesc{(\ref {move.iterator})}} {\memgloref{}}|memjustarg}{1100} +\glossaryentry{move.iter.requirements@ {\memgloterm{move.iter.requirements}}{\memglodesc{(\ref {move.iter.requirements})}} {\memgloref{}}|memjustarg}{1101} +\glossaryentry{move.iter.cons@ {\memgloterm{move.iter.cons}}{\memglodesc{(\ref {move.iter.cons})}} {\memgloref{}}|memjustarg}{1101} +\glossaryentry{move.iter.op.conv@ {\memgloterm{move.iter.op.conv}}{\memglodesc{(\ref {move.iter.op.conv})}} {\memgloref{}}|memjustarg}{1101} +\glossaryentry{move.iter.elem@ {\memgloterm{move.iter.elem}}{\memglodesc{(\ref {move.iter.elem})}} {\memgloref{}}|memjustarg}{1102} +\glossaryentry{move.iter.nav@ {\memgloterm{move.iter.nav}}{\memglodesc{(\ref {move.iter.nav})}} {\memgloref{}}|memjustarg}{1102} +\glossaryentry{move.iter.op.comp@ {\memgloterm{move.iter.op.comp}}{\memglodesc{(\ref {move.iter.op.comp})}} {\memgloref{}}|memjustarg}{1102} +\glossaryentry{move.iter.nonmember@ {\memgloterm{move.iter.nonmember}}{\memglodesc{(\ref {move.iter.nonmember})}} {\memgloref{}}|memjustarg}{1103} +\glossaryentry{move.sentinel@ {\memgloterm{move.sentinel}}{\memglodesc{(\ref {move.sentinel})}} {\memgloref{}}|memjustarg}{1104} +\glossaryentry{move.sent.ops@ {\memgloterm{move.sent.ops}}{\memglodesc{(\ref {move.sent.ops})}} {\memgloref{}}|memjustarg}{1104} +\glossaryentry{iterators.common@ {\memgloterm{iterators.common}}{\memglodesc{(\ref {iterators.common})}} {\memgloref{}}|memjustarg}{1105} +\glossaryentry{common.iterator@ {\memgloterm{common.iterator}}{\memglodesc{(\ref {common.iterator})}} {\memgloref{}}|memjustarg}{1105} +\glossaryentry{common.iter.types@ {\memgloterm{common.iter.types}}{\memglodesc{(\ref {common.iter.types})}} {\memgloref{}}|memjustarg}{1106} +\glossaryentry{common.iter.const@ {\memgloterm{common.iter.const}}{\memglodesc{(\ref {common.iter.const})}} {\memgloref{}}|memjustarg}{1106} +\glossaryentry{common.iter.access@ {\memgloterm{common.iter.access}}{\memglodesc{(\ref {common.iter.access})}} {\memgloref{}}|memjustarg}{1107} +\glossaryentry{common.iter.nav@ {\memgloterm{common.iter.nav}}{\memglodesc{(\ref {common.iter.nav})}} {\memgloref{}}|memjustarg}{1107} +\glossaryentry{common.iter.cmp@ {\memgloterm{common.iter.cmp}}{\memglodesc{(\ref {common.iter.cmp})}} {\memgloref{}}|memjustarg}{1108} +\glossaryentry{common.iter.cust@ {\memgloterm{common.iter.cust}}{\memglodesc{(\ref {common.iter.cust})}} {\memgloref{}}|memjustarg}{1108} +\glossaryentry{default.sentinel@ {\memgloterm{default.sentinel}}{\memglodesc{(\ref {default.sentinel})}} {\memgloref{}}|memjustarg}{1109} +\glossaryentry{iterators.counted@ {\memgloterm{iterators.counted}}{\memglodesc{(\ref {iterators.counted})}} {\memgloref{}}|memjustarg}{1109} +\glossaryentry{counted.iterator@ {\memgloterm{counted.iterator}}{\memglodesc{(\ref {counted.iterator})}} {\memgloref{}}|memjustarg}{1109} +\glossaryentry{counted.iter.const@ {\memgloterm{counted.iter.const}}{\memglodesc{(\ref {counted.iter.const})}} {\memgloref{}}|memjustarg}{1110} +\glossaryentry{counted.iter.access@ {\memgloterm{counted.iter.access}}{\memglodesc{(\ref {counted.iter.access})}} {\memgloref{}}|memjustarg}{1111} +\glossaryentry{counted.iter.elem@ {\memgloterm{counted.iter.elem}}{\memglodesc{(\ref {counted.iter.elem})}} {\memgloref{}}|memjustarg}{1111} +\glossaryentry{counted.iter.nav@ {\memgloterm{counted.iter.nav}}{\memglodesc{(\ref {counted.iter.nav})}} {\memgloref{}}|memjustarg}{1111} +\glossaryentry{counted.iter.cmp@ {\memgloterm{counted.iter.cmp}}{\memglodesc{(\ref {counted.iter.cmp})}} {\memgloref{}}|memjustarg}{1113} +\glossaryentry{counted.iter.cust@ {\memgloterm{counted.iter.cust}}{\memglodesc{(\ref {counted.iter.cust})}} {\memgloref{}}|memjustarg}{1113} +\glossaryentry{unreachable.sentinel@ {\memgloterm{unreachable.sentinel}}{\memglodesc{(\ref {unreachable.sentinel})}} {\memgloref{}}|memjustarg}{1113} +\glossaryentry{stream.iterators@ {\memgloterm{stream.iterators}}{\memglodesc{(\ref {stream.iterators})}} {\memgloref{}}|memjustarg}{1114} +\glossaryentry{stream.iterators.general@ {\memgloterm{stream.iterators.general}}{\memglodesc{(\ref {stream.iterators.general})}} {\memgloref{}}|memjustarg}{1114} +\glossaryentry{istream.iterator@ {\memgloterm{istream.iterator}}{\memglodesc{(\ref {istream.iterator})}} {\memgloref{}}|memjustarg}{1114} +\glossaryentry{istream.iterator.general@ {\memgloterm{istream.iterator.general}}{\memglodesc{(\ref {istream.iterator.general})}} {\memgloref{}}|memjustarg}{1114} +\glossaryentry{istream.iterator.cons@ {\memgloterm{istream.iterator.cons}}{\memglodesc{(\ref {istream.iterator.cons})}} {\memgloref{}}|memjustarg}{1114} +\glossaryentry{istream.iterator.ops@ {\memgloterm{istream.iterator.ops}}{\memglodesc{(\ref {istream.iterator.ops})}} {\memgloref{}}|memjustarg}{1115} +\glossaryentry{ostream.iterator@ {\memgloterm{ostream.iterator}}{\memglodesc{(\ref {ostream.iterator})}} {\memgloref{}}|memjustarg}{1115} +\glossaryentry{ostream.iterator.general@ {\memgloterm{ostream.iterator.general}}{\memglodesc{(\ref {ostream.iterator.general})}} {\memgloref{}}|memjustarg}{1115} +\glossaryentry{ostream.iterator.cons.des@ {\memgloterm{ostream.iterator.cons.des}}{\memglodesc{(\ref {ostream.iterator.cons.des})}} {\memgloref{}}|memjustarg}{1116} +\glossaryentry{ostream.iterator.ops@ {\memgloterm{ostream.iterator.ops}}{\memglodesc{(\ref {ostream.iterator.ops})}} {\memgloref{}}|memjustarg}{1116} +\glossaryentry{istreambuf.iterator@ {\memgloterm{istreambuf.iterator}}{\memglodesc{(\ref {istreambuf.iterator})}} {\memgloref{}}|memjustarg}{1116} +\glossaryentry{istreambuf.iterator.general@ {\memgloterm{istreambuf.iterator.general}}{\memglodesc{(\ref {istreambuf.iterator.general})}} {\memgloref{}}|memjustarg}{1116} +\glossaryentry{istreambuf.iterator.proxy@ {\memgloterm{istreambuf.iterator.proxy}}{\memglodesc{(\ref {istreambuf.iterator.proxy})}} {\memgloref{}}|memjustarg}{1117} +\glossaryentry{istreambuf.iterator.cons@ {\memgloterm{istreambuf.iterator.cons}}{\memglodesc{(\ref {istreambuf.iterator.cons})}} {\memgloref{}}|memjustarg}{1117} +\glossaryentry{istreambuf.iterator.ops@ {\memgloterm{istreambuf.iterator.ops}}{\memglodesc{(\ref {istreambuf.iterator.ops})}} {\memgloref{}}|memjustarg}{1118} +\glossaryentry{ostreambuf.iterator@ {\memgloterm{ostreambuf.iterator}}{\memglodesc{(\ref {ostreambuf.iterator})}} {\memgloref{}}|memjustarg}{1118} +\glossaryentry{ostreambuf.iterator.general@ {\memgloterm{ostreambuf.iterator.general}}{\memglodesc{(\ref {ostreambuf.iterator.general})}} {\memgloref{}}|memjustarg}{1118} +\glossaryentry{ostreambuf.iter.cons@ {\memgloterm{ostreambuf.iter.cons}}{\memglodesc{(\ref {ostreambuf.iter.cons})}} {\memgloref{}}|memjustarg}{1119} +\glossaryentry{ostreambuf.iter.ops@ {\memgloterm{ostreambuf.iter.ops}}{\memglodesc{(\ref {ostreambuf.iter.ops})}} {\memgloref{}}|memjustarg}{1119} +\glossaryentry{iterator.range@ {\memgloterm{iterator.range}}{\memglodesc{(\ref {iterator.range})}} {\memgloref{}}|memjustarg}{1119} +\glossaryentry{ranges@ {\memgloterm{ranges}}{\memglodesc{(\ref {ranges})}} {\memgloref{}}|memjustarg}{1122} +\glossaryentry{ranges.general@ {\memgloterm{ranges.general}}{\memglodesc{(\ref {ranges.general})}} {\memgloref{}}|memjustarg}{1122} +\glossaryentry{ranges.syn@ {\memgloterm{ranges.syn}}{\memglodesc{(\ref {ranges.syn})}} {\memgloref{}}|memjustarg}{1122} +\glossaryentry{range.access@ {\memgloterm{range.access}}{\memglodesc{(\ref {range.access})}} {\memgloref{}}|memjustarg}{1131} +\glossaryentry{range.access.general@ {\memgloterm{range.access.general}}{\memglodesc{(\ref {range.access.general})}} {\memgloref{}}|memjustarg}{1131} +\glossaryentry{range.access.begin@ {\memgloterm{range.access.begin}}{\memglodesc{(\ref {range.access.begin})}} {\memgloref{}}|memjustarg}{1131} +\glossaryentry{range.access.end@ {\memgloterm{range.access.end}}{\memglodesc{(\ref {range.access.end})}} {\memgloref{}}|memjustarg}{1131} +\glossaryentry{range.access.cbegin@ {\memgloterm{range.access.cbegin}}{\memglodesc{(\ref {range.access.cbegin})}} {\memgloref{}}|memjustarg}{1132} +\glossaryentry{range.access.cend@ {\memgloterm{range.access.cend}}{\memglodesc{(\ref {range.access.cend})}} {\memgloref{}}|memjustarg}{1132} +\glossaryentry{range.access.rbegin@ {\memgloterm{range.access.rbegin}}{\memglodesc{(\ref {range.access.rbegin})}} {\memgloref{}}|memjustarg}{1132} +\glossaryentry{range.access.rend@ {\memgloterm{range.access.rend}}{\memglodesc{(\ref {range.access.rend})}} {\memgloref{}}|memjustarg}{1132} +\glossaryentry{range.access.crbegin@ {\memgloterm{range.access.crbegin}}{\memglodesc{(\ref {range.access.crbegin})}} {\memgloref{}}|memjustarg}{1133} +\glossaryentry{range.access.crend@ {\memgloterm{range.access.crend}}{\memglodesc{(\ref {range.access.crend})}} {\memgloref{}}|memjustarg}{1133} +\glossaryentry{range.prim.size@ {\memgloterm{range.prim.size}}{\memglodesc{(\ref {range.prim.size})}} {\memgloref{}}|memjustarg}{1133} +\glossaryentry{range.prim.ssize@ {\memgloterm{range.prim.ssize}}{\memglodesc{(\ref {range.prim.ssize})}} {\memgloref{}}|memjustarg}{1134} +\glossaryentry{range.prim.empty@ {\memgloterm{range.prim.empty}}{\memglodesc{(\ref {range.prim.empty})}} {\memgloref{}}|memjustarg}{1134} +\glossaryentry{range.prim.data@ {\memgloterm{range.prim.data}}{\memglodesc{(\ref {range.prim.data})}} {\memgloref{}}|memjustarg}{1134} +\glossaryentry{range.prim.cdata@ {\memgloterm{range.prim.cdata}}{\memglodesc{(\ref {range.prim.cdata})}} {\memgloref{}}|memjustarg}{1134} +\glossaryentry{range.req@ {\memgloterm{range.req}}{\memglodesc{(\ref {range.req})}} {\memgloref{}}|memjustarg}{1135} +\glossaryentry{range.req.general@ {\memgloterm{range.req.general}}{\memglodesc{(\ref {range.req.general})}} {\memgloref{}}|memjustarg}{1135} +\glossaryentry{range.range@ {\memgloterm{range.range}}{\memglodesc{(\ref {range.range})}} {\memgloref{}}|memjustarg}{1135} +\glossaryentry{range.sized@ {\memgloterm{range.sized}}{\memglodesc{(\ref {range.sized})}} {\memgloref{}}|memjustarg}{1136} +\glossaryentry{range.view@ {\memgloterm{range.view}}{\memglodesc{(\ref {range.view})}} {\memgloref{}}|memjustarg}{1136} +\glossaryentry{range.refinements@ {\memgloterm{range.refinements}}{\memglodesc{(\ref {range.refinements})}} {\memgloref{}}|memjustarg}{1137} +\glossaryentry{range.utility@ {\memgloterm{range.utility}}{\memglodesc{(\ref {range.utility})}} {\memgloref{}}|memjustarg}{1138} +\glossaryentry{range.utility.general@ {\memgloterm{range.utility.general}}{\memglodesc{(\ref {range.utility.general})}} {\memgloref{}}|memjustarg}{1138} +\glossaryentry{range.utility.helpers@ {\memgloterm{range.utility.helpers}}{\memglodesc{(\ref {range.utility.helpers})}} {\memgloref{}}|memjustarg}{1138} +\glossaryentry{view.interface@ {\memgloterm{view.interface}}{\memglodesc{(\ref {view.interface})}} {\memgloref{}}|memjustarg}{1138} +\glossaryentry{view.interface.general@ {\memgloterm{view.interface.general}}{\memglodesc{(\ref {view.interface.general})}} {\memgloref{}}|memjustarg}{1138} +\glossaryentry{view.interface.members@ {\memgloterm{view.interface.members}}{\memglodesc{(\ref {view.interface.members})}} {\memgloref{}}|memjustarg}{1140} +\glossaryentry{range.subrange@ {\memgloterm{range.subrange}}{\memglodesc{(\ref {range.subrange})}} {\memgloref{}}|memjustarg}{1140} +\glossaryentry{range.subrange.general@ {\memgloterm{range.subrange.general}}{\memglodesc{(\ref {range.subrange.general})}} {\memgloref{}}|memjustarg}{1140} +\glossaryentry{range.subrange.ctor@ {\memgloterm{range.subrange.ctor}}{\memglodesc{(\ref {range.subrange.ctor})}} {\memgloref{}}|memjustarg}{1141} +\glossaryentry{range.subrange.access@ {\memgloterm{range.subrange.access}}{\memglodesc{(\ref {range.subrange.access})}} {\memgloref{}}|memjustarg}{1142} +\glossaryentry{range.dangling@ {\memgloterm{range.dangling}}{\memglodesc{(\ref {range.dangling})}} {\memgloref{}}|memjustarg}{1143} +\glossaryentry{range.elementsof@ {\memgloterm{range.elementsof}}{\memglodesc{(\ref {range.elementsof})}} {\memgloref{}}|memjustarg}{1144} +\glossaryentry{range.utility.conv@ {\memgloterm{range.utility.conv}}{\memglodesc{(\ref {range.utility.conv})}} {\memgloref{}}|memjustarg}{1144} +\glossaryentry{range.utility.conv.general@ {\memgloterm{range.utility.conv.general}}{\memglodesc{(\ref {range.utility.conv.general})}} {\memgloref{}}|memjustarg}{1144} +\glossaryentry{range.utility.conv.to@ {\memgloterm{range.utility.conv.to}}{\memglodesc{(\ref {range.utility.conv.to})}} {\memgloref{}}|memjustarg}{1145} +\glossaryentry{range.utility.conv.adaptors@ {\memgloterm{range.utility.conv.adaptors}}{\memglodesc{(\ref {range.utility.conv.adaptors})}} {\memgloref{}}|memjustarg}{1146} +\glossaryentry{range.factories@ {\memgloterm{range.factories}}{\memglodesc{(\ref {range.factories})}} {\memgloref{}}|memjustarg}{1146} +\glossaryentry{range.factories.general@ {\memgloterm{range.factories.general}}{\memglodesc{(\ref {range.factories.general})}} {\memgloref{}}|memjustarg}{1146} +\glossaryentry{range.empty@ {\memgloterm{range.empty}}{\memglodesc{(\ref {range.empty})}} {\memgloref{}}|memjustarg}{1146} +\glossaryentry{range.empty.overview@ {\memgloterm{range.empty.overview}}{\memglodesc{(\ref {range.empty.overview})}} {\memgloref{}}|memjustarg}{1146} +\glossaryentry{range.empty.view@ {\memgloterm{range.empty.view}}{\memglodesc{(\ref {range.empty.view})}} {\memgloref{}}|memjustarg}{1146} +\glossaryentry{range.single@ {\memgloterm{range.single}}{\memglodesc{(\ref {range.single})}} {\memgloref{}}|memjustarg}{1147} +\glossaryentry{range.single.overview@ {\memgloterm{range.single.overview}}{\memglodesc{(\ref {range.single.overview})}} {\memgloref{}}|memjustarg}{1147} +\glossaryentry{range.single.view@ {\memgloterm{range.single.view}}{\memglodesc{(\ref {range.single.view})}} {\memgloref{}}|memjustarg}{1147} +\glossaryentry{range.iota@ {\memgloterm{range.iota}}{\memglodesc{(\ref {range.iota})}} {\memgloref{}}|memjustarg}{1148} +\glossaryentry{range.iota.overview@ {\memgloterm{range.iota.overview}}{\memglodesc{(\ref {range.iota.overview})}} {\memgloref{}}|memjustarg}{1148} +\glossaryentry{range.iota.view@ {\memgloterm{range.iota.view}}{\memglodesc{(\ref {range.iota.view})}} {\memgloref{}}|memjustarg}{1148} +\glossaryentry{range.iota.iterator@ {\memgloterm{range.iota.iterator}}{\memglodesc{(\ref {range.iota.iterator})}} {\memgloref{}}|memjustarg}{1150} +\glossaryentry{range.iota.sentinel@ {\memgloterm{range.iota.sentinel}}{\memglodesc{(\ref {range.iota.sentinel})}} {\memgloref{}}|memjustarg}{1153} +\glossaryentry{range.repeat@ {\memgloterm{range.repeat}}{\memglodesc{(\ref {range.repeat})}} {\memgloref{}}|memjustarg}{1154} +\glossaryentry{range.repeat.overview@ {\memgloterm{range.repeat.overview}}{\memglodesc{(\ref {range.repeat.overview})}} {\memgloref{}}|memjustarg}{1154} +\glossaryentry{range.repeat.view@ {\memgloterm{range.repeat.view}}{\memglodesc{(\ref {range.repeat.view})}} {\memgloref{}}|memjustarg}{1154} +\glossaryentry{range.repeat.iterator@ {\memgloterm{range.repeat.iterator}}{\memglodesc{(\ref {range.repeat.iterator})}} {\memgloref{}}|memjustarg}{1155} +\glossaryentry{range.istream@ {\memgloterm{range.istream}}{\memglodesc{(\ref {range.istream})}} {\memgloref{}}|memjustarg}{1157} +\glossaryentry{range.istream.overview@ {\memgloterm{range.istream.overview}}{\memglodesc{(\ref {range.istream.overview})}} {\memgloref{}}|memjustarg}{1157} +\glossaryentry{range.istream.view@ {\memgloterm{range.istream.view}}{\memglodesc{(\ref {range.istream.view})}} {\memgloref{}}|memjustarg}{1158} +\glossaryentry{range.istream.iterator@ {\memgloterm{range.istream.iterator}}{\memglodesc{(\ref {range.istream.iterator})}} {\memgloref{}}|memjustarg}{1158} +\glossaryentry{range.adaptors@ {\memgloterm{range.adaptors}}{\memglodesc{(\ref {range.adaptors})}} {\memgloref{}}|memjustarg}{1159} +\glossaryentry{range.adaptors.general@ {\memgloterm{range.adaptors.general}}{\memglodesc{(\ref {range.adaptors.general})}} {\memgloref{}}|memjustarg}{1159} +\glossaryentry{range.adaptor.object@ {\memgloterm{range.adaptor.object}}{\memglodesc{(\ref {range.adaptor.object})}} {\memgloref{}}|memjustarg}{1159} +\glossaryentry{range.move.wrap@ {\memgloterm{range.move.wrap}}{\memglodesc{(\ref {range.move.wrap})}} {\memgloref{}}|memjustarg}{1160} +\glossaryentry{range.nonprop.cache@ {\memgloterm{range.nonprop.cache}}{\memglodesc{(\ref {range.nonprop.cache})}} {\memgloref{}}|memjustarg}{1161} +\glossaryentry{range.adaptor.helpers@ {\memgloterm{range.adaptor.helpers}}{\memglodesc{(\ref {range.adaptor.helpers})}} {\memgloref{}}|memjustarg}{1162} +\glossaryentry{range.all@ {\memgloterm{range.all}}{\memglodesc{(\ref {range.all})}} {\memgloref{}}|memjustarg}{1162} +\glossaryentry{range.all.general@ {\memgloterm{range.all.general}}{\memglodesc{(\ref {range.all.general})}} {\memgloref{}}|memjustarg}{1162} +\glossaryentry{range.ref.view@ {\memgloterm{range.ref.view}}{\memglodesc{(\ref {range.ref.view})}} {\memgloref{}}|memjustarg}{1162} +\glossaryentry{range.owning.view@ {\memgloterm{range.owning.view}}{\memglodesc{(\ref {range.owning.view})}} {\memgloref{}}|memjustarg}{1163} +\glossaryentry{range.as.rvalue@ {\memgloterm{range.as.rvalue}}{\memglodesc{(\ref {range.as.rvalue})}} {\memgloref{}}|memjustarg}{1164} +\glossaryentry{range.as.rvalue.overview@ {\memgloterm{range.as.rvalue.overview}}{\memglodesc{(\ref {range.as.rvalue.overview})}} {\memgloref{}}|memjustarg}{1164} +\glossaryentry{range.as.rvalue.view@ {\memgloterm{range.as.rvalue.view}}{\memglodesc{(\ref {range.as.rvalue.view})}} {\memgloref{}}|memjustarg}{1164} +\glossaryentry{range.filter@ {\memgloterm{range.filter}}{\memglodesc{(\ref {range.filter})}} {\memgloref{}}|memjustarg}{1165} +\glossaryentry{range.filter.overview@ {\memgloterm{range.filter.overview}}{\memglodesc{(\ref {range.filter.overview})}} {\memgloref{}}|memjustarg}{1165} +\glossaryentry{range.filter.view@ {\memgloterm{range.filter.view}}{\memglodesc{(\ref {range.filter.view})}} {\memgloref{}}|memjustarg}{1165} +\glossaryentry{range.filter.iterator@ {\memgloterm{range.filter.iterator}}{\memglodesc{(\ref {range.filter.iterator})}} {\memgloref{}}|memjustarg}{1166} +\glossaryentry{range.filter.sentinel@ {\memgloterm{range.filter.sentinel}}{\memglodesc{(\ref {range.filter.sentinel})}} {\memgloref{}}|memjustarg}{1168} +\glossaryentry{range.transform@ {\memgloterm{range.transform}}{\memglodesc{(\ref {range.transform})}} {\memgloref{}}|memjustarg}{1168} +\glossaryentry{range.transform.overview@ {\memgloterm{range.transform.overview}}{\memglodesc{(\ref {range.transform.overview})}} {\memgloref{}}|memjustarg}{1168} +\glossaryentry{range.transform.view@ {\memgloterm{range.transform.view}}{\memglodesc{(\ref {range.transform.view})}} {\memgloref{}}|memjustarg}{1168} +\glossaryentry{range.transform.iterator@ {\memgloterm{range.transform.iterator}}{\memglodesc{(\ref {range.transform.iterator})}} {\memgloref{}}|memjustarg}{1170} +\glossaryentry{range.transform.sentinel@ {\memgloterm{range.transform.sentinel}}{\memglodesc{(\ref {range.transform.sentinel})}} {\memgloref{}}|memjustarg}{1173} +\glossaryentry{range.take@ {\memgloterm{range.take}}{\memglodesc{(\ref {range.take})}} {\memgloref{}}|memjustarg}{1174} +\glossaryentry{range.take.overview@ {\memgloterm{range.take.overview}}{\memglodesc{(\ref {range.take.overview})}} {\memgloref{}}|memjustarg}{1174} +\glossaryentry{range.take.view@ {\memgloterm{range.take.view}}{\memglodesc{(\ref {range.take.view})}} {\memgloref{}}|memjustarg}{1174} +\glossaryentry{range.take.sentinel@ {\memgloterm{range.take.sentinel}}{\memglodesc{(\ref {range.take.sentinel})}} {\memgloref{}}|memjustarg}{1176} +\glossaryentry{range.take.while@ {\memgloterm{range.take.while}}{\memglodesc{(\ref {range.take.while})}} {\memgloref{}}|memjustarg}{1177} +\glossaryentry{range.take.while.overview@ {\memgloterm{range.take.while.overview}}{\memglodesc{(\ref {range.take.while.overview})}} {\memgloref{}}|memjustarg}{1177} +\glossaryentry{range.take.while.view@ {\memgloterm{range.take.while.view}}{\memglodesc{(\ref {range.take.while.view})}} {\memgloref{}}|memjustarg}{1177} +\glossaryentry{range.take.while.sentinel@ {\memgloterm{range.take.while.sentinel}}{\memglodesc{(\ref {range.take.while.sentinel})}} {\memgloref{}}|memjustarg}{1178} +\glossaryentry{range.drop@ {\memgloterm{range.drop}}{\memglodesc{(\ref {range.drop})}} {\memgloref{}}|memjustarg}{1179} +\glossaryentry{range.drop.overview@ {\memgloterm{range.drop.overview}}{\memglodesc{(\ref {range.drop.overview})}} {\memgloref{}}|memjustarg}{1179} +\glossaryentry{range.drop.view@ {\memgloterm{range.drop.view}}{\memglodesc{(\ref {range.drop.view})}} {\memgloref{}}|memjustarg}{1179} +\glossaryentry{range.drop.while@ {\memgloterm{range.drop.while}}{\memglodesc{(\ref {range.drop.while})}} {\memgloref{}}|memjustarg}{1180} +\glossaryentry{range.drop.while.overview@ {\memgloterm{range.drop.while.overview}}{\memglodesc{(\ref {range.drop.while.overview})}} {\memgloref{}}|memjustarg}{1180} +\glossaryentry{range.drop.while.view@ {\memgloterm{range.drop.while.view}}{\memglodesc{(\ref {range.drop.while.view})}} {\memgloref{}}|memjustarg}{1181} +\glossaryentry{range.join@ {\memgloterm{range.join}}{\memglodesc{(\ref {range.join})}} {\memgloref{}}|memjustarg}{1181} +\glossaryentry{range.join.overview@ {\memgloterm{range.join.overview}}{\memglodesc{(\ref {range.join.overview})}} {\memgloref{}}|memjustarg}{1181} +\glossaryentry{range.join.view@ {\memgloterm{range.join.view}}{\memglodesc{(\ref {range.join.view})}} {\memgloref{}}|memjustarg}{1181} +\glossaryentry{range.join.iterator@ {\memgloterm{range.join.iterator}}{\memglodesc{(\ref {range.join.iterator})}} {\memgloref{}}|memjustarg}{1183} +\glossaryentry{range.join.sentinel@ {\memgloterm{range.join.sentinel}}{\memglodesc{(\ref {range.join.sentinel})}} {\memgloref{}}|memjustarg}{1186} +\glossaryentry{range.join.with@ {\memgloterm{range.join.with}}{\memglodesc{(\ref {range.join.with})}} {\memgloref{}}|memjustarg}{1187} +\glossaryentry{range.join.with.overview@ {\memgloterm{range.join.with.overview}}{\memglodesc{(\ref {range.join.with.overview})}} {\memgloref{}}|memjustarg}{1187} +\glossaryentry{range.join.with.view@ {\memgloterm{range.join.with.view}}{\memglodesc{(\ref {range.join.with.view})}} {\memgloref{}}|memjustarg}{1187} +\glossaryentry{range.join.with.iterator@ {\memgloterm{range.join.with.iterator}}{\memglodesc{(\ref {range.join.with.iterator})}} {\memgloref{}}|memjustarg}{1189} +\glossaryentry{range.join.with.sentinel@ {\memgloterm{range.join.with.sentinel}}{\memglodesc{(\ref {range.join.with.sentinel})}} {\memgloref{}}|memjustarg}{1192} +\glossaryentry{range.lazy.split@ {\memgloterm{range.lazy.split}}{\memglodesc{(\ref {range.lazy.split})}} {\memgloref{}}|memjustarg}{1193} +\glossaryentry{range.lazy.split.overview@ {\memgloterm{range.lazy.split.overview}}{\memglodesc{(\ref {range.lazy.split.overview})}} {\memgloref{}}|memjustarg}{1193} +\glossaryentry{range.lazy.split.view@ {\memgloterm{range.lazy.split.view}}{\memglodesc{(\ref {range.lazy.split.view})}} {\memgloref{}}|memjustarg}{1193} +\glossaryentry{range.lazy.split.outer@ {\memgloterm{range.lazy.split.outer}}{\memglodesc{(\ref {range.lazy.split.outer})}} {\memgloref{}}|memjustarg}{1195} +\glossaryentry{range.lazy.split.outer.value@ {\memgloterm{range.lazy.split.outer.value}}{\memglodesc{(\ref {range.lazy.split.outer.value})}} {\memgloref{}}|memjustarg}{1197} +\glossaryentry{range.lazy.split.inner@ {\memgloterm{range.lazy.split.inner}}{\memglodesc{(\ref {range.lazy.split.inner})}} {\memgloref{}}|memjustarg}{1197} +\glossaryentry{range.split@ {\memgloterm{range.split}}{\memglodesc{(\ref {range.split})}} {\memgloref{}}|memjustarg}{1199} +\glossaryentry{range.split.overview@ {\memgloterm{range.split.overview}}{\memglodesc{(\ref {range.split.overview})}} {\memgloref{}}|memjustarg}{1199} +\glossaryentry{range.split.view@ {\memgloterm{range.split.view}}{\memglodesc{(\ref {range.split.view})}} {\memgloref{}}|memjustarg}{1199} +\glossaryentry{range.split.iterator@ {\memgloterm{range.split.iterator}}{\memglodesc{(\ref {range.split.iterator})}} {\memgloref{}}|memjustarg}{1200} +\glossaryentry{range.split.sentinel@ {\memgloterm{range.split.sentinel}}{\memglodesc{(\ref {range.split.sentinel})}} {\memgloref{}}|memjustarg}{1201} +\glossaryentry{range.counted@ {\memgloterm{range.counted}}{\memglodesc{(\ref {range.counted})}} {\memgloref{}}|memjustarg}{1202} +\glossaryentry{range.common@ {\memgloterm{range.common}}{\memglodesc{(\ref {range.common})}} {\memgloref{}}|memjustarg}{1202} +\glossaryentry{range.common.overview@ {\memgloterm{range.common.overview}}{\memglodesc{(\ref {range.common.overview})}} {\memgloref{}}|memjustarg}{1202} +\glossaryentry{range.common.view@ {\memgloterm{range.common.view}}{\memglodesc{(\ref {range.common.view})}} {\memgloref{}}|memjustarg}{1203} +\glossaryentry{range.reverse@ {\memgloterm{range.reverse}}{\memglodesc{(\ref {range.reverse})}} {\memgloref{}}|memjustarg}{1204} +\glossaryentry{range.reverse.overview@ {\memgloterm{range.reverse.overview}}{\memglodesc{(\ref {range.reverse.overview})}} {\memgloref{}}|memjustarg}{1204} +\glossaryentry{range.reverse.view@ {\memgloterm{range.reverse.view}}{\memglodesc{(\ref {range.reverse.view})}} {\memgloref{}}|memjustarg}{1204} +\glossaryentry{range.as.const@ {\memgloterm{range.as.const}}{\memglodesc{(\ref {range.as.const})}} {\memgloref{}}|memjustarg}{1205} +\glossaryentry{range.as.const.overview@ {\memgloterm{range.as.const.overview}}{\memglodesc{(\ref {range.as.const.overview})}} {\memgloref{}}|memjustarg}{1205} +\glossaryentry{range.as.const.view@ {\memgloterm{range.as.const.view}}{\memglodesc{(\ref {range.as.const.view})}} {\memgloref{}}|memjustarg}{1205} +\glossaryentry{range.elements@ {\memgloterm{range.elements}}{\memglodesc{(\ref {range.elements})}} {\memgloref{}}|memjustarg}{1206} +\glossaryentry{range.elements.overview@ {\memgloterm{range.elements.overview}}{\memglodesc{(\ref {range.elements.overview})}} {\memgloref{}}|memjustarg}{1206} +\glossaryentry{range.elements.view@ {\memgloterm{range.elements.view}}{\memglodesc{(\ref {range.elements.view})}} {\memgloref{}}|memjustarg}{1207} +\glossaryentry{range.elements.iterator@ {\memgloterm{range.elements.iterator}}{\memglodesc{(\ref {range.elements.iterator})}} {\memgloref{}}|memjustarg}{1207} +\glossaryentry{range.elements.sentinel@ {\memgloterm{range.elements.sentinel}}{\memglodesc{(\ref {range.elements.sentinel})}} {\memgloref{}}|memjustarg}{1211} +\glossaryentry{range.enumerate@ {\memgloterm{range.enumerate}}{\memglodesc{(\ref {range.enumerate})}} {\memgloref{}}|memjustarg}{1212} +\glossaryentry{range.enumerate.overview@ {\memgloterm{range.enumerate.overview}}{\memglodesc{(\ref {range.enumerate.overview})}} {\memgloref{}}|memjustarg}{1212} +\glossaryentry{range.enumerate.view@ {\memgloterm{range.enumerate.view}}{\memglodesc{(\ref {range.enumerate.view})}} {\memgloref{}}|memjustarg}{1212} +\glossaryentry{range.enumerate.iterator@ {\memgloterm{range.enumerate.iterator}}{\memglodesc{(\ref {range.enumerate.iterator})}} {\memgloref{}}|memjustarg}{1213} +\glossaryentry{range.enumerate.sentinel@ {\memgloterm{range.enumerate.sentinel}}{\memglodesc{(\ref {range.enumerate.sentinel})}} {\memgloref{}}|memjustarg}{1215} +\glossaryentry{range.zip@ {\memgloterm{range.zip}}{\memglodesc{(\ref {range.zip})}} {\memgloref{}}|memjustarg}{1216} +\glossaryentry{range.zip.overview@ {\memgloterm{range.zip.overview}}{\memglodesc{(\ref {range.zip.overview})}} {\memgloref{}}|memjustarg}{1216} +\glossaryentry{range.zip.view@ {\memgloterm{range.zip.view}}{\memglodesc{(\ref {range.zip.view})}} {\memgloref{}}|memjustarg}{1217} +\glossaryentry{range.zip.iterator@ {\memgloterm{range.zip.iterator}}{\memglodesc{(\ref {range.zip.iterator})}} {\memgloref{}}|memjustarg}{1218} +\glossaryentry{range.zip.sentinel@ {\memgloterm{range.zip.sentinel}}{\memglodesc{(\ref {range.zip.sentinel})}} {\memgloref{}}|memjustarg}{1221} +\glossaryentry{range.zip.transform@ {\memgloterm{range.zip.transform}}{\memglodesc{(\ref {range.zip.transform})}} {\memgloref{}}|memjustarg}{1222} +\glossaryentry{range.zip.transform.overview@ {\memgloterm{range.zip.transform.overview}}{\memglodesc{(\ref {range.zip.transform.overview})}} {\memgloref{}}|memjustarg}{1222} +\glossaryentry{range.zip.transform.view@ {\memgloterm{range.zip.transform.view}}{\memglodesc{(\ref {range.zip.transform.view})}} {\memgloref{}}|memjustarg}{1223} +\glossaryentry{range.zip.transform.iterator@ {\memgloterm{range.zip.transform.iterator}}{\memglodesc{(\ref {range.zip.transform.iterator})}} {\memgloref{}}|memjustarg}{1224} +\glossaryentry{range.zip.transform.sentinel@ {\memgloterm{range.zip.transform.sentinel}}{\memglodesc{(\ref {range.zip.transform.sentinel})}} {\memgloref{}}|memjustarg}{1226} +\glossaryentry{range.adjacent@ {\memgloterm{range.adjacent}}{\memglodesc{(\ref {range.adjacent})}} {\memgloref{}}|memjustarg}{1227} +\glossaryentry{range.adjacent.overview@ {\memgloterm{range.adjacent.overview}}{\memglodesc{(\ref {range.adjacent.overview})}} {\memgloref{}}|memjustarg}{1227} +\glossaryentry{range.adjacent.view@ {\memgloterm{range.adjacent.view}}{\memglodesc{(\ref {range.adjacent.view})}} {\memgloref{}}|memjustarg}{1228} +\glossaryentry{range.adjacent.iterator@ {\memgloterm{range.adjacent.iterator}}{\memglodesc{(\ref {range.adjacent.iterator})}} {\memgloref{}}|memjustarg}{1229} +\glossaryentry{range.adjacent.sentinel@ {\memgloterm{range.adjacent.sentinel}}{\memglodesc{(\ref {range.adjacent.sentinel})}} {\memgloref{}}|memjustarg}{1232} +\glossaryentry{range.adjacent.transform@ {\memgloterm{range.adjacent.transform}}{\memglodesc{(\ref {range.adjacent.transform})}} {\memgloref{}}|memjustarg}{1233} +\glossaryentry{range.adjacent.transform.overview@ {\memgloterm{range.adjacent.transform.overview}}{\memglodesc{(\ref {range.adjacent.transform.overview})}} {\memgloref{}}|memjustarg}{1233} +\glossaryentry{range.adjacent.transform.view@ {\memgloterm{range.adjacent.transform.view}}{\memglodesc{(\ref {range.adjacent.transform.view})}} {\memgloref{}}|memjustarg}{1233} +\glossaryentry{range.adjacent.transform.iterator@ {\memgloterm{range.adjacent.transform.iterator}}{\memglodesc{(\ref {range.adjacent.transform.iterator})}} {\memgloref{}}|memjustarg}{1234} +\glossaryentry{range.adjacent.transform.sentinel@ {\memgloterm{range.adjacent.transform.sentinel}}{\memglodesc{(\ref {range.adjacent.transform.sentinel})}} {\memgloref{}}|memjustarg}{1237} +\glossaryentry{range.chunk@ {\memgloterm{range.chunk}}{\memglodesc{(\ref {range.chunk})}} {\memgloref{}}|memjustarg}{1238} +\glossaryentry{range.chunk.overview@ {\memgloterm{range.chunk.overview}}{\memglodesc{(\ref {range.chunk.overview})}} {\memgloref{}}|memjustarg}{1238} +\glossaryentry{range.chunk.view.input@ {\memgloterm{range.chunk.view.input}}{\memglodesc{(\ref {range.chunk.view.input})}} {\memgloref{}}|memjustarg}{1238} +\glossaryentry{range.chunk.outer.iter@ {\memgloterm{range.chunk.outer.iter}}{\memglodesc{(\ref {range.chunk.outer.iter})}} {\memgloref{}}|memjustarg}{1239} +\glossaryentry{range.chunk.outer.value@ {\memgloterm{range.chunk.outer.value}}{\memglodesc{(\ref {range.chunk.outer.value})}} {\memgloref{}}|memjustarg}{1240} +\glossaryentry{range.chunk.inner.iter@ {\memgloterm{range.chunk.inner.iter}}{\memglodesc{(\ref {range.chunk.inner.iter})}} {\memgloref{}}|memjustarg}{1241} +\glossaryentry{range.chunk.view.fwd@ {\memgloterm{range.chunk.view.fwd}}{\memglodesc{(\ref {range.chunk.view.fwd})}} {\memgloref{}}|memjustarg}{1242} +\glossaryentry{range.chunk.fwd.iter@ {\memgloterm{range.chunk.fwd.iter}}{\memglodesc{(\ref {range.chunk.fwd.iter})}} {\memgloref{}}|memjustarg}{1243} +\glossaryentry{range.slide@ {\memgloterm{range.slide}}{\memglodesc{(\ref {range.slide})}} {\memgloref{}}|memjustarg}{1247} +\glossaryentry{range.slide.overview@ {\memgloterm{range.slide.overview}}{\memglodesc{(\ref {range.slide.overview})}} {\memgloref{}}|memjustarg}{1247} +\glossaryentry{range.slide.view@ {\memgloterm{range.slide.view}}{\memglodesc{(\ref {range.slide.view})}} {\memgloref{}}|memjustarg}{1247} +\glossaryentry{range.slide.iterator@ {\memgloterm{range.slide.iterator}}{\memglodesc{(\ref {range.slide.iterator})}} {\memgloref{}}|memjustarg}{1248} +\glossaryentry{range.slide.sentinel@ {\memgloterm{range.slide.sentinel}}{\memglodesc{(\ref {range.slide.sentinel})}} {\memgloref{}}|memjustarg}{1252} +\glossaryentry{range.chunk.by@ {\memgloterm{range.chunk.by}}{\memglodesc{(\ref {range.chunk.by})}} {\memgloref{}}|memjustarg}{1252} +\glossaryentry{range.chunk.by.overview@ {\memgloterm{range.chunk.by.overview}}{\memglodesc{(\ref {range.chunk.by.overview})}} {\memgloref{}}|memjustarg}{1252} +\glossaryentry{range.chunk.by.view@ {\memgloterm{range.chunk.by.view}}{\memglodesc{(\ref {range.chunk.by.view})}} {\memgloref{}}|memjustarg}{1253} +\glossaryentry{range.chunk.by.iter@ {\memgloterm{range.chunk.by.iter}}{\memglodesc{(\ref {range.chunk.by.iter})}} {\memgloref{}}|memjustarg}{1254} +\glossaryentry{range.stride@ {\memgloterm{range.stride}}{\memglodesc{(\ref {range.stride})}} {\memgloref{}}|memjustarg}{1255} +\glossaryentry{range.stride.overview@ {\memgloterm{range.stride.overview}}{\memglodesc{(\ref {range.stride.overview})}} {\memgloref{}}|memjustarg}{1255} +\glossaryentry{range.stride.view@ {\memgloterm{range.stride.view}}{\memglodesc{(\ref {range.stride.view})}} {\memgloref{}}|memjustarg}{1255} +\glossaryentry{range.stride.iterator@ {\memgloterm{range.stride.iterator}}{\memglodesc{(\ref {range.stride.iterator})}} {\memgloref{}}|memjustarg}{1256} +\glossaryentry{range.cartesian@ {\memgloterm{range.cartesian}}{\memglodesc{(\ref {range.cartesian})}} {\memgloref{}}|memjustarg}{1260} +\glossaryentry{range.cartesian.overview@ {\memgloterm{range.cartesian.overview}}{\memglodesc{(\ref {range.cartesian.overview})}} {\memgloref{}}|memjustarg}{1260} +\glossaryentry{range.cartesian.view@ {\memgloterm{range.cartesian.view}}{\memglodesc{(\ref {range.cartesian.view})}} {\memgloref{}}|memjustarg}{1261} +\glossaryentry{range.cartesian.iterator@ {\memgloterm{range.cartesian.iterator}}{\memglodesc{(\ref {range.cartesian.iterator})}} {\memgloref{}}|memjustarg}{1263} +\glossaryentry{coro.generator@ {\memgloterm{coro.generator}}{\memglodesc{(\ref {coro.generator})}} {\memgloref{}}|memjustarg}{1267} +\glossaryentry{coroutine.generator.overview@ {\memgloterm{coroutine.generator.overview}}{\memglodesc{(\ref {coroutine.generator.overview})}} {\memgloref{}}|memjustarg}{1267} +\glossaryentry{generator.syn@ {\memgloterm{generator.syn}}{\memglodesc{(\ref {generator.syn})}} {\memgloref{}}|memjustarg}{1268} +\glossaryentry{coro.generator.class@ {\memgloterm{coro.generator.class}}{\memglodesc{(\ref {coro.generator.class})}} {\memgloref{}}|memjustarg}{1268} +\glossaryentry{coro.generator.members@ {\memgloterm{coro.generator.members}}{\memglodesc{(\ref {coro.generator.members})}} {\memgloref{}}|memjustarg}{1269} +\glossaryentry{coro.generator.promise@ {\memgloterm{coro.generator.promise}}{\memglodesc{(\ref {coro.generator.promise})}} {\memgloref{}}|memjustarg}{1269} +\glossaryentry{coro.generator.iterator@ {\memgloterm{coro.generator.iterator}}{\memglodesc{(\ref {coro.generator.iterator})}} {\memgloref{}}|memjustarg}{1272} +\glossaryentry{algorithms@ {\memgloterm{algorithms}}{\memglodesc{(\ref {algorithms})}} {\memgloref{}}|memjustarg}{1273} +\glossaryentry{algorithms.general@ {\memgloterm{algorithms.general}}{\memglodesc{(\ref {algorithms.general})}} {\memgloref{}}|memjustarg}{1273} +\glossaryentry{algorithms.requirements@ {\memgloterm{algorithms.requirements}}{\memglodesc{(\ref {algorithms.requirements})}} {\memgloref{}}|memjustarg}{1273} +\glossaryentry{algorithms.parallel@ {\memgloterm{algorithms.parallel}}{\memglodesc{(\ref {algorithms.parallel})}} {\memgloref{}}|memjustarg}{1275} +\glossaryentry{algorithms.parallel.defns@ {\memgloterm{algorithms.parallel.defns}}{\memglodesc{(\ref {algorithms.parallel.defns})}} {\memgloref{}}|memjustarg}{1275} +\glossaryentry{algorithms.parallel.user@ {\memgloterm{algorithms.parallel.user}}{\memglodesc{(\ref {algorithms.parallel.user})}} {\memgloref{}}|memjustarg}{1276} +\glossaryentry{algorithms.parallel.exec@ {\memgloterm{algorithms.parallel.exec}}{\memglodesc{(\ref {algorithms.parallel.exec})}} {\memgloref{}}|memjustarg}{1276} +\glossaryentry{algorithms.parallel.exceptions@ {\memgloterm{algorithms.parallel.exceptions}}{\memglodesc{(\ref {algorithms.parallel.exceptions})}} {\memgloref{}}|memjustarg}{1278} +\glossaryentry{algorithms.parallel.overloads@ {\memgloterm{algorithms.parallel.overloads}}{\memglodesc{(\ref {algorithms.parallel.overloads})}} {\memgloref{}}|memjustarg}{1278} +\glossaryentry{algorithm.syn@ {\memgloterm{algorithm.syn}}{\memglodesc{(\ref {algorithm.syn})}} {\memgloref{}}|memjustarg}{1278} +\glossaryentry{algorithms.results@ {\memgloterm{algorithms.results}}{\memglodesc{(\ref {algorithms.results})}} {\memgloref{}}|memjustarg}{1316} +\glossaryentry{alg.nonmodifying@ {\memgloterm{alg.nonmodifying}}{\memglodesc{(\ref {alg.nonmodifying})}} {\memgloref{}}|memjustarg}{1319} +\glossaryentry{alg.all.of@ {\memgloterm{alg.all.of}}{\memglodesc{(\ref {alg.all.of})}} {\memgloref{}}|memjustarg}{1319} +\glossaryentry{alg.any.of@ {\memgloterm{alg.any.of}}{\memglodesc{(\ref {alg.any.of})}} {\memgloref{}}|memjustarg}{1320} +\glossaryentry{alg.none.of@ {\memgloterm{alg.none.of}}{\memglodesc{(\ref {alg.none.of})}} {\memgloref{}}|memjustarg}{1320} +\glossaryentry{alg.contains@ {\memgloterm{alg.contains}}{\memglodesc{(\ref {alg.contains})}} {\memgloref{}}|memjustarg}{1320} +\glossaryentry{alg.foreach@ {\memgloterm{alg.foreach}}{\memglodesc{(\ref {alg.foreach})}} {\memgloref{}}|memjustarg}{1321} +\glossaryentry{alg.find@ {\memgloterm{alg.find}}{\memglodesc{(\ref {alg.find})}} {\memgloref{}}|memjustarg}{1322} +\glossaryentry{alg.find.last@ {\memgloterm{alg.find.last}}{\memglodesc{(\ref {alg.find.last})}} {\memgloref{}}|memjustarg}{1323} +\glossaryentry{alg.find.end@ {\memgloterm{alg.find.end}}{\memglodesc{(\ref {alg.find.end})}} {\memgloref{}}|memjustarg}{1324} +\glossaryentry{alg.find.first.of@ {\memgloterm{alg.find.first.of}}{\memglodesc{(\ref {alg.find.first.of})}} {\memgloref{}}|memjustarg}{1324} +\glossaryentry{alg.adjacent.find@ {\memgloterm{alg.adjacent.find}}{\memglodesc{(\ref {alg.adjacent.find})}} {\memgloref{}}|memjustarg}{1325} +\glossaryentry{alg.count@ {\memgloterm{alg.count}}{\memglodesc{(\ref {alg.count})}} {\memgloref{}}|memjustarg}{1326} +\glossaryentry{mismatch@ {\memgloterm{mismatch}}{\memglodesc{(\ref {mismatch})}} {\memgloref{}}|memjustarg}{1327} +\glossaryentry{alg.equal@ {\memgloterm{alg.equal}}{\memglodesc{(\ref {alg.equal})}} {\memgloref{}}|memjustarg}{1328} +\glossaryentry{alg.is.permutation@ {\memgloterm{alg.is.permutation}}{\memglodesc{(\ref {alg.is.permutation})}} {\memgloref{}}|memjustarg}{1329} +\glossaryentry{alg.search@ {\memgloterm{alg.search}}{\memglodesc{(\ref {alg.search})}} {\memgloref{}}|memjustarg}{1330} +\glossaryentry{alg.starts.with@ {\memgloterm{alg.starts.with}}{\memglodesc{(\ref {alg.starts.with})}} {\memgloref{}}|memjustarg}{1332} +\glossaryentry{alg.ends.with@ {\memgloterm{alg.ends.with}}{\memglodesc{(\ref {alg.ends.with})}} {\memgloref{}}|memjustarg}{1332} +\glossaryentry{alg.fold@ {\memgloterm{alg.fold}}{\memglodesc{(\ref {alg.fold})}} {\memgloref{}}|memjustarg}{1333} +\glossaryentry{alg.modifying.operations@ {\memgloterm{alg.modifying.operations}}{\memglodesc{(\ref {alg.modifying.operations})}} {\memgloref{}}|memjustarg}{1334} +\glossaryentry{alg.copy@ {\memgloterm{alg.copy}}{\memglodesc{(\ref {alg.copy})}} {\memgloref{}}|memjustarg}{1334} +\glossaryentry{alg.move@ {\memgloterm{alg.move}}{\memglodesc{(\ref {alg.move})}} {\memgloref{}}|memjustarg}{1336} +\glossaryentry{alg.swap@ {\memgloterm{alg.swap}}{\memglodesc{(\ref {alg.swap})}} {\memgloref{}}|memjustarg}{1338} +\glossaryentry{alg.transform@ {\memgloterm{alg.transform}}{\memglodesc{(\ref {alg.transform})}} {\memgloref{}}|memjustarg}{1338} +\glossaryentry{alg.replace@ {\memgloterm{alg.replace}}{\memglodesc{(\ref {alg.replace})}} {\memgloref{}}|memjustarg}{1340} +\glossaryentry{alg.fill@ {\memgloterm{alg.fill}}{\memglodesc{(\ref {alg.fill})}} {\memgloref{}}|memjustarg}{1342} +\glossaryentry{alg.generate@ {\memgloterm{alg.generate}}{\memglodesc{(\ref {alg.generate})}} {\memgloref{}}|memjustarg}{1342} +\glossaryentry{alg.remove@ {\memgloterm{alg.remove}}{\memglodesc{(\ref {alg.remove})}} {\memgloref{}}|memjustarg}{1343} +\glossaryentry{alg.unique@ {\memgloterm{alg.unique}}{\memglodesc{(\ref {alg.unique})}} {\memgloref{}}|memjustarg}{1345} +\glossaryentry{alg.reverse@ {\memgloterm{alg.reverse}}{\memglodesc{(\ref {alg.reverse})}} {\memgloref{}}|memjustarg}{1347} +\glossaryentry{alg.rotate@ {\memgloterm{alg.rotate}}{\memglodesc{(\ref {alg.rotate})}} {\memgloref{}}|memjustarg}{1347} +\glossaryentry{alg.random.sample@ {\memgloterm{alg.random.sample}}{\memglodesc{(\ref {alg.random.sample})}} {\memgloref{}}|memjustarg}{1349} +\glossaryentry{alg.random.shuffle@ {\memgloterm{alg.random.shuffle}}{\memglodesc{(\ref {alg.random.shuffle})}} {\memgloref{}}|memjustarg}{1349} +\glossaryentry{alg.shift@ {\memgloterm{alg.shift}}{\memglodesc{(\ref {alg.shift})}} {\memgloref{}}|memjustarg}{1350} +\glossaryentry{alg.sorting@ {\memgloterm{alg.sorting}}{\memglodesc{(\ref {alg.sorting})}} {\memgloref{}}|memjustarg}{1351} +\glossaryentry{alg.sorting.general@ {\memgloterm{alg.sorting.general}}{\memglodesc{(\ref {alg.sorting.general})}} {\memgloref{}}|memjustarg}{1351} +\glossaryentry{alg.sort@ {\memgloterm{alg.sort}}{\memglodesc{(\ref {alg.sort})}} {\memgloref{}}|memjustarg}{1351} +\glossaryentry{sort@ {\memgloterm{sort}}{\memglodesc{(\ref {sort})}} {\memgloref{}}|memjustarg}{1351} +\glossaryentry{stable.sort@ {\memgloterm{stable.sort}}{\memglodesc{(\ref {stable.sort})}} {\memgloref{}}|memjustarg}{1352} +\glossaryentry{partial.sort@ {\memgloterm{partial.sort}}{\memglodesc{(\ref {partial.sort})}} {\memgloref{}}|memjustarg}{1353} +\glossaryentry{partial.sort.copy@ {\memgloterm{partial.sort.copy}}{\memglodesc{(\ref {partial.sort.copy})}} {\memgloref{}}|memjustarg}{1353} +\glossaryentry{is.sorted@ {\memgloterm{is.sorted}}{\memglodesc{(\ref {is.sorted})}} {\memgloref{}}|memjustarg}{1355} +\glossaryentry{alg.nth.element@ {\memgloterm{alg.nth.element}}{\memglodesc{(\ref {alg.nth.element})}} {\memgloref{}}|memjustarg}{1356} +\glossaryentry{alg.binary.search@ {\memgloterm{alg.binary.search}}{\memglodesc{(\ref {alg.binary.search})}} {\memgloref{}}|memjustarg}{1356} +\glossaryentry{alg.binary.search.general@ {\memgloterm{alg.binary.search.general}}{\memglodesc{(\ref {alg.binary.search.general})}} {\memgloref{}}|memjustarg}{1356} +\glossaryentry{lower.bound@ {\memgloterm{lower.bound}}{\memglodesc{(\ref {lower.bound})}} {\memgloref{}}|memjustarg}{1356} +\glossaryentry{upper.bound@ {\memgloterm{upper.bound}}{\memglodesc{(\ref {upper.bound})}} {\memgloref{}}|memjustarg}{1357} +\glossaryentry{equal.range@ {\memgloterm{equal.range}}{\memglodesc{(\ref {equal.range})}} {\memgloref{}}|memjustarg}{1357} +\glossaryentry{binary.search@ {\memgloterm{binary.search}}{\memglodesc{(\ref {binary.search})}} {\memgloref{}}|memjustarg}{1358} +\glossaryentry{alg.partitions@ {\memgloterm{alg.partitions}}{\memglodesc{(\ref {alg.partitions})}} {\memgloref{}}|memjustarg}{1359} +\glossaryentry{alg.merge@ {\memgloterm{alg.merge}}{\memglodesc{(\ref {alg.merge})}} {\memgloref{}}|memjustarg}{1361} +\glossaryentry{alg.set.operations@ {\memgloterm{alg.set.operations}}{\memglodesc{(\ref {alg.set.operations})}} {\memgloref{}}|memjustarg}{1363} +\glossaryentry{alg.set.operations.general@ {\memgloterm{alg.set.operations.general}}{\memglodesc{(\ref {alg.set.operations.general})}} {\memgloref{}}|memjustarg}{1363} +\glossaryentry{includes@ {\memgloterm{includes}}{\memglodesc{(\ref {includes})}} {\memgloref{}}|memjustarg}{1363} +\glossaryentry{set.union@ {\memgloterm{set.union}}{\memglodesc{(\ref {set.union})}} {\memgloref{}}|memjustarg}{1364} +\glossaryentry{set.intersection@ {\memgloterm{set.intersection}}{\memglodesc{(\ref {set.intersection})}} {\memgloref{}}|memjustarg}{1365} +\glossaryentry{set.difference@ {\memgloterm{set.difference}}{\memglodesc{(\ref {set.difference})}} {\memgloref{}}|memjustarg}{1366} +\glossaryentry{set.symmetric.difference@ {\memgloterm{set.symmetric.difference}}{\memglodesc{(\ref {set.symmetric.difference})}} {\memgloref{}}|memjustarg}{1367} +\glossaryentry{alg.heap.operations@ {\memgloterm{alg.heap.operations}}{\memglodesc{(\ref {alg.heap.operations})}} {\memgloref{}}|memjustarg}{1368} +\glossaryentry{alg.heap.operations.general@ {\memgloterm{alg.heap.operations.general}}{\memglodesc{(\ref {alg.heap.operations.general})}} {\memgloref{}}|memjustarg}{1368} +\glossaryentry{push.heap@ {\memgloterm{push.heap}}{\memglodesc{(\ref {push.heap})}} {\memgloref{}}|memjustarg}{1368} +\glossaryentry{pop.heap@ {\memgloterm{pop.heap}}{\memglodesc{(\ref {pop.heap})}} {\memgloref{}}|memjustarg}{1368} +\glossaryentry{make.heap@ {\memgloterm{make.heap}}{\memglodesc{(\ref {make.heap})}} {\memgloref{}}|memjustarg}{1369} +\glossaryentry{sort.heap@ {\memgloterm{sort.heap}}{\memglodesc{(\ref {sort.heap})}} {\memgloref{}}|memjustarg}{1369} +\glossaryentry{is.heap@ {\memgloterm{is.heap}}{\memglodesc{(\ref {is.heap})}} {\memgloref{}}|memjustarg}{1370} +\glossaryentry{alg.min.max@ {\memgloterm{alg.min.max}}{\memglodesc{(\ref {alg.min.max})}} {\memgloref{}}|memjustarg}{1371} +\glossaryentry{alg.clamp@ {\memgloterm{alg.clamp}}{\memglodesc{(\ref {alg.clamp})}} {\memgloref{}}|memjustarg}{1374} +\glossaryentry{alg.lex.comparison@ {\memgloterm{alg.lex.comparison}}{\memglodesc{(\ref {alg.lex.comparison})}} {\memgloref{}}|memjustarg}{1375} +\glossaryentry{alg.three.way@ {\memgloterm{alg.three.way}}{\memglodesc{(\ref {alg.three.way})}} {\memgloref{}}|memjustarg}{1376} +\glossaryentry{alg.permutation.generators@ {\memgloterm{alg.permutation.generators}}{\memglodesc{(\ref {alg.permutation.generators})}} {\memgloref{}}|memjustarg}{1376} +\glossaryentry{numeric.ops.overview@ {\memgloterm{numeric.ops.overview}}{\memglodesc{(\ref {numeric.ops.overview})}} {\memgloref{}}|memjustarg}{1377} +\glossaryentry{numeric.ops@ {\memgloterm{numeric.ops}}{\memglodesc{(\ref {numeric.ops})}} {\memgloref{}}|memjustarg}{1381} +\glossaryentry{numeric.ops.general@ {\memgloterm{numeric.ops.general}}{\memglodesc{(\ref {numeric.ops.general})}} {\memgloref{}}|memjustarg}{1381} +\glossaryentry{numerics.defns@ {\memgloterm{numerics.defns}}{\memglodesc{(\ref {numerics.defns})}} {\memgloref{}}|memjustarg}{1381} +\glossaryentry{accumulate@ {\memgloterm{accumulate}}{\memglodesc{(\ref {accumulate})}} {\memgloref{}}|memjustarg}{1381} +\glossaryentry{reduce@ {\memgloterm{reduce}}{\memglodesc{(\ref {reduce})}} {\memgloref{}}|memjustarg}{1381} +\glossaryentry{inner.product@ {\memgloterm{inner.product}}{\memglodesc{(\ref {inner.product})}} {\memgloref{}}|memjustarg}{1382} +\glossaryentry{transform.reduce@ {\memgloterm{transform.reduce}}{\memglodesc{(\ref {transform.reduce})}} {\memgloref{}}|memjustarg}{1382} +\glossaryentry{partial.sum@ {\memgloterm{partial.sum}}{\memglodesc{(\ref {partial.sum})}} {\memgloref{}}|memjustarg}{1384} +\glossaryentry{exclusive.scan@ {\memgloterm{exclusive.scan}}{\memglodesc{(\ref {exclusive.scan})}} {\memgloref{}}|memjustarg}{1384} +\glossaryentry{inclusive.scan@ {\memgloterm{inclusive.scan}}{\memglodesc{(\ref {inclusive.scan})}} {\memgloref{}}|memjustarg}{1385} +\glossaryentry{transform.exclusive.scan@ {\memgloterm{transform.exclusive.scan}}{\memglodesc{(\ref {transform.exclusive.scan})}} {\memgloref{}}|memjustarg}{1386} +\glossaryentry{transform.inclusive.scan@ {\memgloterm{transform.inclusive.scan}}{\memglodesc{(\ref {transform.inclusive.scan})}} {\memgloref{}}|memjustarg}{1387} +\glossaryentry{adjacent.difference@ {\memgloterm{adjacent.difference}}{\memglodesc{(\ref {adjacent.difference})}} {\memgloref{}}|memjustarg}{1388} +\glossaryentry{numeric.iota@ {\memgloterm{numeric.iota}}{\memglodesc{(\ref {numeric.iota})}} {\memgloref{}}|memjustarg}{1389} +\glossaryentry{numeric.ops.gcd@ {\memgloterm{numeric.ops.gcd}}{\memglodesc{(\ref {numeric.ops.gcd})}} {\memgloref{}}|memjustarg}{1389} +\glossaryentry{numeric.ops.lcm@ {\memgloterm{numeric.ops.lcm}}{\memglodesc{(\ref {numeric.ops.lcm})}} {\memgloref{}}|memjustarg}{1390} +\glossaryentry{numeric.ops.midpoint@ {\memgloterm{numeric.ops.midpoint}}{\memglodesc{(\ref {numeric.ops.midpoint})}} {\memgloref{}}|memjustarg}{1390} +\glossaryentry{specialized.algorithms@ {\memgloterm{specialized.algorithms}}{\memglodesc{(\ref {specialized.algorithms})}} {\memgloref{}}|memjustarg}{1390} +\glossaryentry{specialized.algorithms.general@ {\memgloterm{specialized.algorithms.general}}{\memglodesc{(\ref {specialized.algorithms.general})}} {\memgloref{}}|memjustarg}{1390} +\glossaryentry{special.mem.concepts@ {\memgloterm{special.mem.concepts}}{\memglodesc{(\ref {special.mem.concepts})}} {\memgloref{}}|memjustarg}{1390} +\glossaryentry{uninitialized.construct.default@ {\memgloterm{uninitialized.construct.default}}{\memglodesc{(\ref {uninitialized.construct.default})}} {\memgloref{}}|memjustarg}{1391} +\glossaryentry{uninitialized.construct.value@ {\memgloterm{uninitialized.construct.value}}{\memglodesc{(\ref {uninitialized.construct.value})}} {\memgloref{}}|memjustarg}{1392} +\glossaryentry{uninitialized.copy@ {\memgloterm{uninitialized.copy}}{\memglodesc{(\ref {uninitialized.copy})}} {\memgloref{}}|memjustarg}{1392} +\glossaryentry{uninitialized.move@ {\memgloterm{uninitialized.move}}{\memglodesc{(\ref {uninitialized.move})}} {\memgloref{}}|memjustarg}{1393} +\glossaryentry{uninitialized.fill@ {\memgloterm{uninitialized.fill}}{\memglodesc{(\ref {uninitialized.fill})}} {\memgloref{}}|memjustarg}{1394} +\glossaryentry{specialized.construct@ {\memgloterm{specialized.construct}}{\memglodesc{(\ref {specialized.construct})}} {\memgloref{}}|memjustarg}{1395} +\glossaryentry{specialized.destroy@ {\memgloterm{specialized.destroy}}{\memglodesc{(\ref {specialized.destroy})}} {\memgloref{}}|memjustarg}{1395} +\glossaryentry{alg.c.library@ {\memgloterm{alg.c.library}}{\memglodesc{(\ref {alg.c.library})}} {\memgloref{}}|memjustarg}{1396} +\glossaryentry{numerics@ {\memgloterm{numerics}}{\memglodesc{(\ref {numerics})}} {\memgloref{}}|memjustarg}{1397} +\glossaryentry{numerics.general@ {\memgloterm{numerics.general}}{\memglodesc{(\ref {numerics.general})}} {\memgloref{}}|memjustarg}{1397} +\glossaryentry{numeric.requirements@ {\memgloterm{numeric.requirements}}{\memglodesc{(\ref {numeric.requirements})}} {\memgloref{}}|memjustarg}{1397} +\glossaryentry{cfenv@ {\memgloterm{cfenv}}{\memglodesc{(\ref {cfenv})}} {\memgloref{}}|memjustarg}{1397} +\glossaryentry{cfenv.syn@ {\memgloterm{cfenv.syn}}{\memglodesc{(\ref {cfenv.syn})}} {\memgloref{}}|memjustarg}{1397} +\glossaryentry{cfenv.thread@ {\memgloterm{cfenv.thread}}{\memglodesc{(\ref {cfenv.thread})}} {\memgloref{}}|memjustarg}{1398} +\glossaryentry{complex.numbers@ {\memgloterm{complex.numbers}}{\memglodesc{(\ref {complex.numbers})}} {\memgloref{}}|memjustarg}{1398} +\glossaryentry{complex.numbers.general@ {\memgloterm{complex.numbers.general}}{\memglodesc{(\ref {complex.numbers.general})}} {\memgloref{}}|memjustarg}{1398} +\glossaryentry{complex.syn@ {\memgloterm{complex.syn}}{\memglodesc{(\ref {complex.syn})}} {\memgloref{}}|memjustarg}{1398} +\glossaryentry{complex@ {\memgloterm{complex}}{\memglodesc{(\ref {complex})}} {\memgloref{}}|memjustarg}{1400} +\glossaryentry{complex.members@ {\memgloterm{complex.members}}{\memglodesc{(\ref {complex.members})}} {\memgloref{}}|memjustarg}{1400} +\glossaryentry{complex.member.ops@ {\memgloterm{complex.member.ops}}{\memglodesc{(\ref {complex.member.ops})}} {\memgloref{}}|memjustarg}{1401} +\glossaryentry{complex.ops@ {\memgloterm{complex.ops}}{\memglodesc{(\ref {complex.ops})}} {\memgloref{}}|memjustarg}{1401} +\glossaryentry{complex.value.ops@ {\memgloterm{complex.value.ops}}{\memglodesc{(\ref {complex.value.ops})}} {\memgloref{}}|memjustarg}{1402} +\glossaryentry{complex.transcendentals@ {\memgloterm{complex.transcendentals}}{\memglodesc{(\ref {complex.transcendentals})}} {\memgloref{}}|memjustarg}{1403} +\glossaryentry{cmplx.over@ {\memgloterm{cmplx.over}}{\memglodesc{(\ref {cmplx.over})}} {\memgloref{}}|memjustarg}{1404} +\glossaryentry{complex.literals@ {\memgloterm{complex.literals}}{\memglodesc{(\ref {complex.literals})}} {\memgloref{}}|memjustarg}{1404} +\glossaryentry{rand@ {\memgloterm{rand}}{\memglodesc{(\ref {rand})}} {\memgloref{}}|memjustarg}{1405} +\glossaryentry{rand.general@ {\memgloterm{rand.general}}{\memglodesc{(\ref {rand.general})}} {\memgloref{}}|memjustarg}{1405} +\glossaryentry{rand.synopsis@ {\memgloterm{rand.synopsis}}{\memglodesc{(\ref {rand.synopsis})}} {\memgloref{}}|memjustarg}{1405} +\glossaryentry{rand.req@ {\memgloterm{rand.req}}{\memglodesc{(\ref {rand.req})}} {\memgloref{}}|memjustarg}{1407} +\glossaryentry{rand.req.genl@ {\memgloterm{rand.req.genl}}{\memglodesc{(\ref {rand.req.genl})}} {\memgloref{}}|memjustarg}{1407} +\glossaryentry{rand.req.seedseq@ {\memgloterm{rand.req.seedseq}}{\memglodesc{(\ref {rand.req.seedseq})}} {\memgloref{}}|memjustarg}{1408} +\glossaryentry{rand.req.urng@ {\memgloterm{rand.req.urng}}{\memglodesc{(\ref {rand.req.urng})}} {\memgloref{}}|memjustarg}{1409} +\glossaryentry{rand.req.eng@ {\memgloterm{rand.req.eng}}{\memglodesc{(\ref {rand.req.eng})}} {\memgloref{}}|memjustarg}{1409} +\glossaryentry{rand.req.adapt@ {\memgloterm{rand.req.adapt}}{\memglodesc{(\ref {rand.req.adapt})}} {\memgloref{}}|memjustarg}{1411} +\glossaryentry{rand.req.dist@ {\memgloterm{rand.req.dist}}{\memglodesc{(\ref {rand.req.dist})}} {\memgloref{}}|memjustarg}{1412} +\glossaryentry{rand.eng@ {\memgloterm{rand.eng}}{\memglodesc{(\ref {rand.eng})}} {\memgloref{}}|memjustarg}{1414} +\glossaryentry{rand.eng.general@ {\memgloterm{rand.eng.general}}{\memglodesc{(\ref {rand.eng.general})}} {\memgloref{}}|memjustarg}{1414} +\glossaryentry{rand.eng.lcong@ {\memgloterm{rand.eng.lcong}}{\memglodesc{(\ref {rand.eng.lcong})}} {\memgloref{}}|memjustarg}{1415} +\glossaryentry{rand.eng.mers@ {\memgloterm{rand.eng.mers}}{\memglodesc{(\ref {rand.eng.mers})}} {\memgloref{}}|memjustarg}{1416} +\glossaryentry{rand.eng.sub@ {\memgloterm{rand.eng.sub}}{\memglodesc{(\ref {rand.eng.sub})}} {\memgloref{}}|memjustarg}{1417} +\glossaryentry{rand.adapt@ {\memgloterm{rand.adapt}}{\memglodesc{(\ref {rand.adapt})}} {\memgloref{}}|memjustarg}{1419} +\glossaryentry{rand.adapt.general@ {\memgloterm{rand.adapt.general}}{\memglodesc{(\ref {rand.adapt.general})}} {\memgloref{}}|memjustarg}{1419} +\glossaryentry{rand.adapt.disc@ {\memgloterm{rand.adapt.disc}}{\memglodesc{(\ref {rand.adapt.disc})}} {\memgloref{}}|memjustarg}{1419} +\glossaryentry{rand.adapt.ibits@ {\memgloterm{rand.adapt.ibits}}{\memglodesc{(\ref {rand.adapt.ibits})}} {\memgloref{}}|memjustarg}{1420} +\glossaryentry{rand.adapt.shuf@ {\memgloterm{rand.adapt.shuf}}{\memglodesc{(\ref {rand.adapt.shuf})}} {\memgloref{}}|memjustarg}{1421} +\glossaryentry{rand.predef@ {\memgloterm{rand.predef}}{\memglodesc{(\ref {rand.predef})}} {\memgloref{}}|memjustarg}{1422} +\glossaryentry{rand.device@ {\memgloterm{rand.device}}{\memglodesc{(\ref {rand.device})}} {\memgloref{}}|memjustarg}{1423} +\glossaryentry{rand.util@ {\memgloterm{rand.util}}{\memglodesc{(\ref {rand.util})}} {\memgloref{}}|memjustarg}{1424} +\glossaryentry{rand.util.seedseq@ {\memgloterm{rand.util.seedseq}}{\memglodesc{(\ref {rand.util.seedseq})}} {\memgloref{}}|memjustarg}{1424} +\glossaryentry{rand.util.canonical@ {\memgloterm{rand.util.canonical}}{\memglodesc{(\ref {rand.util.canonical})}} {\memgloref{}}|memjustarg}{1426} +\glossaryentry{rand.dist@ {\memgloterm{rand.dist}}{\memglodesc{(\ref {rand.dist})}} {\memgloref{}}|memjustarg}{1426} +\glossaryentry{rand.dist.general@ {\memgloterm{rand.dist.general}}{\memglodesc{(\ref {rand.dist.general})}} {\memgloref{}}|memjustarg}{1426} +\glossaryentry{rand.dist.uni@ {\memgloterm{rand.dist.uni}}{\memglodesc{(\ref {rand.dist.uni})}} {\memgloref{}}|memjustarg}{1426} +\glossaryentry{rand.dist.uni.int@ {\memgloterm{rand.dist.uni.int}}{\memglodesc{(\ref {rand.dist.uni.int})}} {\memgloref{}}|memjustarg}{1426} +\glossaryentry{rand.dist.uni.real@ {\memgloterm{rand.dist.uni.real}}{\memglodesc{(\ref {rand.dist.uni.real})}} {\memgloref{}}|memjustarg}{1427} +\glossaryentry{rand.dist.bern@ {\memgloterm{rand.dist.bern}}{\memglodesc{(\ref {rand.dist.bern})}} {\memgloref{}}|memjustarg}{1428} +\glossaryentry{rand.dist.bern.bernoulli@ {\memgloterm{rand.dist.bern.bernoulli}}{\memglodesc{(\ref {rand.dist.bern.bernoulli})}} {\memgloref{}}|memjustarg}{1428} +\glossaryentry{rand.dist.bern.bin@ {\memgloterm{rand.dist.bern.bin}}{\memglodesc{(\ref {rand.dist.bern.bin})}} {\memgloref{}}|memjustarg}{1429} +\glossaryentry{rand.dist.bern.geo@ {\memgloterm{rand.dist.bern.geo}}{\memglodesc{(\ref {rand.dist.bern.geo})}} {\memgloref{}}|memjustarg}{1430} +\glossaryentry{rand.dist.bern.negbin@ {\memgloterm{rand.dist.bern.negbin}}{\memglodesc{(\ref {rand.dist.bern.negbin})}} {\memgloref{}}|memjustarg}{1431} +\glossaryentry{rand.dist.pois@ {\memgloterm{rand.dist.pois}}{\memglodesc{(\ref {rand.dist.pois})}} {\memgloref{}}|memjustarg}{1432} +\glossaryentry{rand.dist.pois.poisson@ {\memgloterm{rand.dist.pois.poisson}}{\memglodesc{(\ref {rand.dist.pois.poisson})}} {\memgloref{}}|memjustarg}{1432} +\glossaryentry{rand.dist.pois.exp@ {\memgloterm{rand.dist.pois.exp}}{\memglodesc{(\ref {rand.dist.pois.exp})}} {\memgloref{}}|memjustarg}{1433} +\glossaryentry{rand.dist.pois.gamma@ {\memgloterm{rand.dist.pois.gamma}}{\memglodesc{(\ref {rand.dist.pois.gamma})}} {\memgloref{}}|memjustarg}{1434} +\glossaryentry{rand.dist.pois.weibull@ {\memgloterm{rand.dist.pois.weibull}}{\memglodesc{(\ref {rand.dist.pois.weibull})}} {\memgloref{}}|memjustarg}{1435} +\glossaryentry{rand.dist.pois.extreme@ {\memgloterm{rand.dist.pois.extreme}}{\memglodesc{(\ref {rand.dist.pois.extreme})}} {\memgloref{}}|memjustarg}{1436} +\glossaryentry{rand.dist.norm@ {\memgloterm{rand.dist.norm}}{\memglodesc{(\ref {rand.dist.norm})}} {\memgloref{}}|memjustarg}{1437} +\glossaryentry{rand.dist.norm.normal@ {\memgloterm{rand.dist.norm.normal}}{\memglodesc{(\ref {rand.dist.norm.normal})}} {\memgloref{}}|memjustarg}{1437} +\glossaryentry{rand.dist.norm.lognormal@ {\memgloterm{rand.dist.norm.lognormal}}{\memglodesc{(\ref {rand.dist.norm.lognormal})}} {\memgloref{}}|memjustarg}{1438} +\glossaryentry{rand.dist.norm.chisq@ {\memgloterm{rand.dist.norm.chisq}}{\memglodesc{(\ref {rand.dist.norm.chisq})}} {\memgloref{}}|memjustarg}{1439} +\glossaryentry{rand.dist.norm.cauchy@ {\memgloterm{rand.dist.norm.cauchy}}{\memglodesc{(\ref {rand.dist.norm.cauchy})}} {\memgloref{}}|memjustarg}{1439} +\glossaryentry{rand.dist.norm.f@ {\memgloterm{rand.dist.norm.f}}{\memglodesc{(\ref {rand.dist.norm.f})}} {\memgloref{}}|memjustarg}{1440} +\glossaryentry{rand.dist.norm.t@ {\memgloterm{rand.dist.norm.t}}{\memglodesc{(\ref {rand.dist.norm.t})}} {\memgloref{}}|memjustarg}{1441} +\glossaryentry{rand.dist.samp@ {\memgloterm{rand.dist.samp}}{\memglodesc{(\ref {rand.dist.samp})}} {\memgloref{}}|memjustarg}{1442} +\glossaryentry{rand.dist.samp.discrete@ {\memgloterm{rand.dist.samp.discrete}}{\memglodesc{(\ref {rand.dist.samp.discrete})}} {\memgloref{}}|memjustarg}{1442} +\glossaryentry{rand.dist.samp.pconst@ {\memgloterm{rand.dist.samp.pconst}}{\memglodesc{(\ref {rand.dist.samp.pconst})}} {\memgloref{}}|memjustarg}{1444} +\glossaryentry{rand.dist.samp.plinear@ {\memgloterm{rand.dist.samp.plinear}}{\memglodesc{(\ref {rand.dist.samp.plinear})}} {\memgloref{}}|memjustarg}{1445} +\glossaryentry{c.math.rand@ {\memgloterm{c.math.rand}}{\memglodesc{(\ref {c.math.rand})}} {\memgloref{}}|memjustarg}{1447} +\glossaryentry{numarray@ {\memgloterm{numarray}}{\memglodesc{(\ref {numarray})}} {\memgloref{}}|memjustarg}{1447} +\glossaryentry{valarray.syn@ {\memgloterm{valarray.syn}}{\memglodesc{(\ref {valarray.syn})}} {\memgloref{}}|memjustarg}{1447} +\glossaryentry{template.valarray@ {\memgloterm{template.valarray}}{\memglodesc{(\ref {template.valarray})}} {\memgloref{}}|memjustarg}{1450} +\glossaryentry{template.valarray.overview@ {\memgloterm{template.valarray.overview}}{\memglodesc{(\ref {template.valarray.overview})}} {\memgloref{}}|memjustarg}{1450} +\glossaryentry{valarray.cons@ {\memgloterm{valarray.cons}}{\memglodesc{(\ref {valarray.cons})}} {\memgloref{}}|memjustarg}{1452} +\glossaryentry{valarray.assign@ {\memgloterm{valarray.assign}}{\memglodesc{(\ref {valarray.assign})}} {\memgloref{}}|memjustarg}{1453} +\glossaryentry{valarray.access@ {\memgloterm{valarray.access}}{\memglodesc{(\ref {valarray.access})}} {\memgloref{}}|memjustarg}{1453} +\glossaryentry{valarray.sub@ {\memgloterm{valarray.sub}}{\memglodesc{(\ref {valarray.sub})}} {\memgloref{}}|memjustarg}{1453} +\glossaryentry{valarray.unary@ {\memgloterm{valarray.unary}}{\memglodesc{(\ref {valarray.unary})}} {\memgloref{}}|memjustarg}{1455} +\glossaryentry{valarray.cassign@ {\memgloterm{valarray.cassign}}{\memglodesc{(\ref {valarray.cassign})}} {\memgloref{}}|memjustarg}{1455} +\glossaryentry{valarray.members@ {\memgloterm{valarray.members}}{\memglodesc{(\ref {valarray.members})}} {\memgloref{}}|memjustarg}{1456} +\glossaryentry{valarray.nonmembers@ {\memgloterm{valarray.nonmembers}}{\memglodesc{(\ref {valarray.nonmembers})}} {\memgloref{}}|memjustarg}{1457} +\glossaryentry{valarray.binary@ {\memgloterm{valarray.binary}}{\memglodesc{(\ref {valarray.binary})}} {\memgloref{}}|memjustarg}{1457} +\glossaryentry{valarray.comparison@ {\memgloterm{valarray.comparison}}{\memglodesc{(\ref {valarray.comparison})}} {\memgloref{}}|memjustarg}{1458} +\glossaryentry{valarray.transcend@ {\memgloterm{valarray.transcend}}{\memglodesc{(\ref {valarray.transcend})}} {\memgloref{}}|memjustarg}{1459} +\glossaryentry{valarray.special@ {\memgloterm{valarray.special}}{\memglodesc{(\ref {valarray.special})}} {\memgloref{}}|memjustarg}{1459} +\glossaryentry{class.slice@ {\memgloterm{class.slice}}{\memglodesc{(\ref {class.slice})}} {\memgloref{}}|memjustarg}{1459} +\glossaryentry{class.slice.overview@ {\memgloterm{class.slice.overview}}{\memglodesc{(\ref {class.slice.overview})}} {\memgloref{}}|memjustarg}{1459} +\glossaryentry{cons.slice@ {\memgloterm{cons.slice}}{\memglodesc{(\ref {cons.slice})}} {\memgloref{}}|memjustarg}{1460} +\glossaryentry{slice.access@ {\memgloterm{slice.access}}{\memglodesc{(\ref {slice.access})}} {\memgloref{}}|memjustarg}{1460} +\glossaryentry{slice.ops@ {\memgloterm{slice.ops}}{\memglodesc{(\ref {slice.ops})}} {\memgloref{}}|memjustarg}{1460} +\glossaryentry{template.slice.array@ {\memgloterm{template.slice.array}}{\memglodesc{(\ref {template.slice.array})}} {\memgloref{}}|memjustarg}{1460} +\glossaryentry{template.slice.array.overview@ {\memgloterm{template.slice.array.overview}}{\memglodesc{(\ref {template.slice.array.overview})}} {\memgloref{}}|memjustarg}{1460} +\glossaryentry{slice.arr.assign@ {\memgloterm{slice.arr.assign}}{\memglodesc{(\ref {slice.arr.assign})}} {\memgloref{}}|memjustarg}{1461} +\glossaryentry{slice.arr.comp.assign@ {\memgloterm{slice.arr.comp.assign}}{\memglodesc{(\ref {slice.arr.comp.assign})}} {\memgloref{}}|memjustarg}{1461} +\glossaryentry{slice.arr.fill@ {\memgloterm{slice.arr.fill}}{\memglodesc{(\ref {slice.arr.fill})}} {\memgloref{}}|memjustarg}{1461} +\glossaryentry{class.gslice@ {\memgloterm{class.gslice}}{\memglodesc{(\ref {class.gslice})}} {\memgloref{}}|memjustarg}{1461} +\glossaryentry{class.gslice.overview@ {\memgloterm{class.gslice.overview}}{\memglodesc{(\ref {class.gslice.overview})}} {\memgloref{}}|memjustarg}{1461} +\glossaryentry{gslice.cons@ {\memgloterm{gslice.cons}}{\memglodesc{(\ref {gslice.cons})}} {\memgloref{}}|memjustarg}{1462} +\glossaryentry{gslice.access@ {\memgloterm{gslice.access}}{\memglodesc{(\ref {gslice.access})}} {\memgloref{}}|memjustarg}{1462} +\glossaryentry{template.gslice.array@ {\memgloterm{template.gslice.array}}{\memglodesc{(\ref {template.gslice.array})}} {\memgloref{}}|memjustarg}{1463} +\glossaryentry{template.gslice.array.overview@ {\memgloterm{template.gslice.array.overview}}{\memglodesc{(\ref {template.gslice.array.overview})}} {\memgloref{}}|memjustarg}{1463} +\glossaryentry{gslice.array.assign@ {\memgloterm{gslice.array.assign}}{\memglodesc{(\ref {gslice.array.assign})}} {\memgloref{}}|memjustarg}{1463} +\glossaryentry{gslice.array.comp.assign@ {\memgloterm{gslice.array.comp.assign}}{\memglodesc{(\ref {gslice.array.comp.assign})}} {\memgloref{}}|memjustarg}{1463} +\glossaryentry{gslice.array.fill@ {\memgloterm{gslice.array.fill}}{\memglodesc{(\ref {gslice.array.fill})}} {\memgloref{}}|memjustarg}{1463} +\glossaryentry{template.mask.array@ {\memgloterm{template.mask.array}}{\memglodesc{(\ref {template.mask.array})}} {\memgloref{}}|memjustarg}{1464} +\glossaryentry{template.mask.array.overview@ {\memgloterm{template.mask.array.overview}}{\memglodesc{(\ref {template.mask.array.overview})}} {\memgloref{}}|memjustarg}{1464} +\glossaryentry{mask.array.assign@ {\memgloterm{mask.array.assign}}{\memglodesc{(\ref {mask.array.assign})}} {\memgloref{}}|memjustarg}{1464} +\glossaryentry{mask.array.comp.assign@ {\memgloterm{mask.array.comp.assign}}{\memglodesc{(\ref {mask.array.comp.assign})}} {\memgloref{}}|memjustarg}{1464} +\glossaryentry{mask.array.fill@ {\memgloterm{mask.array.fill}}{\memglodesc{(\ref {mask.array.fill})}} {\memgloref{}}|memjustarg}{1464} +\glossaryentry{template.indirect.array@ {\memgloterm{template.indirect.array}}{\memglodesc{(\ref {template.indirect.array})}} {\memgloref{}}|memjustarg}{1465} +\glossaryentry{template.indirect.array.overview@ {\memgloterm{template.indirect.array.overview}}{\memglodesc{(\ref {template.indirect.array.overview})}} {\memgloref{}}|memjustarg}{1465} +\glossaryentry{indirect.array.assign@ {\memgloterm{indirect.array.assign}}{\memglodesc{(\ref {indirect.array.assign})}} {\memgloref{}}|memjustarg}{1465} +\glossaryentry{indirect.array.comp.assign@ {\memgloterm{indirect.array.comp.assign}}{\memglodesc{(\ref {indirect.array.comp.assign})}} {\memgloref{}}|memjustarg}{1465} +\glossaryentry{indirect.array.fill@ {\memgloterm{indirect.array.fill}}{\memglodesc{(\ref {indirect.array.fill})}} {\memgloref{}}|memjustarg}{1466} +\glossaryentry{valarray.range@ {\memgloterm{valarray.range}}{\memglodesc{(\ref {valarray.range})}} {\memgloref{}}|memjustarg}{1466} +\glossaryentry{c.math@ {\memgloterm{c.math}}{\memglodesc{(\ref {c.math})}} {\memgloref{}}|memjustarg}{1466} +\glossaryentry{cmath.syn@ {\memgloterm{cmath.syn}}{\memglodesc{(\ref {cmath.syn})}} {\memgloref{}}|memjustarg}{1466} +\glossaryentry{c.math.abs@ {\memgloterm{c.math.abs}}{\memglodesc{(\ref {c.math.abs})}} {\memgloref{}}|memjustarg}{1473} +\glossaryentry{c.math.hypot3@ {\memgloterm{c.math.hypot3}}{\memglodesc{(\ref {c.math.hypot3})}} {\memgloref{}}|memjustarg}{1473} +\glossaryentry{c.math.lerp@ {\memgloterm{c.math.lerp}}{\memglodesc{(\ref {c.math.lerp})}} {\memgloref{}}|memjustarg}{1473} +\glossaryentry{c.math.fpclass@ {\memgloterm{c.math.fpclass}}{\memglodesc{(\ref {c.math.fpclass})}} {\memgloref{}}|memjustarg}{1473} +\glossaryentry{sf.cmath@ {\memgloterm{sf.cmath}}{\memglodesc{(\ref {sf.cmath})}} {\memgloref{}}|memjustarg}{1473} +\glossaryentry{sf.cmath.general@ {\memgloterm{sf.cmath.general}}{\memglodesc{(\ref {sf.cmath.general})}} {\memgloref{}}|memjustarg}{1473} +\glossaryentry{sf.cmath.assoc.laguerre@ {\memgloterm{sf.cmath.assoc.laguerre}}{\memglodesc{(\ref {sf.cmath.assoc.laguerre})}} {\memgloref{}}|memjustarg}{1474} +\glossaryentry{sf.cmath.assoc.legendre@ {\memgloterm{sf.cmath.assoc.legendre}}{\memglodesc{(\ref {sf.cmath.assoc.legendre})}} {\memgloref{}}|memjustarg}{1474} +\glossaryentry{sf.cmath.beta@ {\memgloterm{sf.cmath.beta}}{\memglodesc{(\ref {sf.cmath.beta})}} {\memgloref{}}|memjustarg}{1474} +\glossaryentry{sf.cmath.comp.ellint.1@ {\memgloterm{sf.cmath.comp.ellint.1}}{\memglodesc{(\ref {sf.cmath.comp.ellint.1})}} {\memgloref{}}|memjustarg}{1474} +\glossaryentry{sf.cmath.comp.ellint.2@ {\memgloterm{sf.cmath.comp.ellint.2}}{\memglodesc{(\ref {sf.cmath.comp.ellint.2})}} {\memgloref{}}|memjustarg}{1475} +\glossaryentry{sf.cmath.comp.ellint.3@ {\memgloterm{sf.cmath.comp.ellint.3}}{\memglodesc{(\ref {sf.cmath.comp.ellint.3})}} {\memgloref{}}|memjustarg}{1475} +\glossaryentry{sf.cmath.cyl.bessel.i@ {\memgloterm{sf.cmath.cyl.bessel.i}}{\memglodesc{(\ref {sf.cmath.cyl.bessel.i})}} {\memgloref{}}|memjustarg}{1475} +\glossaryentry{sf.cmath.cyl.bessel.j@ {\memgloterm{sf.cmath.cyl.bessel.j}}{\memglodesc{(\ref {sf.cmath.cyl.bessel.j})}} {\memgloref{}}|memjustarg}{1475} +\glossaryentry{sf.cmath.cyl.bessel.k@ {\memgloterm{sf.cmath.cyl.bessel.k}}{\memglodesc{(\ref {sf.cmath.cyl.bessel.k})}} {\memgloref{}}|memjustarg}{1476} +\glossaryentry{sf.cmath.cyl.neumann@ {\memgloterm{sf.cmath.cyl.neumann}}{\memglodesc{(\ref {sf.cmath.cyl.neumann})}} {\memgloref{}}|memjustarg}{1476} +\glossaryentry{sf.cmath.ellint.1@ {\memgloterm{sf.cmath.ellint.1}}{\memglodesc{(\ref {sf.cmath.ellint.1})}} {\memgloref{}}|memjustarg}{1476} +\glossaryentry{sf.cmath.ellint.2@ {\memgloterm{sf.cmath.ellint.2}}{\memglodesc{(\ref {sf.cmath.ellint.2})}} {\memgloref{}}|memjustarg}{1476} +\glossaryentry{sf.cmath.ellint.3@ {\memgloterm{sf.cmath.ellint.3}}{\memglodesc{(\ref {sf.cmath.ellint.3})}} {\memgloref{}}|memjustarg}{1477} +\glossaryentry{sf.cmath.expint@ {\memgloterm{sf.cmath.expint}}{\memglodesc{(\ref {sf.cmath.expint})}} {\memgloref{}}|memjustarg}{1477} +\glossaryentry{sf.cmath.hermite@ {\memgloterm{sf.cmath.hermite}}{\memglodesc{(\ref {sf.cmath.hermite})}} {\memgloref{}}|memjustarg}{1477} +\glossaryentry{sf.cmath.laguerre@ {\memgloterm{sf.cmath.laguerre}}{\memglodesc{(\ref {sf.cmath.laguerre})}} {\memgloref{}}|memjustarg}{1477} +\glossaryentry{sf.cmath.legendre@ {\memgloterm{sf.cmath.legendre}}{\memglodesc{(\ref {sf.cmath.legendre})}} {\memgloref{}}|memjustarg}{1477} +\glossaryentry{sf.cmath.riemann.zeta@ {\memgloterm{sf.cmath.riemann.zeta}}{\memglodesc{(\ref {sf.cmath.riemann.zeta})}} {\memgloref{}}|memjustarg}{1478} +\glossaryentry{sf.cmath.sph.bessel@ {\memgloterm{sf.cmath.sph.bessel}}{\memglodesc{(\ref {sf.cmath.sph.bessel})}} {\memgloref{}}|memjustarg}{1478} +\glossaryentry{sf.cmath.sph.legendre@ {\memgloterm{sf.cmath.sph.legendre}}{\memglodesc{(\ref {sf.cmath.sph.legendre})}} {\memgloref{}}|memjustarg}{1478} +\glossaryentry{sf.cmath.sph.neumann@ {\memgloterm{sf.cmath.sph.neumann}}{\memglodesc{(\ref {sf.cmath.sph.neumann})}} {\memgloref{}}|memjustarg}{1478} +\glossaryentry{numbers@ {\memgloterm{numbers}}{\memglodesc{(\ref {numbers})}} {\memgloref{}}|memjustarg}{1479} +\glossaryentry{numbers.syn@ {\memgloterm{numbers.syn}}{\memglodesc{(\ref {numbers.syn})}} {\memgloref{}}|memjustarg}{1479} +\glossaryentry{math.constants@ {\memgloterm{math.constants}}{\memglodesc{(\ref {math.constants})}} {\memgloref{}}|memjustarg}{1479} +\glossaryentry{time@ {\memgloterm{time}}{\memglodesc{(\ref {time})}} {\memgloref{}}|memjustarg}{1480} +\glossaryentry{time.general@ {\memgloterm{time.general}}{\memglodesc{(\ref {time.general})}} {\memgloref{}}|memjustarg}{1480} +\glossaryentry{time.syn@ {\memgloterm{time.syn}}{\memglodesc{(\ref {time.syn})}} {\memgloref{}}|memjustarg}{1480} +\glossaryentry{time.clock.req@ {\memgloterm{time.clock.req}}{\memglodesc{(\ref {time.clock.req})}} {\memgloref{}}|memjustarg}{1494} +\glossaryentry{time.traits@ {\memgloterm{time.traits}}{\memglodesc{(\ref {time.traits})}} {\memgloref{}}|memjustarg}{1495} +\glossaryentry{time.traits.is.fp@ {\memgloterm{time.traits.is.fp}}{\memglodesc{(\ref {time.traits.is.fp})}} {\memgloref{}}|memjustarg}{1495} +\glossaryentry{time.traits.duration.values@ {\memgloterm{time.traits.duration.values}}{\memglodesc{(\ref {time.traits.duration.values})}} {\memgloref{}}|memjustarg}{1495} +\glossaryentry{time.traits.specializations@ {\memgloterm{time.traits.specializations}}{\memglodesc{(\ref {time.traits.specializations})}} {\memgloref{}}|memjustarg}{1495} +\glossaryentry{time.traits.is.clock@ {\memgloterm{time.traits.is.clock}}{\memglodesc{(\ref {time.traits.is.clock})}} {\memgloref{}}|memjustarg}{1496} +\glossaryentry{time.duration@ {\memgloterm{time.duration}}{\memglodesc{(\ref {time.duration})}} {\memgloref{}}|memjustarg}{1496} +\glossaryentry{time.duration.general@ {\memgloterm{time.duration.general}}{\memglodesc{(\ref {time.duration.general})}} {\memgloref{}}|memjustarg}{1496} +\glossaryentry{time.duration.cons@ {\memgloterm{time.duration.cons}}{\memglodesc{(\ref {time.duration.cons})}} {\memgloref{}}|memjustarg}{1497} +\glossaryentry{time.duration.observer@ {\memgloterm{time.duration.observer}}{\memglodesc{(\ref {time.duration.observer})}} {\memgloref{}}|memjustarg}{1498} +\glossaryentry{time.duration.arithmetic@ {\memgloterm{time.duration.arithmetic}}{\memglodesc{(\ref {time.duration.arithmetic})}} {\memgloref{}}|memjustarg}{1498} +\glossaryentry{time.duration.special@ {\memgloterm{time.duration.special}}{\memglodesc{(\ref {time.duration.special})}} {\memgloref{}}|memjustarg}{1498} +\glossaryentry{time.duration.nonmember@ {\memgloterm{time.duration.nonmember}}{\memglodesc{(\ref {time.duration.nonmember})}} {\memgloref{}}|memjustarg}{1499} +\glossaryentry{time.duration.comparisons@ {\memgloterm{time.duration.comparisons}}{\memglodesc{(\ref {time.duration.comparisons})}} {\memgloref{}}|memjustarg}{1500} +\glossaryentry{time.duration.cast@ {\memgloterm{time.duration.cast}}{\memglodesc{(\ref {time.duration.cast})}} {\memgloref{}}|memjustarg}{1500} +\glossaryentry{time.duration.literals@ {\memgloterm{time.duration.literals}}{\memglodesc{(\ref {time.duration.literals})}} {\memgloref{}}|memjustarg}{1501} +\glossaryentry{time.duration.alg@ {\memgloterm{time.duration.alg}}{\memglodesc{(\ref {time.duration.alg})}} {\memgloref{}}|memjustarg}{1502} +\glossaryentry{time.duration.io@ {\memgloterm{time.duration.io}}{\memglodesc{(\ref {time.duration.io})}} {\memgloref{}}|memjustarg}{1502} +\glossaryentry{time.point@ {\memgloterm{time.point}}{\memglodesc{(\ref {time.point})}} {\memgloref{}}|memjustarg}{1503} +\glossaryentry{time.point.general@ {\memgloterm{time.point.general}}{\memglodesc{(\ref {time.point.general})}} {\memgloref{}}|memjustarg}{1503} +\glossaryentry{time.point.cons@ {\memgloterm{time.point.cons}}{\memglodesc{(\ref {time.point.cons})}} {\memgloref{}}|memjustarg}{1503} +\glossaryentry{time.point.observer@ {\memgloterm{time.point.observer}}{\memglodesc{(\ref {time.point.observer})}} {\memgloref{}}|memjustarg}{1504} +\glossaryentry{time.point.arithmetic@ {\memgloterm{time.point.arithmetic}}{\memglodesc{(\ref {time.point.arithmetic})}} {\memgloref{}}|memjustarg}{1504} +\glossaryentry{time.point.special@ {\memgloterm{time.point.special}}{\memglodesc{(\ref {time.point.special})}} {\memgloref{}}|memjustarg}{1504} +\glossaryentry{time.point.nonmember@ {\memgloterm{time.point.nonmember}}{\memglodesc{(\ref {time.point.nonmember})}} {\memgloref{}}|memjustarg}{1504} +\glossaryentry{time.point.comparisons@ {\memgloterm{time.point.comparisons}}{\memglodesc{(\ref {time.point.comparisons})}} {\memgloref{}}|memjustarg}{1505} +\glossaryentry{time.point.cast@ {\memgloterm{time.point.cast}}{\memglodesc{(\ref {time.point.cast})}} {\memgloref{}}|memjustarg}{1505} +\glossaryentry{time.clock@ {\memgloterm{time.clock}}{\memglodesc{(\ref {time.clock})}} {\memgloref{}}|memjustarg}{1506} +\glossaryentry{time.clock.general@ {\memgloterm{time.clock.general}}{\memglodesc{(\ref {time.clock.general})}} {\memgloref{}}|memjustarg}{1506} +\glossaryentry{time.clock.system@ {\memgloterm{time.clock.system}}{\memglodesc{(\ref {time.clock.system})}} {\memgloref{}}|memjustarg}{1506} +\glossaryentry{time.clock.system.overview@ {\memgloterm{time.clock.system.overview}}{\memglodesc{(\ref {time.clock.system.overview})}} {\memgloref{}}|memjustarg}{1506} +\glossaryentry{time.clock.system.members@ {\memgloterm{time.clock.system.members}}{\memglodesc{(\ref {time.clock.system.members})}} {\memgloref{}}|memjustarg}{1506} +\glossaryentry{time.clock.system.nonmembers@ {\memgloterm{time.clock.system.nonmembers}}{\memglodesc{(\ref {time.clock.system.nonmembers})}} {\memgloref{}}|memjustarg}{1506} +\glossaryentry{time.clock.utc@ {\memgloterm{time.clock.utc}}{\memglodesc{(\ref {time.clock.utc})}} {\memgloref{}}|memjustarg}{1507} +\glossaryentry{time.clock.utc.overview@ {\memgloterm{time.clock.utc.overview}}{\memglodesc{(\ref {time.clock.utc.overview})}} {\memgloref{}}|memjustarg}{1507} +\glossaryentry{time.clock.utc.members@ {\memgloterm{time.clock.utc.members}}{\memglodesc{(\ref {time.clock.utc.members})}} {\memgloref{}}|memjustarg}{1508} +\glossaryentry{time.clock.utc.nonmembers@ {\memgloterm{time.clock.utc.nonmembers}}{\memglodesc{(\ref {time.clock.utc.nonmembers})}} {\memgloref{}}|memjustarg}{1508} +\glossaryentry{time.clock.tai@ {\memgloterm{time.clock.tai}}{\memglodesc{(\ref {time.clock.tai})}} {\memgloref{}}|memjustarg}{1509} +\glossaryentry{time.clock.tai.overview@ {\memgloterm{time.clock.tai.overview}}{\memglodesc{(\ref {time.clock.tai.overview})}} {\memgloref{}}|memjustarg}{1509} +\glossaryentry{time.clock.tai.members@ {\memgloterm{time.clock.tai.members}}{\memglodesc{(\ref {time.clock.tai.members})}} {\memgloref{}}|memjustarg}{1510} +\glossaryentry{time.clock.tai.nonmembers@ {\memgloterm{time.clock.tai.nonmembers}}{\memglodesc{(\ref {time.clock.tai.nonmembers})}} {\memgloref{}}|memjustarg}{1510} +\glossaryentry{time.clock.gps@ {\memgloterm{time.clock.gps}}{\memglodesc{(\ref {time.clock.gps})}} {\memgloref{}}|memjustarg}{1511} +\glossaryentry{time.clock.gps.overview@ {\memgloterm{time.clock.gps.overview}}{\memglodesc{(\ref {time.clock.gps.overview})}} {\memgloref{}}|memjustarg}{1511} +\glossaryentry{time.clock.gps.members@ {\memgloterm{time.clock.gps.members}}{\memglodesc{(\ref {time.clock.gps.members})}} {\memgloref{}}|memjustarg}{1511} +\glossaryentry{time.clock.gps.nonmembers@ {\memgloterm{time.clock.gps.nonmembers}}{\memglodesc{(\ref {time.clock.gps.nonmembers})}} {\memgloref{}}|memjustarg}{1511} +\glossaryentry{time.clock.file@ {\memgloterm{time.clock.file}}{\memglodesc{(\ref {time.clock.file})}} {\memgloref{}}|memjustarg}{1512} +\glossaryentry{time.clock.file.overview@ {\memgloterm{time.clock.file.overview}}{\memglodesc{(\ref {time.clock.file.overview})}} {\memgloref{}}|memjustarg}{1512} +\glossaryentry{time.clock.file.members@ {\memgloterm{time.clock.file.members}}{\memglodesc{(\ref {time.clock.file.members})}} {\memgloref{}}|memjustarg}{1512} +\glossaryentry{time.clock.file.nonmembers@ {\memgloterm{time.clock.file.nonmembers}}{\memglodesc{(\ref {time.clock.file.nonmembers})}} {\memgloref{}}|memjustarg}{1513} +\glossaryentry{time.clock.steady@ {\memgloterm{time.clock.steady}}{\memglodesc{(\ref {time.clock.steady})}} {\memgloref{}}|memjustarg}{1513} +\glossaryentry{time.clock.hires@ {\memgloterm{time.clock.hires}}{\memglodesc{(\ref {time.clock.hires})}} {\memgloref{}}|memjustarg}{1513} +\glossaryentry{time.clock.local@ {\memgloterm{time.clock.local}}{\memglodesc{(\ref {time.clock.local})}} {\memgloref{}}|memjustarg}{1513} +\glossaryentry{time.clock.cast@ {\memgloterm{time.clock.cast}}{\memglodesc{(\ref {time.clock.cast})}} {\memgloref{}}|memjustarg}{1514} +\glossaryentry{time.clock.conv@ {\memgloterm{time.clock.conv}}{\memglodesc{(\ref {time.clock.conv})}} {\memgloref{}}|memjustarg}{1514} +\glossaryentry{time.clock.cast.id@ {\memgloterm{time.clock.cast.id}}{\memglodesc{(\ref {time.clock.cast.id})}} {\memgloref{}}|memjustarg}{1514} +\glossaryentry{time.clock.cast.sys.utc@ {\memgloterm{time.clock.cast.sys.utc}}{\memglodesc{(\ref {time.clock.cast.sys.utc})}} {\memgloref{}}|memjustarg}{1515} +\glossaryentry{time.clock.cast.sys@ {\memgloterm{time.clock.cast.sys}}{\memglodesc{(\ref {time.clock.cast.sys})}} {\memgloref{}}|memjustarg}{1515} +\glossaryentry{time.clock.cast.utc@ {\memgloterm{time.clock.cast.utc}}{\memglodesc{(\ref {time.clock.cast.utc})}} {\memgloref{}}|memjustarg}{1516} +\glossaryentry{time.clock.cast.fn@ {\memgloterm{time.clock.cast.fn}}{\memglodesc{(\ref {time.clock.cast.fn})}} {\memgloref{}}|memjustarg}{1516} +\glossaryentry{time.cal@ {\memgloterm{time.cal}}{\memglodesc{(\ref {time.cal})}} {\memgloref{}}|memjustarg}{1517} +\glossaryentry{time.cal.general@ {\memgloterm{time.cal.general}}{\memglodesc{(\ref {time.cal.general})}} {\memgloref{}}|memjustarg}{1517} +\glossaryentry{time.cal.last@ {\memgloterm{time.cal.last}}{\memglodesc{(\ref {time.cal.last})}} {\memgloref{}}|memjustarg}{1517} +\glossaryentry{time.cal.day@ {\memgloterm{time.cal.day}}{\memglodesc{(\ref {time.cal.day})}} {\memgloref{}}|memjustarg}{1517} +\glossaryentry{time.cal.day.overview@ {\memgloterm{time.cal.day.overview}}{\memglodesc{(\ref {time.cal.day.overview})}} {\memgloref{}}|memjustarg}{1517} +\glossaryentry{time.cal.day.members@ {\memgloterm{time.cal.day.members}}{\memglodesc{(\ref {time.cal.day.members})}} {\memgloref{}}|memjustarg}{1517} +\glossaryentry{time.cal.day.nonmembers@ {\memgloterm{time.cal.day.nonmembers}}{\memglodesc{(\ref {time.cal.day.nonmembers})}} {\memgloref{}}|memjustarg}{1518} +\glossaryentry{time.cal.month@ {\memgloterm{time.cal.month}}{\memglodesc{(\ref {time.cal.month})}} {\memgloref{}}|memjustarg}{1519} +\glossaryentry{time.cal.month.overview@ {\memgloterm{time.cal.month.overview}}{\memglodesc{(\ref {time.cal.month.overview})}} {\memgloref{}}|memjustarg}{1519} +\glossaryentry{time.cal.month.members@ {\memgloterm{time.cal.month.members}}{\memglodesc{(\ref {time.cal.month.members})}} {\memgloref{}}|memjustarg}{1519} +\glossaryentry{time.cal.month.nonmembers@ {\memgloterm{time.cal.month.nonmembers}}{\memglodesc{(\ref {time.cal.month.nonmembers})}} {\memgloref{}}|memjustarg}{1520} +\glossaryentry{time.cal.year@ {\memgloterm{time.cal.year}}{\memglodesc{(\ref {time.cal.year})}} {\memgloref{}}|memjustarg}{1521} +\glossaryentry{time.cal.year.overview@ {\memgloterm{time.cal.year.overview}}{\memglodesc{(\ref {time.cal.year.overview})}} {\memgloref{}}|memjustarg}{1521} +\glossaryentry{time.cal.year.members@ {\memgloterm{time.cal.year.members}}{\memglodesc{(\ref {time.cal.year.members})}} {\memgloref{}}|memjustarg}{1521} +\glossaryentry{time.cal.year.nonmembers@ {\memgloterm{time.cal.year.nonmembers}}{\memglodesc{(\ref {time.cal.year.nonmembers})}} {\memgloref{}}|memjustarg}{1522} +\glossaryentry{time.cal.wd@ {\memgloterm{time.cal.wd}}{\memglodesc{(\ref {time.cal.wd})}} {\memgloref{}}|memjustarg}{1523} +\glossaryentry{time.cal.wd.overview@ {\memgloterm{time.cal.wd.overview}}{\memglodesc{(\ref {time.cal.wd.overview})}} {\memgloref{}}|memjustarg}{1523} +\glossaryentry{time.cal.wd.members@ {\memgloterm{time.cal.wd.members}}{\memglodesc{(\ref {time.cal.wd.members})}} {\memgloref{}}|memjustarg}{1524} +\glossaryentry{time.cal.wd.nonmembers@ {\memgloterm{time.cal.wd.nonmembers}}{\memglodesc{(\ref {time.cal.wd.nonmembers})}} {\memgloref{}}|memjustarg}{1525} +\glossaryentry{time.cal.wdidx@ {\memgloterm{time.cal.wdidx}}{\memglodesc{(\ref {time.cal.wdidx})}} {\memgloref{}}|memjustarg}{1525} +\glossaryentry{time.cal.wdidx.overview@ {\memgloterm{time.cal.wdidx.overview}}{\memglodesc{(\ref {time.cal.wdidx.overview})}} {\memgloref{}}|memjustarg}{1525} +\glossaryentry{time.cal.wdidx.members@ {\memgloterm{time.cal.wdidx.members}}{\memglodesc{(\ref {time.cal.wdidx.members})}} {\memgloref{}}|memjustarg}{1526} +\glossaryentry{time.cal.wdidx.nonmembers@ {\memgloterm{time.cal.wdidx.nonmembers}}{\memglodesc{(\ref {time.cal.wdidx.nonmembers})}} {\memgloref{}}|memjustarg}{1526} +\glossaryentry{time.cal.wdlast@ {\memgloterm{time.cal.wdlast}}{\memglodesc{(\ref {time.cal.wdlast})}} {\memgloref{}}|memjustarg}{1526} +\glossaryentry{time.cal.wdlast.overview@ {\memgloterm{time.cal.wdlast.overview}}{\memglodesc{(\ref {time.cal.wdlast.overview})}} {\memgloref{}}|memjustarg}{1526} +\glossaryentry{time.cal.wdlast.members@ {\memgloterm{time.cal.wdlast.members}}{\memglodesc{(\ref {time.cal.wdlast.members})}} {\memgloref{}}|memjustarg}{1527} +\glossaryentry{time.cal.wdlast.nonmembers@ {\memgloterm{time.cal.wdlast.nonmembers}}{\memglodesc{(\ref {time.cal.wdlast.nonmembers})}} {\memgloref{}}|memjustarg}{1527} +\glossaryentry{time.cal.md@ {\memgloterm{time.cal.md}}{\memglodesc{(\ref {time.cal.md})}} {\memgloref{}}|memjustarg}{1527} +\glossaryentry{time.cal.md.overview@ {\memgloterm{time.cal.md.overview}}{\memglodesc{(\ref {time.cal.md.overview})}} {\memgloref{}}|memjustarg}{1527} +\glossaryentry{time.cal.md.members@ {\memgloterm{time.cal.md.members}}{\memglodesc{(\ref {time.cal.md.members})}} {\memgloref{}}|memjustarg}{1527} +\glossaryentry{time.cal.md.nonmembers@ {\memgloterm{time.cal.md.nonmembers}}{\memglodesc{(\ref {time.cal.md.nonmembers})}} {\memgloref{}}|memjustarg}{1528} +\glossaryentry{time.cal.mdlast@ {\memgloterm{time.cal.mdlast}}{\memglodesc{(\ref {time.cal.mdlast})}} {\memgloref{}}|memjustarg}{1528} +\glossaryentry{time.cal.mwd@ {\memgloterm{time.cal.mwd}}{\memglodesc{(\ref {time.cal.mwd})}} {\memgloref{}}|memjustarg}{1529} +\glossaryentry{time.cal.mwd.overview@ {\memgloterm{time.cal.mwd.overview}}{\memglodesc{(\ref {time.cal.mwd.overview})}} {\memgloref{}}|memjustarg}{1529} +\glossaryentry{time.cal.mwd.members@ {\memgloterm{time.cal.mwd.members}}{\memglodesc{(\ref {time.cal.mwd.members})}} {\memgloref{}}|memjustarg}{1529} +\glossaryentry{time.cal.mwd.nonmembers@ {\memgloterm{time.cal.mwd.nonmembers}}{\memglodesc{(\ref {time.cal.mwd.nonmembers})}} {\memgloref{}}|memjustarg}{1530} +\glossaryentry{time.cal.mwdlast@ {\memgloterm{time.cal.mwdlast}}{\memglodesc{(\ref {time.cal.mwdlast})}} {\memgloref{}}|memjustarg}{1530} +\glossaryentry{time.cal.mwdlast.overview@ {\memgloterm{time.cal.mwdlast.overview}}{\memglodesc{(\ref {time.cal.mwdlast.overview})}} {\memgloref{}}|memjustarg}{1530} +\glossaryentry{time.cal.mwdlast.members@ {\memgloterm{time.cal.mwdlast.members}}{\memglodesc{(\ref {time.cal.mwdlast.members})}} {\memgloref{}}|memjustarg}{1530} +\glossaryentry{time.cal.mwdlast.nonmembers@ {\memgloterm{time.cal.mwdlast.nonmembers}}{\memglodesc{(\ref {time.cal.mwdlast.nonmembers})}} {\memgloref{}}|memjustarg}{1530} +\glossaryentry{time.cal.ym@ {\memgloterm{time.cal.ym}}{\memglodesc{(\ref {time.cal.ym})}} {\memgloref{}}|memjustarg}{1531} +\glossaryentry{time.cal.ym.overview@ {\memgloterm{time.cal.ym.overview}}{\memglodesc{(\ref {time.cal.ym.overview})}} {\memgloref{}}|memjustarg}{1531} +\glossaryentry{time.cal.ym.members@ {\memgloterm{time.cal.ym.members}}{\memglodesc{(\ref {time.cal.ym.members})}} {\memgloref{}}|memjustarg}{1531} +\glossaryentry{time.cal.ym.nonmembers@ {\memgloterm{time.cal.ym.nonmembers}}{\memglodesc{(\ref {time.cal.ym.nonmembers})}} {\memgloref{}}|memjustarg}{1532} +\glossaryentry{time.cal.ymd@ {\memgloterm{time.cal.ymd}}{\memglodesc{(\ref {time.cal.ymd})}} {\memgloref{}}|memjustarg}{1533} +\glossaryentry{time.cal.ymd.overview@ {\memgloterm{time.cal.ymd.overview}}{\memglodesc{(\ref {time.cal.ymd.overview})}} {\memgloref{}}|memjustarg}{1533} +\glossaryentry{time.cal.ymd.members@ {\memgloterm{time.cal.ymd.members}}{\memglodesc{(\ref {time.cal.ymd.members})}} {\memgloref{}}|memjustarg}{1533} +\glossaryentry{time.cal.ymd.nonmembers@ {\memgloterm{time.cal.ymd.nonmembers}}{\memglodesc{(\ref {time.cal.ymd.nonmembers})}} {\memgloref{}}|memjustarg}{1535} +\glossaryentry{time.cal.ymdlast@ {\memgloterm{time.cal.ymdlast}}{\memglodesc{(\ref {time.cal.ymdlast})}} {\memgloref{}}|memjustarg}{1536} +\glossaryentry{time.cal.ymdlast.overview@ {\memgloterm{time.cal.ymdlast.overview}}{\memglodesc{(\ref {time.cal.ymdlast.overview})}} {\memgloref{}}|memjustarg}{1536} +\glossaryentry{time.cal.ymdlast.members@ {\memgloterm{time.cal.ymdlast.members}}{\memglodesc{(\ref {time.cal.ymdlast.members})}} {\memgloref{}}|memjustarg}{1536} +\glossaryentry{time.cal.ymdlast.nonmembers@ {\memgloterm{time.cal.ymdlast.nonmembers}}{\memglodesc{(\ref {time.cal.ymdlast.nonmembers})}} {\memgloref{}}|memjustarg}{1537} +\glossaryentry{time.cal.ymwd@ {\memgloterm{time.cal.ymwd}}{\memglodesc{(\ref {time.cal.ymwd})}} {\memgloref{}}|memjustarg}{1538} +\glossaryentry{time.cal.ymwd.overview@ {\memgloterm{time.cal.ymwd.overview}}{\memglodesc{(\ref {time.cal.ymwd.overview})}} {\memgloref{}}|memjustarg}{1538} +\glossaryentry{time.cal.ymwd.members@ {\memgloterm{time.cal.ymwd.members}}{\memglodesc{(\ref {time.cal.ymwd.members})}} {\memgloref{}}|memjustarg}{1539} +\glossaryentry{time.cal.ymwd.nonmembers@ {\memgloterm{time.cal.ymwd.nonmembers}}{\memglodesc{(\ref {time.cal.ymwd.nonmembers})}} {\memgloref{}}|memjustarg}{1540} +\glossaryentry{time.cal.ymwdlast@ {\memgloterm{time.cal.ymwdlast}}{\memglodesc{(\ref {time.cal.ymwdlast})}} {\memgloref{}}|memjustarg}{1540} +\glossaryentry{time.cal.ymwdlast.overview@ {\memgloterm{time.cal.ymwdlast.overview}}{\memglodesc{(\ref {time.cal.ymwdlast.overview})}} {\memgloref{}}|memjustarg}{1540} +\glossaryentry{time.cal.ymwdlast.members@ {\memgloterm{time.cal.ymwdlast.members}}{\memglodesc{(\ref {time.cal.ymwdlast.members})}} {\memgloref{}}|memjustarg}{1541} +\glossaryentry{time.cal.ymwdlast.nonmembers@ {\memgloterm{time.cal.ymwdlast.nonmembers}}{\memglodesc{(\ref {time.cal.ymwdlast.nonmembers})}} {\memgloref{}}|memjustarg}{1542} +\glossaryentry{time.cal.operators@ {\memgloterm{time.cal.operators}}{\memglodesc{(\ref {time.cal.operators})}} {\memgloref{}}|memjustarg}{1543} +\glossaryentry{time.hms@ {\memgloterm{time.hms}}{\memglodesc{(\ref {time.hms})}} {\memgloref{}}|memjustarg}{1546} +\glossaryentry{time.hms.overview@ {\memgloterm{time.hms.overview}}{\memglodesc{(\ref {time.hms.overview})}} {\memgloref{}}|memjustarg}{1546} +\glossaryentry{time.hms.members@ {\memgloterm{time.hms.members}}{\memglodesc{(\ref {time.hms.members})}} {\memgloref{}}|memjustarg}{1546} +\glossaryentry{time.hms.nonmembers@ {\memgloterm{time.hms.nonmembers}}{\memglodesc{(\ref {time.hms.nonmembers})}} {\memgloref{}}|memjustarg}{1548} +\glossaryentry{time.12@ {\memgloterm{time.12}}{\memglodesc{(\ref {time.12})}} {\memgloref{}}|memjustarg}{1548} +\glossaryentry{time.zone@ {\memgloterm{time.zone}}{\memglodesc{(\ref {time.zone})}} {\memgloref{}}|memjustarg}{1548} +\glossaryentry{time.zone.general@ {\memgloterm{time.zone.general}}{\memglodesc{(\ref {time.zone.general})}} {\memgloref{}}|memjustarg}{1548} +\glossaryentry{time.zone.db@ {\memgloterm{time.zone.db}}{\memglodesc{(\ref {time.zone.db})}} {\memgloref{}}|memjustarg}{1548} +\glossaryentry{time.zone.db.tzdb@ {\memgloterm{time.zone.db.tzdb}}{\memglodesc{(\ref {time.zone.db.tzdb})}} {\memgloref{}}|memjustarg}{1548} +\glossaryentry{time.zone.db.list@ {\memgloterm{time.zone.db.list}}{\memglodesc{(\ref {time.zone.db.list})}} {\memgloref{}}|memjustarg}{1549} +\glossaryentry{time.zone.db.access@ {\memgloterm{time.zone.db.access}}{\memglodesc{(\ref {time.zone.db.access})}} {\memgloref{}}|memjustarg}{1550} +\glossaryentry{time.zone.db.remote@ {\memgloterm{time.zone.db.remote}}{\memglodesc{(\ref {time.zone.db.remote})}} {\memgloref{}}|memjustarg}{1550} +\glossaryentry{time.zone.exception@ {\memgloterm{time.zone.exception}}{\memglodesc{(\ref {time.zone.exception})}} {\memgloref{}}|memjustarg}{1551} +\glossaryentry{time.zone.exception.nonexist@ {\memgloterm{time.zone.exception.nonexist}}{\memglodesc{(\ref {time.zone.exception.nonexist})}} {\memgloref{}}|memjustarg}{1551} +\glossaryentry{time.zone.exception.ambig@ {\memgloterm{time.zone.exception.ambig}}{\memglodesc{(\ref {time.zone.exception.ambig})}} {\memgloref{}}|memjustarg}{1551} +\glossaryentry{time.zone.info@ {\memgloterm{time.zone.info}}{\memglodesc{(\ref {time.zone.info})}} {\memgloref{}}|memjustarg}{1552} +\glossaryentry{time.zone.info.sys@ {\memgloterm{time.zone.info.sys}}{\memglodesc{(\ref {time.zone.info.sys})}} {\memgloref{}}|memjustarg}{1552} +\glossaryentry{time.zone.info.local@ {\memgloterm{time.zone.info.local}}{\memglodesc{(\ref {time.zone.info.local})}} {\memgloref{}}|memjustarg}{1553} +\glossaryentry{time.zone.timezone@ {\memgloterm{time.zone.timezone}}{\memglodesc{(\ref {time.zone.timezone})}} {\memgloref{}}|memjustarg}{1553} +\glossaryentry{time.zone.overview@ {\memgloterm{time.zone.overview}}{\memglodesc{(\ref {time.zone.overview})}} {\memgloref{}}|memjustarg}{1553} +\glossaryentry{time.zone.members@ {\memgloterm{time.zone.members}}{\memglodesc{(\ref {time.zone.members})}} {\memgloref{}}|memjustarg}{1554} +\glossaryentry{time.zone.nonmembers@ {\memgloterm{time.zone.nonmembers}}{\memglodesc{(\ref {time.zone.nonmembers})}} {\memgloref{}}|memjustarg}{1555} +\glossaryentry{time.zone.zonedtraits@ {\memgloterm{time.zone.zonedtraits}}{\memglodesc{(\ref {time.zone.zonedtraits})}} {\memgloref{}}|memjustarg}{1555} +\glossaryentry{time.zone.zonedtime@ {\memgloterm{time.zone.zonedtime}}{\memglodesc{(\ref {time.zone.zonedtime})}} {\memgloref{}}|memjustarg}{1555} +\glossaryentry{time.zone.zonedtime.overview@ {\memgloterm{time.zone.zonedtime.overview}}{\memglodesc{(\ref {time.zone.zonedtime.overview})}} {\memgloref{}}|memjustarg}{1555} +\glossaryentry{time.zone.zonedtime.ctor@ {\memgloterm{time.zone.zonedtime.ctor}}{\memglodesc{(\ref {time.zone.zonedtime.ctor})}} {\memgloref{}}|memjustarg}{1557} +\glossaryentry{time.zone.zonedtime.members@ {\memgloterm{time.zone.zonedtime.members}}{\memglodesc{(\ref {time.zone.zonedtime.members})}} {\memgloref{}}|memjustarg}{1558} +\glossaryentry{time.zone.zonedtime.nonmembers@ {\memgloterm{time.zone.zonedtime.nonmembers}}{\memglodesc{(\ref {time.zone.zonedtime.nonmembers})}} {\memgloref{}}|memjustarg}{1559} +\glossaryentry{time.zone.leap@ {\memgloterm{time.zone.leap}}{\memglodesc{(\ref {time.zone.leap})}} {\memgloref{}}|memjustarg}{1559} +\glossaryentry{time.zone.leap.overview@ {\memgloterm{time.zone.leap.overview}}{\memglodesc{(\ref {time.zone.leap.overview})}} {\memgloref{}}|memjustarg}{1559} +\glossaryentry{time.zone.leap.members@ {\memgloterm{time.zone.leap.members}}{\memglodesc{(\ref {time.zone.leap.members})}} {\memgloref{}}|memjustarg}{1560} +\glossaryentry{time.zone.leap.nonmembers@ {\memgloterm{time.zone.leap.nonmembers}}{\memglodesc{(\ref {time.zone.leap.nonmembers})}} {\memgloref{}}|memjustarg}{1560} +\glossaryentry{time.zone.link@ {\memgloterm{time.zone.link}}{\memglodesc{(\ref {time.zone.link})}} {\memgloref{}}|memjustarg}{1561} +\glossaryentry{time.zone.link.overview@ {\memgloterm{time.zone.link.overview}}{\memglodesc{(\ref {time.zone.link.overview})}} {\memgloref{}}|memjustarg}{1561} +\glossaryentry{time.zone.link.members@ {\memgloterm{time.zone.link.members}}{\memglodesc{(\ref {time.zone.link.members})}} {\memgloref{}}|memjustarg}{1561} +\glossaryentry{time.zone.link.nonmembers@ {\memgloterm{time.zone.link.nonmembers}}{\memglodesc{(\ref {time.zone.link.nonmembers})}} {\memgloref{}}|memjustarg}{1561} +\glossaryentry{time.format@ {\memgloterm{time.format}}{\memglodesc{(\ref {time.format})}} {\memgloref{}}|memjustarg}{1561} +\glossaryentry{time.parse@ {\memgloterm{time.parse}}{\memglodesc{(\ref {time.parse})}} {\memgloref{}}|memjustarg}{1565} +\glossaryentry{ctime.syn@ {\memgloterm{ctime.syn}}{\memglodesc{(\ref {ctime.syn})}} {\memgloref{}}|memjustarg}{1569} +\glossaryentry{localization@ {\memgloterm{localization}}{\memglodesc{(\ref {localization})}} {\memgloref{}}|memjustarg}{1571} +\glossaryentry{localization.general@ {\memgloterm{localization.general}}{\memglodesc{(\ref {localization.general})}} {\memgloref{}}|memjustarg}{1571} +\glossaryentry{locale.syn@ {\memgloterm{locale.syn}}{\memglodesc{(\ref {locale.syn})}} {\memgloref{}}|memjustarg}{1571} +\glossaryentry{locales@ {\memgloterm{locales}}{\memglodesc{(\ref {locales})}} {\memgloref{}}|memjustarg}{1572} +\glossaryentry{locale@ {\memgloterm{locale}}{\memglodesc{(\ref {locale})}} {\memgloref{}}|memjustarg}{1572} +\glossaryentry{locale.general@ {\memgloterm{locale.general}}{\memglodesc{(\ref {locale.general})}} {\memgloref{}}|memjustarg}{1572} +\glossaryentry{locale.types@ {\memgloterm{locale.types}}{\memglodesc{(\ref {locale.types})}} {\memgloref{}}|memjustarg}{1574} +\glossaryentry{locale.category@ {\memgloterm{locale.category}}{\memglodesc{(\ref {locale.category})}} {\memgloref{}}|memjustarg}{1574} +\glossaryentry{locale.facet@ {\memgloterm{locale.facet}}{\memglodesc{(\ref {locale.facet})}} {\memgloref{}}|memjustarg}{1575} +\glossaryentry{locale.id@ {\memgloterm{locale.id}}{\memglodesc{(\ref {locale.id})}} {\memgloref{}}|memjustarg}{1576} +\glossaryentry{locale.cons@ {\memgloterm{locale.cons}}{\memglodesc{(\ref {locale.cons})}} {\memgloref{}}|memjustarg}{1576} +\glossaryentry{locale.members@ {\memgloterm{locale.members}}{\memglodesc{(\ref {locale.members})}} {\memgloref{}}|memjustarg}{1577} +\glossaryentry{locale.operators@ {\memgloterm{locale.operators}}{\memglodesc{(\ref {locale.operators})}} {\memgloref{}}|memjustarg}{1577} +\glossaryentry{locale.statics@ {\memgloterm{locale.statics}}{\memglodesc{(\ref {locale.statics})}} {\memgloref{}}|memjustarg}{1577} +\glossaryentry{locale.global.templates@ {\memgloterm{locale.global.templates}}{\memglodesc{(\ref {locale.global.templates})}} {\memgloref{}}|memjustarg}{1578} +\glossaryentry{locale.convenience@ {\memgloterm{locale.convenience}}{\memglodesc{(\ref {locale.convenience})}} {\memgloref{}}|memjustarg}{1578} +\glossaryentry{classification@ {\memgloterm{classification}}{\memglodesc{(\ref {classification})}} {\memgloref{}}|memjustarg}{1578} +\glossaryentry{conversions.character@ {\memgloterm{conversions.character}}{\memglodesc{(\ref {conversions.character})}} {\memgloref{}}|memjustarg}{1578} +\glossaryentry{locale.categories@ {\memgloterm{locale.categories}}{\memglodesc{(\ref {locale.categories})}} {\memgloref{}}|memjustarg}{1578} +\glossaryentry{locale.categories.general@ {\memgloterm{locale.categories.general}}{\memglodesc{(\ref {locale.categories.general})}} {\memgloref{}}|memjustarg}{1578} +\glossaryentry{category.ctype@ {\memgloterm{category.ctype}}{\memglodesc{(\ref {category.ctype})}} {\memgloref{}}|memjustarg}{1579} +\glossaryentry{category.ctype.general@ {\memgloterm{category.ctype.general}}{\memglodesc{(\ref {category.ctype.general})}} {\memgloref{}}|memjustarg}{1579} +\glossaryentry{locale.ctype@ {\memgloterm{locale.ctype}}{\memglodesc{(\ref {locale.ctype})}} {\memgloref{}}|memjustarg}{1579} +\glossaryentry{locale.ctype.general@ {\memgloterm{locale.ctype.general}}{\memglodesc{(\ref {locale.ctype.general})}} {\memgloref{}}|memjustarg}{1579} +\glossaryentry{locale.ctype.members@ {\memgloterm{locale.ctype.members}}{\memglodesc{(\ref {locale.ctype.members})}} {\memgloref{}}|memjustarg}{1580} +\glossaryentry{locale.ctype.virtuals@ {\memgloterm{locale.ctype.virtuals}}{\memglodesc{(\ref {locale.ctype.virtuals})}} {\memgloref{}}|memjustarg}{1580} +\glossaryentry{locale.ctype.byname@ {\memgloterm{locale.ctype.byname}}{\memglodesc{(\ref {locale.ctype.byname})}} {\memgloref{}}|memjustarg}{1581} +\glossaryentry{facet.ctype.special@ {\memgloterm{facet.ctype.special}}{\memglodesc{(\ref {facet.ctype.special})}} {\memgloref{}}|memjustarg}{1582} +\glossaryentry{facet.ctype.special.general@ {\memgloterm{facet.ctype.special.general}}{\memglodesc{(\ref {facet.ctype.special.general})}} {\memgloref{}}|memjustarg}{1582} +\glossaryentry{facet.ctype.char.dtor@ {\memgloterm{facet.ctype.char.dtor}}{\memglodesc{(\ref {facet.ctype.char.dtor})}} {\memgloref{}}|memjustarg}{1582} +\glossaryentry{facet.ctype.char.members@ {\memgloterm{facet.ctype.char.members}}{\memglodesc{(\ref {facet.ctype.char.members})}} {\memgloref{}}|memjustarg}{1583} +\glossaryentry{facet.ctype.char.statics@ {\memgloterm{facet.ctype.char.statics}}{\memglodesc{(\ref {facet.ctype.char.statics})}} {\memgloref{}}|memjustarg}{1583} +\glossaryentry{facet.ctype.char.virtuals@ {\memgloterm{facet.ctype.char.virtuals}}{\memglodesc{(\ref {facet.ctype.char.virtuals})}} {\memgloref{}}|memjustarg}{1583} +\glossaryentry{locale.codecvt@ {\memgloterm{locale.codecvt}}{\memglodesc{(\ref {locale.codecvt})}} {\memgloref{}}|memjustarg}{1584} +\glossaryentry{locale.codecvt.general@ {\memgloterm{locale.codecvt.general}}{\memglodesc{(\ref {locale.codecvt.general})}} {\memgloref{}}|memjustarg}{1584} +\glossaryentry{locale.codecvt.members@ {\memgloterm{locale.codecvt.members}}{\memglodesc{(\ref {locale.codecvt.members})}} {\memgloref{}}|memjustarg}{1585} +\glossaryentry{locale.codecvt.virtuals@ {\memgloterm{locale.codecvt.virtuals}}{\memglodesc{(\ref {locale.codecvt.virtuals})}} {\memgloref{}}|memjustarg}{1585} +\glossaryentry{locale.codecvt.byname@ {\memgloterm{locale.codecvt.byname}}{\memglodesc{(\ref {locale.codecvt.byname})}} {\memgloref{}}|memjustarg}{1587} +\glossaryentry{category.numeric@ {\memgloterm{category.numeric}}{\memglodesc{(\ref {category.numeric})}} {\memgloref{}}|memjustarg}{1587} +\glossaryentry{category.numeric.general@ {\memgloterm{category.numeric.general}}{\memglodesc{(\ref {category.numeric.general})}} {\memgloref{}}|memjustarg}{1587} +\glossaryentry{locale.num.get@ {\memgloterm{locale.num.get}}{\memglodesc{(\ref {locale.num.get})}} {\memgloref{}}|memjustarg}{1588} +\glossaryentry{locale.num.get.general@ {\memgloterm{locale.num.get.general}}{\memglodesc{(\ref {locale.num.get.general})}} {\memgloref{}}|memjustarg}{1588} +\glossaryentry{facet.num.get.members@ {\memgloterm{facet.num.get.members}}{\memglodesc{(\ref {facet.num.get.members})}} {\memgloref{}}|memjustarg}{1589} +\glossaryentry{facet.num.get.virtuals@ {\memgloterm{facet.num.get.virtuals}}{\memglodesc{(\ref {facet.num.get.virtuals})}} {\memgloref{}}|memjustarg}{1589} +\glossaryentry{locale.nm.put@ {\memgloterm{locale.nm.put}}{\memglodesc{(\ref {locale.nm.put})}} {\memgloref{}}|memjustarg}{1592} +\glossaryentry{locale.nm.put.general@ {\memgloterm{locale.nm.put.general}}{\memglodesc{(\ref {locale.nm.put.general})}} {\memgloref{}}|memjustarg}{1592} +\glossaryentry{facet.num.put.members@ {\memgloterm{facet.num.put.members}}{\memglodesc{(\ref {facet.num.put.members})}} {\memgloref{}}|memjustarg}{1592} +\glossaryentry{facet.num.put.virtuals@ {\memgloterm{facet.num.put.virtuals}}{\memglodesc{(\ref {facet.num.put.virtuals})}} {\memgloref{}}|memjustarg}{1592} +\glossaryentry{facet.numpunct@ {\memgloterm{facet.numpunct}}{\memglodesc{(\ref {facet.numpunct})}} {\memgloref{}}|memjustarg}{1595} +\glossaryentry{locale.numpunct@ {\memgloterm{locale.numpunct}}{\memglodesc{(\ref {locale.numpunct})}} {\memgloref{}}|memjustarg}{1595} +\glossaryentry{locale.numpunct.general@ {\memgloterm{locale.numpunct.general}}{\memglodesc{(\ref {locale.numpunct.general})}} {\memgloref{}}|memjustarg}{1595} +\glossaryentry{facet.numpunct.members@ {\memgloterm{facet.numpunct.members}}{\memglodesc{(\ref {facet.numpunct.members})}} {\memgloref{}}|memjustarg}{1596} +\glossaryentry{facet.numpunct.virtuals@ {\memgloterm{facet.numpunct.virtuals}}{\memglodesc{(\ref {facet.numpunct.virtuals})}} {\memgloref{}}|memjustarg}{1596} +\glossaryentry{locale.numpunct.byname@ {\memgloterm{locale.numpunct.byname}}{\memglodesc{(\ref {locale.numpunct.byname})}} {\memgloref{}}|memjustarg}{1596} +\glossaryentry{category.collate@ {\memgloterm{category.collate}}{\memglodesc{(\ref {category.collate})}} {\memgloref{}}|memjustarg}{1597} +\glossaryentry{locale.collate@ {\memgloterm{locale.collate}}{\memglodesc{(\ref {locale.collate})}} {\memgloref{}}|memjustarg}{1597} +\glossaryentry{locale.collate.general@ {\memgloterm{locale.collate.general}}{\memglodesc{(\ref {locale.collate.general})}} {\memgloref{}}|memjustarg}{1597} +\glossaryentry{locale.collate.members@ {\memgloterm{locale.collate.members}}{\memglodesc{(\ref {locale.collate.members})}} {\memgloref{}}|memjustarg}{1597} +\glossaryentry{locale.collate.virtuals@ {\memgloterm{locale.collate.virtuals}}{\memglodesc{(\ref {locale.collate.virtuals})}} {\memgloref{}}|memjustarg}{1597} +\glossaryentry{locale.collate.byname@ {\memgloterm{locale.collate.byname}}{\memglodesc{(\ref {locale.collate.byname})}} {\memgloref{}}|memjustarg}{1598} +\glossaryentry{category.time@ {\memgloterm{category.time}}{\memglodesc{(\ref {category.time})}} {\memgloref{}}|memjustarg}{1598} +\glossaryentry{category.time.general@ {\memgloterm{category.time.general}}{\memglodesc{(\ref {category.time.general})}} {\memgloref{}}|memjustarg}{1598} +\glossaryentry{locale.time.get@ {\memgloterm{locale.time.get}}{\memglodesc{(\ref {locale.time.get})}} {\memgloref{}}|memjustarg}{1598} +\glossaryentry{locale.time.get.general@ {\memgloterm{locale.time.get.general}}{\memglodesc{(\ref {locale.time.get.general})}} {\memgloref{}}|memjustarg}{1598} +\glossaryentry{locale.time.get.members@ {\memgloterm{locale.time.get.members}}{\memglodesc{(\ref {locale.time.get.members})}} {\memgloref{}}|memjustarg}{1599} +\glossaryentry{locale.time.get.virtuals@ {\memgloterm{locale.time.get.virtuals}}{\memglodesc{(\ref {locale.time.get.virtuals})}} {\memgloref{}}|memjustarg}{1600} +\glossaryentry{locale.time.get.byname@ {\memgloterm{locale.time.get.byname}}{\memglodesc{(\ref {locale.time.get.byname})}} {\memgloref{}}|memjustarg}{1601} +\glossaryentry{locale.time.put@ {\memgloterm{locale.time.put}}{\memglodesc{(\ref {locale.time.put})}} {\memgloref{}}|memjustarg}{1602} +\glossaryentry{locale.time.put.members@ {\memgloterm{locale.time.put.members}}{\memglodesc{(\ref {locale.time.put.members})}} {\memgloref{}}|memjustarg}{1602} +\glossaryentry{locale.time.put.virtuals@ {\memgloterm{locale.time.put.virtuals}}{\memglodesc{(\ref {locale.time.put.virtuals})}} {\memgloref{}}|memjustarg}{1603} +\glossaryentry{locale.time.put.byname@ {\memgloterm{locale.time.put.byname}}{\memglodesc{(\ref {locale.time.put.byname})}} {\memgloref{}}|memjustarg}{1603} +\glossaryentry{category.monetary@ {\memgloterm{category.monetary}}{\memglodesc{(\ref {category.monetary})}} {\memgloref{}}|memjustarg}{1603} +\glossaryentry{category.monetary.general@ {\memgloterm{category.monetary.general}}{\memglodesc{(\ref {category.monetary.general})}} {\memgloref{}}|memjustarg}{1603} +\glossaryentry{locale.money.get@ {\memgloterm{locale.money.get}}{\memglodesc{(\ref {locale.money.get})}} {\memgloref{}}|memjustarg}{1603} +\glossaryentry{locale.money.get.members@ {\memgloterm{locale.money.get.members}}{\memglodesc{(\ref {locale.money.get.members})}} {\memgloref{}}|memjustarg}{1604} +\glossaryentry{locale.money.get.virtuals@ {\memgloterm{locale.money.get.virtuals}}{\memglodesc{(\ref {locale.money.get.virtuals})}} {\memgloref{}}|memjustarg}{1604} +\glossaryentry{locale.money.put@ {\memgloterm{locale.money.put}}{\memglodesc{(\ref {locale.money.put})}} {\memgloref{}}|memjustarg}{1605} +\glossaryentry{locale.money.put.members@ {\memgloterm{locale.money.put.members}}{\memglodesc{(\ref {locale.money.put.members})}} {\memgloref{}}|memjustarg}{1605} +\glossaryentry{locale.money.put.virtuals@ {\memgloterm{locale.money.put.virtuals}}{\memglodesc{(\ref {locale.money.put.virtuals})}} {\memgloref{}}|memjustarg}{1605} +\glossaryentry{locale.moneypunct@ {\memgloterm{locale.moneypunct}}{\memglodesc{(\ref {locale.moneypunct})}} {\memgloref{}}|memjustarg}{1606} +\glossaryentry{locale.moneypunct.general@ {\memgloterm{locale.moneypunct.general}}{\memglodesc{(\ref {locale.moneypunct.general})}} {\memgloref{}}|memjustarg}{1606} +\glossaryentry{locale.moneypunct.members@ {\memgloterm{locale.moneypunct.members}}{\memglodesc{(\ref {locale.moneypunct.members})}} {\memgloref{}}|memjustarg}{1607} +\glossaryentry{locale.moneypunct.virtuals@ {\memgloterm{locale.moneypunct.virtuals}}{\memglodesc{(\ref {locale.moneypunct.virtuals})}} {\memgloref{}}|memjustarg}{1607} +\glossaryentry{locale.moneypunct.byname@ {\memgloterm{locale.moneypunct.byname}}{\memglodesc{(\ref {locale.moneypunct.byname})}} {\memgloref{}}|memjustarg}{1608} +\glossaryentry{category.messages@ {\memgloterm{category.messages}}{\memglodesc{(\ref {category.messages})}} {\memgloref{}}|memjustarg}{1608} +\glossaryentry{category.messages.general@ {\memgloterm{category.messages.general}}{\memglodesc{(\ref {category.messages.general})}} {\memgloref{}}|memjustarg}{1608} +\glossaryentry{locale.messages@ {\memgloterm{locale.messages}}{\memglodesc{(\ref {locale.messages})}} {\memgloref{}}|memjustarg}{1609} +\glossaryentry{locale.messages.general@ {\memgloterm{locale.messages.general}}{\memglodesc{(\ref {locale.messages.general})}} {\memgloref{}}|memjustarg}{1609} +\glossaryentry{locale.messages.members@ {\memgloterm{locale.messages.members}}{\memglodesc{(\ref {locale.messages.members})}} {\memgloref{}}|memjustarg}{1609} +\glossaryentry{locale.messages.virtuals@ {\memgloterm{locale.messages.virtuals}}{\memglodesc{(\ref {locale.messages.virtuals})}} {\memgloref{}}|memjustarg}{1609} +\glossaryentry{locale.messages.byname@ {\memgloterm{locale.messages.byname}}{\memglodesc{(\ref {locale.messages.byname})}} {\memgloref{}}|memjustarg}{1610} +\glossaryentry{c.locales@ {\memgloterm{c.locales}}{\memglodesc{(\ref {c.locales})}} {\memgloref{}}|memjustarg}{1610} +\glossaryentry{clocale.syn@ {\memgloterm{clocale.syn}}{\memglodesc{(\ref {clocale.syn})}} {\memgloref{}}|memjustarg}{1610} +\glossaryentry{clocale.data.races@ {\memgloterm{clocale.data.races}}{\memglodesc{(\ref {clocale.data.races})}} {\memgloref{}}|memjustarg}{1610} +\glossaryentry{input.output@ {\memgloterm{input.output}}{\memglodesc{(\ref {input.output})}} {\memgloref{}}|memjustarg}{1611} +\glossaryentry{input.output.general@ {\memgloterm{input.output.general}}{\memglodesc{(\ref {input.output.general})}} {\memgloref{}}|memjustarg}{1611} +\glossaryentry{iostreams.requirements@ {\memgloterm{iostreams.requirements}}{\memglodesc{(\ref {iostreams.requirements})}} {\memgloref{}}|memjustarg}{1611} +\glossaryentry{iostream.limits.imbue@ {\memgloterm{iostream.limits.imbue}}{\memglodesc{(\ref {iostream.limits.imbue})}} {\memgloref{}}|memjustarg}{1611} +\glossaryentry{stream.types@ {\memgloterm{stream.types}}{\memglodesc{(\ref {stream.types})}} {\memgloref{}}|memjustarg}{1611} +\glossaryentry{iostreams.limits.pos@ {\memgloterm{iostreams.limits.pos}}{\memglodesc{(\ref {iostreams.limits.pos})}} {\memgloref{}}|memjustarg}{1611} +\glossaryentry{iostreams.threadsafety@ {\memgloterm{iostreams.threadsafety}}{\memglodesc{(\ref {iostreams.threadsafety})}} {\memgloref{}}|memjustarg}{1612} +\glossaryentry{iostream.forward@ {\memgloterm{iostream.forward}}{\memglodesc{(\ref {iostream.forward})}} {\memgloref{}}|memjustarg}{1612} +\glossaryentry{iosfwd.syn@ {\memgloterm{iosfwd.syn}}{\memglodesc{(\ref {iosfwd.syn})}} {\memgloref{}}|memjustarg}{1612} +\glossaryentry{iostream.forward.overview@ {\memgloterm{iostream.forward.overview}}{\memglodesc{(\ref {iostream.forward.overview})}} {\memgloref{}}|memjustarg}{1614} +\glossaryentry{iostream.objects@ {\memgloterm{iostream.objects}}{\memglodesc{(\ref {iostream.objects})}} {\memgloref{}}|memjustarg}{1614} +\glossaryentry{iostream.syn@ {\memgloterm{iostream.syn}}{\memglodesc{(\ref {iostream.syn})}} {\memgloref{}}|memjustarg}{1614} +\glossaryentry{iostream.objects.overview@ {\memgloterm{iostream.objects.overview}}{\memglodesc{(\ref {iostream.objects.overview})}} {\memgloref{}}|memjustarg}{1614} +\glossaryentry{narrow.stream.objects@ {\memgloterm{narrow.stream.objects}}{\memglodesc{(\ref {narrow.stream.objects})}} {\memgloref{}}|memjustarg}{1615} +\glossaryentry{wide.stream.objects@ {\memgloterm{wide.stream.objects}}{\memglodesc{(\ref {wide.stream.objects})}} {\memgloref{}}|memjustarg}{1615} +\glossaryentry{iostreams.base@ {\memgloterm{iostreams.base}}{\memglodesc{(\ref {iostreams.base})}} {\memgloref{}}|memjustarg}{1616} +\glossaryentry{ios.syn@ {\memgloterm{ios.syn}}{\memglodesc{(\ref {ios.syn})}} {\memgloref{}}|memjustarg}{1616} +\glossaryentry{ios.base@ {\memgloterm{ios.base}}{\memglodesc{(\ref {ios.base})}} {\memgloref{}}|memjustarg}{1617} +\glossaryentry{ios.base.general@ {\memgloterm{ios.base.general}}{\memglodesc{(\ref {ios.base.general})}} {\memgloref{}}|memjustarg}{1617} +\glossaryentry{ios.types@ {\memgloterm{ios.types}}{\memglodesc{(\ref {ios.types})}} {\memgloref{}}|memjustarg}{1619} +\glossaryentry{ios.failure@ {\memgloterm{ios.failure}}{\memglodesc{(\ref {ios.failure})}} {\memgloref{}}|memjustarg}{1619} +\glossaryentry{ios.fmtflags@ {\memgloterm{ios.fmtflags}}{\memglodesc{(\ref {ios.fmtflags})}} {\memgloref{}}|memjustarg}{1619} +\glossaryentry{ios.iostate@ {\memgloterm{ios.iostate}}{\memglodesc{(\ref {ios.iostate})}} {\memgloref{}}|memjustarg}{1619} +\glossaryentry{ios.openmode@ {\memgloterm{ios.openmode}}{\memglodesc{(\ref {ios.openmode})}} {\memgloref{}}|memjustarg}{1619} +\glossaryentry{ios.seekdir@ {\memgloterm{ios.seekdir}}{\memglodesc{(\ref {ios.seekdir})}} {\memgloref{}}|memjustarg}{1619} +\glossaryentry{ios.init@ {\memgloterm{ios.init}}{\memglodesc{(\ref {ios.init})}} {\memgloref{}}|memjustarg}{1621} +\glossaryentry{fmtflags.state@ {\memgloterm{fmtflags.state}}{\memglodesc{(\ref {fmtflags.state})}} {\memgloref{}}|memjustarg}{1621} +\glossaryentry{ios.base.locales@ {\memgloterm{ios.base.locales}}{\memglodesc{(\ref {ios.base.locales})}} {\memgloref{}}|memjustarg}{1622} +\glossaryentry{ios.members.static@ {\memgloterm{ios.members.static}}{\memglodesc{(\ref {ios.members.static})}} {\memgloref{}}|memjustarg}{1622} +\glossaryentry{ios.base.storage@ {\memgloterm{ios.base.storage}}{\memglodesc{(\ref {ios.base.storage})}} {\memgloref{}}|memjustarg}{1622} +\glossaryentry{ios.base.callback@ {\memgloterm{ios.base.callback}}{\memglodesc{(\ref {ios.base.callback})}} {\memgloref{}}|memjustarg}{1623} +\glossaryentry{ios.base.cons@ {\memgloterm{ios.base.cons}}{\memglodesc{(\ref {ios.base.cons})}} {\memgloref{}}|memjustarg}{1623} +\glossaryentry{fpos@ {\memgloterm{fpos}}{\memglodesc{(\ref {fpos})}} {\memgloref{}}|memjustarg}{1623} +\glossaryentry{fpos.members@ {\memgloterm{fpos.members}}{\memglodesc{(\ref {fpos.members})}} {\memgloref{}}|memjustarg}{1624} +\glossaryentry{fpos.operations@ {\memgloterm{fpos.operations}}{\memglodesc{(\ref {fpos.operations})}} {\memgloref{}}|memjustarg}{1624} +\glossaryentry{ios@ {\memgloterm{ios}}{\memglodesc{(\ref {ios})}} {\memgloref{}}|memjustarg}{1625} +\glossaryentry{ios.overview@ {\memgloterm{ios.overview}}{\memglodesc{(\ref {ios.overview})}} {\memgloref{}}|memjustarg}{1625} +\glossaryentry{basic.ios.cons@ {\memgloterm{basic.ios.cons}}{\memglodesc{(\ref {basic.ios.cons})}} {\memgloref{}}|memjustarg}{1626} +\glossaryentry{basic.ios.members@ {\memgloterm{basic.ios.members}}{\memglodesc{(\ref {basic.ios.members})}} {\memgloref{}}|memjustarg}{1626} +\glossaryentry{iostate.flags@ {\memgloterm{iostate.flags}}{\memglodesc{(\ref {iostate.flags})}} {\memgloref{}}|memjustarg}{1628} +\glossaryentry{std.ios.manip@ {\memgloterm{std.ios.manip}}{\memglodesc{(\ref {std.ios.manip})}} {\memgloref{}}|memjustarg}{1629} +\glossaryentry{fmtflags.manip@ {\memgloterm{fmtflags.manip}}{\memglodesc{(\ref {fmtflags.manip})}} {\memgloref{}}|memjustarg}{1629} +\glossaryentry{adjustfield.manip@ {\memgloterm{adjustfield.manip}}{\memglodesc{(\ref {adjustfield.manip})}} {\memgloref{}}|memjustarg}{1630} +\glossaryentry{basefield.manip@ {\memgloterm{basefield.manip}}{\memglodesc{(\ref {basefield.manip})}} {\memgloref{}}|memjustarg}{1630} +\glossaryentry{floatfield.manip@ {\memgloterm{floatfield.manip}}{\memglodesc{(\ref {floatfield.manip})}} {\memgloref{}}|memjustarg}{1630} +\glossaryentry{error.reporting@ {\memgloterm{error.reporting}}{\memglodesc{(\ref {error.reporting})}} {\memgloref{}}|memjustarg}{1631} +\glossaryentry{stream.buffers@ {\memgloterm{stream.buffers}}{\memglodesc{(\ref {stream.buffers})}} {\memgloref{}}|memjustarg}{1631} +\glossaryentry{streambuf.syn@ {\memgloterm{streambuf.syn}}{\memglodesc{(\ref {streambuf.syn})}} {\memgloref{}}|memjustarg}{1631} +\glossaryentry{streambuf.reqts@ {\memgloterm{streambuf.reqts}}{\memglodesc{(\ref {streambuf.reqts})}} {\memgloref{}}|memjustarg}{1631} +\glossaryentry{streambuf@ {\memgloterm{streambuf}}{\memglodesc{(\ref {streambuf})}} {\memgloref{}}|memjustarg}{1632} +\glossaryentry{streambuf.general@ {\memgloterm{streambuf.general}}{\memglodesc{(\ref {streambuf.general})}} {\memgloref{}}|memjustarg}{1632} +\glossaryentry{streambuf.cons@ {\memgloterm{streambuf.cons}}{\memglodesc{(\ref {streambuf.cons})}} {\memgloref{}}|memjustarg}{1633} +\glossaryentry{streambuf.members@ {\memgloterm{streambuf.members}}{\memglodesc{(\ref {streambuf.members})}} {\memgloref{}}|memjustarg}{1634} +\glossaryentry{streambuf.locales@ {\memgloterm{streambuf.locales}}{\memglodesc{(\ref {streambuf.locales})}} {\memgloref{}}|memjustarg}{1634} +\glossaryentry{streambuf.buffer@ {\memgloterm{streambuf.buffer}}{\memglodesc{(\ref {streambuf.buffer})}} {\memgloref{}}|memjustarg}{1634} +\glossaryentry{streambuf.pub.get@ {\memgloterm{streambuf.pub.get}}{\memglodesc{(\ref {streambuf.pub.get})}} {\memgloref{}}|memjustarg}{1634} +\glossaryentry{streambuf.pub.pback@ {\memgloterm{streambuf.pub.pback}}{\memglodesc{(\ref {streambuf.pub.pback})}} {\memgloref{}}|memjustarg}{1635} +\glossaryentry{streambuf.pub.put@ {\memgloterm{streambuf.pub.put}}{\memglodesc{(\ref {streambuf.pub.put})}} {\memgloref{}}|memjustarg}{1635} +\glossaryentry{streambuf.protected@ {\memgloterm{streambuf.protected}}{\memglodesc{(\ref {streambuf.protected})}} {\memgloref{}}|memjustarg}{1635} +\glossaryentry{streambuf.assign@ {\memgloterm{streambuf.assign}}{\memglodesc{(\ref {streambuf.assign})}} {\memgloref{}}|memjustarg}{1635} +\glossaryentry{streambuf.get.area@ {\memgloterm{streambuf.get.area}}{\memglodesc{(\ref {streambuf.get.area})}} {\memgloref{}}|memjustarg}{1636} +\glossaryentry{streambuf.put.area@ {\memgloterm{streambuf.put.area}}{\memglodesc{(\ref {streambuf.put.area})}} {\memgloref{}}|memjustarg}{1636} +\glossaryentry{streambuf.virtuals@ {\memgloterm{streambuf.virtuals}}{\memglodesc{(\ref {streambuf.virtuals})}} {\memgloref{}}|memjustarg}{1636} +\glossaryentry{streambuf.virt.locales@ {\memgloterm{streambuf.virt.locales}}{\memglodesc{(\ref {streambuf.virt.locales})}} {\memgloref{}}|memjustarg}{1636} +\glossaryentry{streambuf.virt.buffer@ {\memgloterm{streambuf.virt.buffer}}{\memglodesc{(\ref {streambuf.virt.buffer})}} {\memgloref{}}|memjustarg}{1636} +\glossaryentry{streambuf.virt.get@ {\memgloterm{streambuf.virt.get}}{\memglodesc{(\ref {streambuf.virt.get})}} {\memgloref{}}|memjustarg}{1637} +\glossaryentry{streambuf.virt.pback@ {\memgloterm{streambuf.virt.pback}}{\memglodesc{(\ref {streambuf.virt.pback})}} {\memgloref{}}|memjustarg}{1638} +\glossaryentry{streambuf.virt.put@ {\memgloterm{streambuf.virt.put}}{\memglodesc{(\ref {streambuf.virt.put})}} {\memgloref{}}|memjustarg}{1638} +\glossaryentry{iostream.format@ {\memgloterm{iostream.format}}{\memglodesc{(\ref {iostream.format})}} {\memgloref{}}|memjustarg}{1639} +\glossaryentry{istream.syn@ {\memgloterm{istream.syn}}{\memglodesc{(\ref {istream.syn})}} {\memgloref{}}|memjustarg}{1639} +\glossaryentry{ostream.syn@ {\memgloterm{ostream.syn}}{\memglodesc{(\ref {ostream.syn})}} {\memgloref{}}|memjustarg}{1639} +\glossaryentry{iomanip.syn@ {\memgloterm{iomanip.syn}}{\memglodesc{(\ref {iomanip.syn})}} {\memgloref{}}|memjustarg}{1640} +\glossaryentry{print.syn@ {\memgloterm{print.syn}}{\memglodesc{(\ref {print.syn})}} {\memgloref{}}|memjustarg}{1640} +\glossaryentry{input.streams@ {\memgloterm{input.streams}}{\memglodesc{(\ref {input.streams})}} {\memgloref{}}|memjustarg}{1641} +\glossaryentry{input.streams.general@ {\memgloterm{input.streams.general}}{\memglodesc{(\ref {input.streams.general})}} {\memgloref{}}|memjustarg}{1641} +\glossaryentry{istream@ {\memgloterm{istream}}{\memglodesc{(\ref {istream})}} {\memgloref{}}|memjustarg}{1641} +\glossaryentry{istream.general@ {\memgloterm{istream.general}}{\memglodesc{(\ref {istream.general})}} {\memgloref{}}|memjustarg}{1641} +\glossaryentry{istream.cons@ {\memgloterm{istream.cons}}{\memglodesc{(\ref {istream.cons})}} {\memgloref{}}|memjustarg}{1642} +\glossaryentry{istream.assign@ {\memgloterm{istream.assign}}{\memglodesc{(\ref {istream.assign})}} {\memgloref{}}|memjustarg}{1643} +\glossaryentry{istream.sentry@ {\memgloterm{istream.sentry}}{\memglodesc{(\ref {istream.sentry})}} {\memgloref{}}|memjustarg}{1643} +\glossaryentry{istream.formatted@ {\memgloterm{istream.formatted}}{\memglodesc{(\ref {istream.formatted})}} {\memgloref{}}|memjustarg}{1644} +\glossaryentry{istream.formatted.reqmts@ {\memgloterm{istream.formatted.reqmts}}{\memglodesc{(\ref {istream.formatted.reqmts})}} {\memgloref{}}|memjustarg}{1644} +\glossaryentry{istream.formatted.arithmetic@ {\memgloterm{istream.formatted.arithmetic}}{\memglodesc{(\ref {istream.formatted.arithmetic})}} {\memgloref{}}|memjustarg}{1644} +\glossaryentry{istream.extractors@ {\memgloterm{istream.extractors}}{\memglodesc{(\ref {istream.extractors})}} {\memgloref{}}|memjustarg}{1645} +\glossaryentry{istream.unformatted@ {\memgloterm{istream.unformatted}}{\memglodesc{(\ref {istream.unformatted})}} {\memgloref{}}|memjustarg}{1646} +\glossaryentry{istream.manip@ {\memgloterm{istream.manip}}{\memglodesc{(\ref {istream.manip})}} {\memgloref{}}|memjustarg}{1650} +\glossaryentry{istream.rvalue@ {\memgloterm{istream.rvalue}}{\memglodesc{(\ref {istream.rvalue})}} {\memgloref{}}|memjustarg}{1651} +\glossaryentry{iostreamclass@ {\memgloterm{iostreamclass}}{\memglodesc{(\ref {iostreamclass})}} {\memgloref{}}|memjustarg}{1651} +\glossaryentry{iostreamclass.general@ {\memgloterm{iostreamclass.general}}{\memglodesc{(\ref {iostreamclass.general})}} {\memgloref{}}|memjustarg}{1651} +\glossaryentry{iostream.cons@ {\memgloterm{iostream.cons}}{\memglodesc{(\ref {iostream.cons})}} {\memgloref{}}|memjustarg}{1651} +\glossaryentry{iostream.dest@ {\memgloterm{iostream.dest}}{\memglodesc{(\ref {iostream.dest})}} {\memgloref{}}|memjustarg}{1651} +\glossaryentry{iostream.assign@ {\memgloterm{iostream.assign}}{\memglodesc{(\ref {iostream.assign})}} {\memgloref{}}|memjustarg}{1652} +\glossaryentry{output.streams@ {\memgloterm{output.streams}}{\memglodesc{(\ref {output.streams})}} {\memgloref{}}|memjustarg}{1652} +\glossaryentry{output.streams.general@ {\memgloterm{output.streams.general}}{\memglodesc{(\ref {output.streams.general})}} {\memgloref{}}|memjustarg}{1652} +\glossaryentry{ostream@ {\memgloterm{ostream}}{\memglodesc{(\ref {ostream})}} {\memgloref{}}|memjustarg}{1652} +\glossaryentry{ostream.general@ {\memgloterm{ostream.general}}{\memglodesc{(\ref {ostream.general})}} {\memgloref{}}|memjustarg}{1652} +\glossaryentry{ostream.cons@ {\memgloterm{ostream.cons}}{\memglodesc{(\ref {ostream.cons})}} {\memgloref{}}|memjustarg}{1654} +\glossaryentry{ostream.assign@ {\memgloterm{ostream.assign}}{\memglodesc{(\ref {ostream.assign})}} {\memgloref{}}|memjustarg}{1654} +\glossaryentry{ostream.sentry@ {\memgloterm{ostream.sentry}}{\memglodesc{(\ref {ostream.sentry})}} {\memgloref{}}|memjustarg}{1654} +\glossaryentry{ostream.seeks@ {\memgloterm{ostream.seeks}}{\memglodesc{(\ref {ostream.seeks})}} {\memgloref{}}|memjustarg}{1655} +\glossaryentry{ostream.formatted@ {\memgloterm{ostream.formatted}}{\memglodesc{(\ref {ostream.formatted})}} {\memgloref{}}|memjustarg}{1655} +\glossaryentry{ostream.formatted.reqmts@ {\memgloterm{ostream.formatted.reqmts}}{\memglodesc{(\ref {ostream.formatted.reqmts})}} {\memgloref{}}|memjustarg}{1655} +\glossaryentry{ostream.inserters.arithmetic@ {\memgloterm{ostream.inserters.arithmetic}}{\memglodesc{(\ref {ostream.inserters.arithmetic})}} {\memgloref{}}|memjustarg}{1656} +\glossaryentry{ostream.inserters@ {\memgloterm{ostream.inserters}}{\memglodesc{(\ref {ostream.inserters})}} {\memgloref{}}|memjustarg}{1657} +\glossaryentry{ostream.inserters.character@ {\memgloterm{ostream.inserters.character}}{\memglodesc{(\ref {ostream.inserters.character})}} {\memgloref{}}|memjustarg}{1658} +\glossaryentry{ostream.formatted.print@ {\memgloterm{ostream.formatted.print}}{\memglodesc{(\ref {ostream.formatted.print})}} {\memgloref{}}|memjustarg}{1659} +\glossaryentry{ostream.unformatted@ {\memgloterm{ostream.unformatted}}{\memglodesc{(\ref {ostream.unformatted})}} {\memgloref{}}|memjustarg}{1659} +\glossaryentry{ostream.manip@ {\memgloterm{ostream.manip}}{\memglodesc{(\ref {ostream.manip})}} {\memgloref{}}|memjustarg}{1660} +\glossaryentry{ostream.rvalue@ {\memgloterm{ostream.rvalue}}{\memglodesc{(\ref {ostream.rvalue})}} {\memgloref{}}|memjustarg}{1660} +\glossaryentry{std.manip@ {\memgloterm{std.manip}}{\memglodesc{(\ref {std.manip})}} {\memgloref{}}|memjustarg}{1661} +\glossaryentry{ext.manip@ {\memgloterm{ext.manip}}{\memglodesc{(\ref {ext.manip})}} {\memgloref{}}|memjustarg}{1662} +\glossaryentry{quoted.manip@ {\memgloterm{quoted.manip}}{\memglodesc{(\ref {quoted.manip})}} {\memgloref{}}|memjustarg}{1664} +\glossaryentry{print.fun@ {\memgloterm{print.fun}}{\memglodesc{(\ref {print.fun})}} {\memgloref{}}|memjustarg}{1665} +\glossaryentry{string.streams@ {\memgloterm{string.streams}}{\memglodesc{(\ref {string.streams})}} {\memgloref{}}|memjustarg}{1666} +\glossaryentry{sstream.syn@ {\memgloterm{sstream.syn}}{\memglodesc{(\ref {sstream.syn})}} {\memgloref{}}|memjustarg}{1666} +\glossaryentry{stringbuf@ {\memgloterm{stringbuf}}{\memglodesc{(\ref {stringbuf})}} {\memgloref{}}|memjustarg}{1667} +\glossaryentry{stringbuf.general@ {\memgloterm{stringbuf.general}}{\memglodesc{(\ref {stringbuf.general})}} {\memgloref{}}|memjustarg}{1667} +\glossaryentry{stringbuf.cons@ {\memgloterm{stringbuf.cons}}{\memglodesc{(\ref {stringbuf.cons})}} {\memgloref{}}|memjustarg}{1668} +\glossaryentry{stringbuf.assign@ {\memgloterm{stringbuf.assign}}{\memglodesc{(\ref {stringbuf.assign})}} {\memgloref{}}|memjustarg}{1669} +\glossaryentry{stringbuf.members@ {\memgloterm{stringbuf.members}}{\memglodesc{(\ref {stringbuf.members})}} {\memgloref{}}|memjustarg}{1670} +\glossaryentry{stringbuf.virtuals@ {\memgloterm{stringbuf.virtuals}}{\memglodesc{(\ref {stringbuf.virtuals})}} {\memgloref{}}|memjustarg}{1671} +\glossaryentry{istringstream@ {\memgloterm{istringstream}}{\memglodesc{(\ref {istringstream})}} {\memgloref{}}|memjustarg}{1672} +\glossaryentry{istringstream.general@ {\memgloterm{istringstream.general}}{\memglodesc{(\ref {istringstream.general})}} {\memgloref{}}|memjustarg}{1672} +\glossaryentry{istringstream.cons@ {\memgloterm{istringstream.cons}}{\memglodesc{(\ref {istringstream.cons})}} {\memgloref{}}|memjustarg}{1674} +\glossaryentry{istringstream.swap@ {\memgloterm{istringstream.swap}}{\memglodesc{(\ref {istringstream.swap})}} {\memgloref{}}|memjustarg}{1674} +\glossaryentry{istringstream.members@ {\memgloterm{istringstream.members}}{\memglodesc{(\ref {istringstream.members})}} {\memgloref{}}|memjustarg}{1674} +\glossaryentry{ostringstream@ {\memgloterm{ostringstream}}{\memglodesc{(\ref {ostringstream})}} {\memgloref{}}|memjustarg}{1675} +\glossaryentry{ostringstream.general@ {\memgloterm{ostringstream.general}}{\memglodesc{(\ref {ostringstream.general})}} {\memgloref{}}|memjustarg}{1675} +\glossaryentry{ostringstream.cons@ {\memgloterm{ostringstream.cons}}{\memglodesc{(\ref {ostringstream.cons})}} {\memgloref{}}|memjustarg}{1676} +\glossaryentry{ostringstream.swap@ {\memgloterm{ostringstream.swap}}{\memglodesc{(\ref {ostringstream.swap})}} {\memgloref{}}|memjustarg}{1677} +\glossaryentry{ostringstream.members@ {\memgloterm{ostringstream.members}}{\memglodesc{(\ref {ostringstream.members})}} {\memgloref{}}|memjustarg}{1677} +\glossaryentry{stringstream@ {\memgloterm{stringstream}}{\memglodesc{(\ref {stringstream})}} {\memgloref{}}|memjustarg}{1677} +\glossaryentry{stringstream.general@ {\memgloterm{stringstream.general}}{\memglodesc{(\ref {stringstream.general})}} {\memgloref{}}|memjustarg}{1677} +\glossaryentry{stringstream.cons@ {\memgloterm{stringstream.cons}}{\memglodesc{(\ref {stringstream.cons})}} {\memgloref{}}|memjustarg}{1679} +\glossaryentry{stringstream.swap@ {\memgloterm{stringstream.swap}}{\memglodesc{(\ref {stringstream.swap})}} {\memgloref{}}|memjustarg}{1679} +\glossaryentry{stringstream.members@ {\memgloterm{stringstream.members}}{\memglodesc{(\ref {stringstream.members})}} {\memgloref{}}|memjustarg}{1679} +\glossaryentry{span.streams@ {\memgloterm{span.streams}}{\memglodesc{(\ref {span.streams})}} {\memgloref{}}|memjustarg}{1680} +\glossaryentry{span.streams.overview@ {\memgloterm{span.streams.overview}}{\memglodesc{(\ref {span.streams.overview})}} {\memgloref{}}|memjustarg}{1680} +\glossaryentry{spanstream.syn@ {\memgloterm{spanstream.syn}}{\memglodesc{(\ref {spanstream.syn})}} {\memgloref{}}|memjustarg}{1680} +\glossaryentry{spanbuf@ {\memgloterm{spanbuf}}{\memglodesc{(\ref {spanbuf})}} {\memgloref{}}|memjustarg}{1681} +\glossaryentry{spanbuf.general@ {\memgloterm{spanbuf.general}}{\memglodesc{(\ref {spanbuf.general})}} {\memgloref{}}|memjustarg}{1681} +\glossaryentry{spanbuf.cons@ {\memgloterm{spanbuf.cons}}{\memglodesc{(\ref {spanbuf.cons})}} {\memgloref{}}|memjustarg}{1682} +\glossaryentry{spanbuf.assign@ {\memgloterm{spanbuf.assign}}{\memglodesc{(\ref {spanbuf.assign})}} {\memgloref{}}|memjustarg}{1682} +\glossaryentry{spanbuf.members@ {\memgloterm{spanbuf.members}}{\memglodesc{(\ref {spanbuf.members})}} {\memgloref{}}|memjustarg}{1682} +\glossaryentry{spanbuf.virtuals@ {\memgloterm{spanbuf.virtuals}}{\memglodesc{(\ref {spanbuf.virtuals})}} {\memgloref{}}|memjustarg}{1683} +\glossaryentry{ispanstream@ {\memgloterm{ispanstream}}{\memglodesc{(\ref {ispanstream})}} {\memgloref{}}|memjustarg}{1683} +\glossaryentry{ispanstream.general@ {\memgloterm{ispanstream.general}}{\memglodesc{(\ref {ispanstream.general})}} {\memgloref{}}|memjustarg}{1683} +\glossaryentry{ispanstream.cons@ {\memgloterm{ispanstream.cons}}{\memglodesc{(\ref {ispanstream.cons})}} {\memgloref{}}|memjustarg}{1684} +\glossaryentry{ispanstream.swap@ {\memgloterm{ispanstream.swap}}{\memglodesc{(\ref {ispanstream.swap})}} {\memgloref{}}|memjustarg}{1684} +\glossaryentry{ispanstream.members@ {\memgloterm{ispanstream.members}}{\memglodesc{(\ref {ispanstream.members})}} {\memgloref{}}|memjustarg}{1684} +\glossaryentry{ospanstream@ {\memgloterm{ospanstream}}{\memglodesc{(\ref {ospanstream})}} {\memgloref{}}|memjustarg}{1685} +\glossaryentry{ospanstream.general@ {\memgloterm{ospanstream.general}}{\memglodesc{(\ref {ospanstream.general})}} {\memgloref{}}|memjustarg}{1685} +\glossaryentry{ospanstream.cons@ {\memgloterm{ospanstream.cons}}{\memglodesc{(\ref {ospanstream.cons})}} {\memgloref{}}|memjustarg}{1685} +\glossaryentry{ospanstream.swap@ {\memgloterm{ospanstream.swap}}{\memglodesc{(\ref {ospanstream.swap})}} {\memgloref{}}|memjustarg}{1686} +\glossaryentry{ospanstream.members@ {\memgloterm{ospanstream.members}}{\memglodesc{(\ref {ospanstream.members})}} {\memgloref{}}|memjustarg}{1686} +\glossaryentry{spanstream@ {\memgloterm{spanstream}}{\memglodesc{(\ref {spanstream})}} {\memgloref{}}|memjustarg}{1686} +\glossaryentry{spanstream.general@ {\memgloterm{spanstream.general}}{\memglodesc{(\ref {spanstream.general})}} {\memgloref{}}|memjustarg}{1686} +\glossaryentry{spanstream.cons@ {\memgloterm{spanstream.cons}}{\memglodesc{(\ref {spanstream.cons})}} {\memgloref{}}|memjustarg}{1687} +\glossaryentry{spanstream.swap@ {\memgloterm{spanstream.swap}}{\memglodesc{(\ref {spanstream.swap})}} {\memgloref{}}|memjustarg}{1687} +\glossaryentry{spanstream.members@ {\memgloterm{spanstream.members}}{\memglodesc{(\ref {spanstream.members})}} {\memgloref{}}|memjustarg}{1687} +\glossaryentry{file.streams@ {\memgloterm{file.streams}}{\memglodesc{(\ref {file.streams})}} {\memgloref{}}|memjustarg}{1687} +\glossaryentry{fstream.syn@ {\memgloterm{fstream.syn}}{\memglodesc{(\ref {fstream.syn})}} {\memgloref{}}|memjustarg}{1687} +\glossaryentry{filebuf@ {\memgloterm{filebuf}}{\memglodesc{(\ref {filebuf})}} {\memgloref{}}|memjustarg}{1688} +\glossaryentry{filebuf.general@ {\memgloterm{filebuf.general}}{\memglodesc{(\ref {filebuf.general})}} {\memgloref{}}|memjustarg}{1688} +\glossaryentry{filebuf.cons@ {\memgloterm{filebuf.cons}}{\memglodesc{(\ref {filebuf.cons})}} {\memgloref{}}|memjustarg}{1689} +\glossaryentry{filebuf.assign@ {\memgloterm{filebuf.assign}}{\memglodesc{(\ref {filebuf.assign})}} {\memgloref{}}|memjustarg}{1690} +\glossaryentry{filebuf.members@ {\memgloterm{filebuf.members}}{\memglodesc{(\ref {filebuf.members})}} {\memgloref{}}|memjustarg}{1690} +\glossaryentry{filebuf.virtuals@ {\memgloterm{filebuf.virtuals}}{\memglodesc{(\ref {filebuf.virtuals})}} {\memgloref{}}|memjustarg}{1691} +\glossaryentry{ifstream@ {\memgloterm{ifstream}}{\memglodesc{(\ref {ifstream})}} {\memgloref{}}|memjustarg}{1693} +\glossaryentry{ifstream.general@ {\memgloterm{ifstream.general}}{\memglodesc{(\ref {ifstream.general})}} {\memgloref{}}|memjustarg}{1693} +\glossaryentry{ifstream.cons@ {\memgloterm{ifstream.cons}}{\memglodesc{(\ref {ifstream.cons})}} {\memgloref{}}|memjustarg}{1694} +\glossaryentry{ifstream.swap@ {\memgloterm{ifstream.swap}}{\memglodesc{(\ref {ifstream.swap})}} {\memgloref{}}|memjustarg}{1695} +\glossaryentry{ifstream.members@ {\memgloterm{ifstream.members}}{\memglodesc{(\ref {ifstream.members})}} {\memgloref{}}|memjustarg}{1695} +\glossaryentry{ofstream@ {\memgloterm{ofstream}}{\memglodesc{(\ref {ofstream})}} {\memgloref{}}|memjustarg}{1695} +\glossaryentry{ofstream.general@ {\memgloterm{ofstream.general}}{\memglodesc{(\ref {ofstream.general})}} {\memgloref{}}|memjustarg}{1695} +\glossaryentry{ofstream.cons@ {\memgloterm{ofstream.cons}}{\memglodesc{(\ref {ofstream.cons})}} {\memgloref{}}|memjustarg}{1696} +\glossaryentry{ofstream.swap@ {\memgloterm{ofstream.swap}}{\memglodesc{(\ref {ofstream.swap})}} {\memgloref{}}|memjustarg}{1697} +\glossaryentry{ofstream.members@ {\memgloterm{ofstream.members}}{\memglodesc{(\ref {ofstream.members})}} {\memgloref{}}|memjustarg}{1697} +\glossaryentry{fstream@ {\memgloterm{fstream}}{\memglodesc{(\ref {fstream})}} {\memgloref{}}|memjustarg}{1697} +\glossaryentry{fstream.general@ {\memgloterm{fstream.general}}{\memglodesc{(\ref {fstream.general})}} {\memgloref{}}|memjustarg}{1697} +\glossaryentry{fstream.cons@ {\memgloterm{fstream.cons}}{\memglodesc{(\ref {fstream.cons})}} {\memgloref{}}|memjustarg}{1698} +\glossaryentry{fstream.swap@ {\memgloterm{fstream.swap}}{\memglodesc{(\ref {fstream.swap})}} {\memgloref{}}|memjustarg}{1699} +\glossaryentry{fstream.members@ {\memgloterm{fstream.members}}{\memglodesc{(\ref {fstream.members})}} {\memgloref{}}|memjustarg}{1699} +\glossaryentry{syncstream@ {\memgloterm{syncstream}}{\memglodesc{(\ref {syncstream})}} {\memgloref{}}|memjustarg}{1699} +\glossaryentry{syncstream.syn@ {\memgloterm{syncstream.syn}}{\memglodesc{(\ref {syncstream.syn})}} {\memgloref{}}|memjustarg}{1699} +\glossaryentry{syncstream.syncbuf@ {\memgloterm{syncstream.syncbuf}}{\memglodesc{(\ref {syncstream.syncbuf})}} {\memgloref{}}|memjustarg}{1700} +\glossaryentry{syncstream.syncbuf.overview@ {\memgloterm{syncstream.syncbuf.overview}}{\memglodesc{(\ref {syncstream.syncbuf.overview})}} {\memgloref{}}|memjustarg}{1700} +\glossaryentry{syncstream.syncbuf.cons@ {\memgloterm{syncstream.syncbuf.cons}}{\memglodesc{(\ref {syncstream.syncbuf.cons})}} {\memgloref{}}|memjustarg}{1700} +\glossaryentry{syncstream.syncbuf.assign@ {\memgloterm{syncstream.syncbuf.assign}}{\memglodesc{(\ref {syncstream.syncbuf.assign})}} {\memgloref{}}|memjustarg}{1701} +\glossaryentry{syncstream.syncbuf.members@ {\memgloterm{syncstream.syncbuf.members}}{\memglodesc{(\ref {syncstream.syncbuf.members})}} {\memgloref{}}|memjustarg}{1701} +\glossaryentry{syncstream.syncbuf.virtuals@ {\memgloterm{syncstream.syncbuf.virtuals}}{\memglodesc{(\ref {syncstream.syncbuf.virtuals})}} {\memgloref{}}|memjustarg}{1702} +\glossaryentry{syncstream.syncbuf.special@ {\memgloterm{syncstream.syncbuf.special}}{\memglodesc{(\ref {syncstream.syncbuf.special})}} {\memgloref{}}|memjustarg}{1702} +\glossaryentry{syncstream.osyncstream@ {\memgloterm{syncstream.osyncstream}}{\memglodesc{(\ref {syncstream.osyncstream})}} {\memgloref{}}|memjustarg}{1702} +\glossaryentry{syncstream.osyncstream.overview@ {\memgloterm{syncstream.osyncstream.overview}}{\memglodesc{(\ref {syncstream.osyncstream.overview})}} {\memgloref{}}|memjustarg}{1702} +\glossaryentry{syncstream.osyncstream.cons@ {\memgloterm{syncstream.osyncstream.cons}}{\memglodesc{(\ref {syncstream.osyncstream.cons})}} {\memgloref{}}|memjustarg}{1703} +\glossaryentry{syncstream.osyncstream.members@ {\memgloterm{syncstream.osyncstream.members}}{\memglodesc{(\ref {syncstream.osyncstream.members})}} {\memgloref{}}|memjustarg}{1703} +\glossaryentry{filesystems@ {\memgloterm{filesystems}}{\memglodesc{(\ref {filesystems})}} {\memgloref{}}|memjustarg}{1704} +\glossaryentry{fs.general@ {\memgloterm{fs.general}}{\memglodesc{(\ref {fs.general})}} {\memgloref{}}|memjustarg}{1704} +\glossaryentry{fs.conformance@ {\memgloterm{fs.conformance}}{\memglodesc{(\ref {fs.conformance})}} {\memgloref{}}|memjustarg}{1704} +\glossaryentry{fs.conformance.general@ {\memgloterm{fs.conformance.general}}{\memglodesc{(\ref {fs.conformance.general})}} {\memgloref{}}|memjustarg}{1704} +\glossaryentry{fs.conform.9945@ {\memgloterm{fs.conform.9945}}{\memglodesc{(\ref {fs.conform.9945})}} {\memgloref{}}|memjustarg}{1704} +\glossaryentry{fs.conform.os@ {\memgloterm{fs.conform.os}}{\memglodesc{(\ref {fs.conform.os})}} {\memgloref{}}|memjustarg}{1705} +\glossaryentry{fs.race.behavior@ {\memgloterm{fs.race.behavior}}{\memglodesc{(\ref {fs.race.behavior})}} {\memgloref{}}|memjustarg}{1705} +\glossaryentry{fs.req@ {\memgloterm{fs.req}}{\memglodesc{(\ref {fs.req})}} {\memgloref{}}|memjustarg}{1705} +\glossaryentry{fs.filesystem.syn@ {\memgloterm{fs.filesystem.syn}}{\memglodesc{(\ref {fs.filesystem.syn})}} {\memgloref{}}|memjustarg}{1705} +\glossaryentry{fs.err.report@ {\memgloterm{fs.err.report}}{\memglodesc{(\ref {fs.err.report})}} {\memgloref{}}|memjustarg}{1709} +\glossaryentry{fs.class.path@ {\memgloterm{fs.class.path}}{\memglodesc{(\ref {fs.class.path})}} {\memgloref{}}|memjustarg}{1709} +\glossaryentry{fs.class.path.general@ {\memgloterm{fs.class.path.general}}{\memglodesc{(\ref {fs.class.path.general})}} {\memgloref{}}|memjustarg}{1709} +\glossaryentry{fs.path.generic@ {\memgloterm{fs.path.generic}}{\memglodesc{(\ref {fs.path.generic})}} {\memgloref{}}|memjustarg}{1712} +\glossaryentry{fs.path.cvt@ {\memgloterm{fs.path.cvt}}{\memglodesc{(\ref {fs.path.cvt})}} {\memgloref{}}|memjustarg}{1714} +\glossaryentry{fs.path.fmt.cvt@ {\memgloterm{fs.path.fmt.cvt}}{\memglodesc{(\ref {fs.path.fmt.cvt})}} {\memgloref{}}|memjustarg}{1714} +\glossaryentry{fs.path.type.cvt@ {\memgloterm{fs.path.type.cvt}}{\memglodesc{(\ref {fs.path.type.cvt})}} {\memgloref{}}|memjustarg}{1714} +\glossaryentry{fs.path.req@ {\memgloterm{fs.path.req}}{\memglodesc{(\ref {fs.path.req})}} {\memgloref{}}|memjustarg}{1715} +\glossaryentry{fs.path.member@ {\memgloterm{fs.path.member}}{\memglodesc{(\ref {fs.path.member})}} {\memgloref{}}|memjustarg}{1715} +\glossaryentry{fs.path.construct@ {\memgloterm{fs.path.construct}}{\memglodesc{(\ref {fs.path.construct})}} {\memgloref{}}|memjustarg}{1715} +\glossaryentry{fs.path.assign@ {\memgloterm{fs.path.assign}}{\memglodesc{(\ref {fs.path.assign})}} {\memgloref{}}|memjustarg}{1716} +\glossaryentry{fs.path.append@ {\memgloterm{fs.path.append}}{\memglodesc{(\ref {fs.path.append})}} {\memgloref{}}|memjustarg}{1717} +\glossaryentry{fs.path.concat@ {\memgloterm{fs.path.concat}}{\memglodesc{(\ref {fs.path.concat})}} {\memgloref{}}|memjustarg}{1717} +\glossaryentry{fs.path.modifiers@ {\memgloterm{fs.path.modifiers}}{\memglodesc{(\ref {fs.path.modifiers})}} {\memgloref{}}|memjustarg}{1718} +\glossaryentry{fs.path.native.obs@ {\memgloterm{fs.path.native.obs}}{\memglodesc{(\ref {fs.path.native.obs})}} {\memgloref{}}|memjustarg}{1719} +\glossaryentry{fs.path.generic.obs@ {\memgloterm{fs.path.generic.obs}}{\memglodesc{(\ref {fs.path.generic.obs})}} {\memgloref{}}|memjustarg}{1719} +\glossaryentry{fs.path.compare@ {\memgloterm{fs.path.compare}}{\memglodesc{(\ref {fs.path.compare})}} {\memgloref{}}|memjustarg}{1720} +\glossaryentry{fs.path.decompose@ {\memgloterm{fs.path.decompose}}{\memglodesc{(\ref {fs.path.decompose})}} {\memgloref{}}|memjustarg}{1720} +\glossaryentry{fs.path.query@ {\memgloterm{fs.path.query}}{\memglodesc{(\ref {fs.path.query})}} {\memgloref{}}|memjustarg}{1721} +\glossaryentry{fs.path.gen@ {\memgloterm{fs.path.gen}}{\memglodesc{(\ref {fs.path.gen})}} {\memgloref{}}|memjustarg}{1722} +\glossaryentry{fs.path.itr@ {\memgloterm{fs.path.itr}}{\memglodesc{(\ref {fs.path.itr})}} {\memgloref{}}|memjustarg}{1723} +\glossaryentry{fs.path.io@ {\memgloterm{fs.path.io}}{\memglodesc{(\ref {fs.path.io})}} {\memgloref{}}|memjustarg}{1723} +\glossaryentry{fs.path.nonmember@ {\memgloterm{fs.path.nonmember}}{\memglodesc{(\ref {fs.path.nonmember})}} {\memgloref{}}|memjustarg}{1724} +\glossaryentry{fs.path.hash@ {\memgloterm{fs.path.hash}}{\memglodesc{(\ref {fs.path.hash})}} {\memgloref{}}|memjustarg}{1724} +\glossaryentry{fs.class.filesystem.error@ {\memgloterm{fs.class.filesystem.error}}{\memglodesc{(\ref {fs.class.filesystem.error})}} {\memgloref{}}|memjustarg}{1724} +\glossaryentry{fs.class.filesystem.error.general@ {\memgloterm{fs.class.filesystem.error.general}}{\memglodesc{(\ref {fs.class.filesystem.error.general})}} {\memgloref{}}|memjustarg}{1724} +\glossaryentry{fs.filesystem.error.members@ {\memgloterm{fs.filesystem.error.members}}{\memglodesc{(\ref {fs.filesystem.error.members})}} {\memgloref{}}|memjustarg}{1724} +\glossaryentry{fs.enum@ {\memgloterm{fs.enum}}{\memglodesc{(\ref {fs.enum})}} {\memgloref{}}|memjustarg}{1725} +\glossaryentry{fs.enum.path.format@ {\memgloterm{fs.enum.path.format}}{\memglodesc{(\ref {fs.enum.path.format})}} {\memgloref{}}|memjustarg}{1725} +\glossaryentry{fs.enum.file.type@ {\memgloterm{fs.enum.file.type}}{\memglodesc{(\ref {fs.enum.file.type})}} {\memgloref{}}|memjustarg}{1725} +\glossaryentry{fs.enum.copy.opts@ {\memgloterm{fs.enum.copy.opts}}{\memglodesc{(\ref {fs.enum.copy.opts})}} {\memgloref{}}|memjustarg}{1726} +\glossaryentry{fs.enum.perms@ {\memgloterm{fs.enum.perms}}{\memglodesc{(\ref {fs.enum.perms})}} {\memgloref{}}|memjustarg}{1727} +\glossaryentry{fs.enum.perm.opts@ {\memgloterm{fs.enum.perm.opts}}{\memglodesc{(\ref {fs.enum.perm.opts})}} {\memgloref{}}|memjustarg}{1727} +\glossaryentry{fs.enum.dir.opts@ {\memgloterm{fs.enum.dir.opts}}{\memglodesc{(\ref {fs.enum.dir.opts})}} {\memgloref{}}|memjustarg}{1727} +\glossaryentry{fs.class.file.status@ {\memgloterm{fs.class.file.status}}{\memglodesc{(\ref {fs.class.file.status})}} {\memgloref{}}|memjustarg}{1728} +\glossaryentry{fs.class.file.status.general@ {\memgloterm{fs.class.file.status.general}}{\memglodesc{(\ref {fs.class.file.status.general})}} {\memgloref{}}|memjustarg}{1728} +\glossaryentry{fs.file.status.cons@ {\memgloterm{fs.file.status.cons}}{\memglodesc{(\ref {fs.file.status.cons})}} {\memgloref{}}|memjustarg}{1728} +\glossaryentry{fs.file.status.obs@ {\memgloterm{fs.file.status.obs}}{\memglodesc{(\ref {fs.file.status.obs})}} {\memgloref{}}|memjustarg}{1728} +\glossaryentry{fs.file.status.mods@ {\memgloterm{fs.file.status.mods}}{\memglodesc{(\ref {fs.file.status.mods})}} {\memgloref{}}|memjustarg}{1728} +\glossaryentry{fs.class.directory.entry@ {\memgloterm{fs.class.directory.entry}}{\memglodesc{(\ref {fs.class.directory.entry})}} {\memgloref{}}|memjustarg}{1729} +\glossaryentry{fs.class.directory.entry.general@ {\memgloterm{fs.class.directory.entry.general}}{\memglodesc{(\ref {fs.class.directory.entry.general})}} {\memgloref{}}|memjustarg}{1729} +\glossaryentry{fs.dir.entry.cons@ {\memgloterm{fs.dir.entry.cons}}{\memglodesc{(\ref {fs.dir.entry.cons})}} {\memgloref{}}|memjustarg}{1730} +\glossaryentry{fs.dir.entry.mods@ {\memgloterm{fs.dir.entry.mods}}{\memglodesc{(\ref {fs.dir.entry.mods})}} {\memgloref{}}|memjustarg}{1730} +\glossaryentry{fs.dir.entry.obs@ {\memgloterm{fs.dir.entry.obs}}{\memglodesc{(\ref {fs.dir.entry.obs})}} {\memgloref{}}|memjustarg}{1731} +\glossaryentry{fs.dir.entry.io@ {\memgloterm{fs.dir.entry.io}}{\memglodesc{(\ref {fs.dir.entry.io})}} {\memgloref{}}|memjustarg}{1732} +\glossaryentry{fs.class.directory.iterator@ {\memgloterm{fs.class.directory.iterator}}{\memglodesc{(\ref {fs.class.directory.iterator})}} {\memgloref{}}|memjustarg}{1733} +\glossaryentry{fs.class.directory.iterator.general@ {\memgloterm{fs.class.directory.iterator.general}}{\memglodesc{(\ref {fs.class.directory.iterator.general})}} {\memgloref{}}|memjustarg}{1733} +\glossaryentry{fs.dir.itr.members@ {\memgloterm{fs.dir.itr.members}}{\memglodesc{(\ref {fs.dir.itr.members})}} {\memgloref{}}|memjustarg}{1734} +\glossaryentry{fs.dir.itr.nonmembers@ {\memgloterm{fs.dir.itr.nonmembers}}{\memglodesc{(\ref {fs.dir.itr.nonmembers})}} {\memgloref{}}|memjustarg}{1734} +\glossaryentry{fs.class.rec.dir.itr@ {\memgloterm{fs.class.rec.dir.itr}}{\memglodesc{(\ref {fs.class.rec.dir.itr})}} {\memgloref{}}|memjustarg}{1735} +\glossaryentry{fs.class.rec.dir.itr.general@ {\memgloterm{fs.class.rec.dir.itr.general}}{\memglodesc{(\ref {fs.class.rec.dir.itr.general})}} {\memgloref{}}|memjustarg}{1735} +\glossaryentry{fs.rec.dir.itr.members@ {\memgloterm{fs.rec.dir.itr.members}}{\memglodesc{(\ref {fs.rec.dir.itr.members})}} {\memgloref{}}|memjustarg}{1736} +\glossaryentry{fs.rec.dir.itr.nonmembers@ {\memgloterm{fs.rec.dir.itr.nonmembers}}{\memglodesc{(\ref {fs.rec.dir.itr.nonmembers})}} {\memgloref{}}|memjustarg}{1737} +\glossaryentry{fs.op.funcs@ {\memgloterm{fs.op.funcs}}{\memglodesc{(\ref {fs.op.funcs})}} {\memgloref{}}|memjustarg}{1737} +\glossaryentry{fs.op.funcs.general@ {\memgloterm{fs.op.funcs.general}}{\memglodesc{(\ref {fs.op.funcs.general})}} {\memgloref{}}|memjustarg}{1737} +\glossaryentry{fs.op.absolute@ {\memgloterm{fs.op.absolute}}{\memglodesc{(\ref {fs.op.absolute})}} {\memgloref{}}|memjustarg}{1737} +\glossaryentry{fs.op.canonical@ {\memgloterm{fs.op.canonical}}{\memglodesc{(\ref {fs.op.canonical})}} {\memgloref{}}|memjustarg}{1738} +\glossaryentry{fs.op.copy@ {\memgloterm{fs.op.copy}}{\memglodesc{(\ref {fs.op.copy})}} {\memgloref{}}|memjustarg}{1738} +\glossaryentry{fs.op.copy.file@ {\memgloterm{fs.op.copy.file}}{\memglodesc{(\ref {fs.op.copy.file})}} {\memgloref{}}|memjustarg}{1740} +\glossaryentry{fs.op.copy.symlink@ {\memgloterm{fs.op.copy.symlink}}{\memglodesc{(\ref {fs.op.copy.symlink})}} {\memgloref{}}|memjustarg}{1740} +\glossaryentry{fs.op.create.directories@ {\memgloterm{fs.op.create.directories}}{\memglodesc{(\ref {fs.op.create.directories})}} {\memgloref{}}|memjustarg}{1741} +\glossaryentry{fs.op.create.directory@ {\memgloterm{fs.op.create.directory}}{\memglodesc{(\ref {fs.op.create.directory})}} {\memgloref{}}|memjustarg}{1741} +\glossaryentry{fs.op.create.dir.symlk@ {\memgloterm{fs.op.create.dir.symlk}}{\memglodesc{(\ref {fs.op.create.dir.symlk})}} {\memgloref{}}|memjustarg}{1741} +\glossaryentry{fs.op.create.hard.lk@ {\memgloterm{fs.op.create.hard.lk}}{\memglodesc{(\ref {fs.op.create.hard.lk})}} {\memgloref{}}|memjustarg}{1742} +\glossaryentry{fs.op.create.symlink@ {\memgloterm{fs.op.create.symlink}}{\memglodesc{(\ref {fs.op.create.symlink})}} {\memgloref{}}|memjustarg}{1742} +\glossaryentry{fs.op.current.path@ {\memgloterm{fs.op.current.path}}{\memglodesc{(\ref {fs.op.current.path})}} {\memgloref{}}|memjustarg}{1742} +\glossaryentry{fs.op.equivalent@ {\memgloterm{fs.op.equivalent}}{\memglodesc{(\ref {fs.op.equivalent})}} {\memgloref{}}|memjustarg}{1742} +\glossaryentry{fs.op.exists@ {\memgloterm{fs.op.exists}}{\memglodesc{(\ref {fs.op.exists})}} {\memgloref{}}|memjustarg}{1743} +\glossaryentry{fs.op.file.size@ {\memgloterm{fs.op.file.size}}{\memglodesc{(\ref {fs.op.file.size})}} {\memgloref{}}|memjustarg}{1743} +\glossaryentry{fs.op.hard.lk.ct@ {\memgloterm{fs.op.hard.lk.ct}}{\memglodesc{(\ref {fs.op.hard.lk.ct})}} {\memgloref{}}|memjustarg}{1743} +\glossaryentry{fs.op.is.block.file@ {\memgloterm{fs.op.is.block.file}}{\memglodesc{(\ref {fs.op.is.block.file})}} {\memgloref{}}|memjustarg}{1743} +\glossaryentry{fs.op.is.char.file@ {\memgloterm{fs.op.is.char.file}}{\memglodesc{(\ref {fs.op.is.char.file})}} {\memgloref{}}|memjustarg}{1743} +\glossaryentry{fs.op.is.directory@ {\memgloterm{fs.op.is.directory}}{\memglodesc{(\ref {fs.op.is.directory})}} {\memgloref{}}|memjustarg}{1744} +\glossaryentry{fs.op.is.empty@ {\memgloterm{fs.op.is.empty}}{\memglodesc{(\ref {fs.op.is.empty})}} {\memgloref{}}|memjustarg}{1744} +\glossaryentry{fs.op.is.fifo@ {\memgloterm{fs.op.is.fifo}}{\memglodesc{(\ref {fs.op.is.fifo})}} {\memgloref{}}|memjustarg}{1744} +\glossaryentry{fs.op.is.other@ {\memgloterm{fs.op.is.other}}{\memglodesc{(\ref {fs.op.is.other})}} {\memgloref{}}|memjustarg}{1744} +\glossaryentry{fs.op.is.regular.file@ {\memgloterm{fs.op.is.regular.file}}{\memglodesc{(\ref {fs.op.is.regular.file})}} {\memgloref{}}|memjustarg}{1745} +\glossaryentry{fs.op.is.socket@ {\memgloterm{fs.op.is.socket}}{\memglodesc{(\ref {fs.op.is.socket})}} {\memgloref{}}|memjustarg}{1745} +\glossaryentry{fs.op.is.symlink@ {\memgloterm{fs.op.is.symlink}}{\memglodesc{(\ref {fs.op.is.symlink})}} {\memgloref{}}|memjustarg}{1745} +\glossaryentry{fs.op.last.write.time@ {\memgloterm{fs.op.last.write.time}}{\memglodesc{(\ref {fs.op.last.write.time})}} {\memgloref{}}|memjustarg}{1745} +\glossaryentry{fs.op.permissions@ {\memgloterm{fs.op.permissions}}{\memglodesc{(\ref {fs.op.permissions})}} {\memgloref{}}|memjustarg}{1746} +\glossaryentry{fs.op.proximate@ {\memgloterm{fs.op.proximate}}{\memglodesc{(\ref {fs.op.proximate})}} {\memgloref{}}|memjustarg}{1746} +\glossaryentry{fs.op.read.symlink@ {\memgloterm{fs.op.read.symlink}}{\memglodesc{(\ref {fs.op.read.symlink})}} {\memgloref{}}|memjustarg}{1746} +\glossaryentry{fs.op.relative@ {\memgloterm{fs.op.relative}}{\memglodesc{(\ref {fs.op.relative})}} {\memgloref{}}|memjustarg}{1746} +\glossaryentry{fs.op.remove@ {\memgloterm{fs.op.remove}}{\memglodesc{(\ref {fs.op.remove})}} {\memgloref{}}|memjustarg}{1747} +\glossaryentry{fs.op.remove.all@ {\memgloterm{fs.op.remove.all}}{\memglodesc{(\ref {fs.op.remove.all})}} {\memgloref{}}|memjustarg}{1747} +\glossaryentry{fs.op.rename@ {\memgloterm{fs.op.rename}}{\memglodesc{(\ref {fs.op.rename})}} {\memgloref{}}|memjustarg}{1747} +\glossaryentry{fs.op.resize.file@ {\memgloterm{fs.op.resize.file}}{\memglodesc{(\ref {fs.op.resize.file})}} {\memgloref{}}|memjustarg}{1747} +\glossaryentry{fs.op.space@ {\memgloterm{fs.op.space}}{\memglodesc{(\ref {fs.op.space})}} {\memgloref{}}|memjustarg}{1747} +\glossaryentry{fs.op.status@ {\memgloterm{fs.op.status}}{\memglodesc{(\ref {fs.op.status})}} {\memgloref{}}|memjustarg}{1748} +\glossaryentry{fs.op.status.known@ {\memgloterm{fs.op.status.known}}{\memglodesc{(\ref {fs.op.status.known})}} {\memgloref{}}|memjustarg}{1749} +\glossaryentry{fs.op.symlink.status@ {\memgloterm{fs.op.symlink.status}}{\memglodesc{(\ref {fs.op.symlink.status})}} {\memgloref{}}|memjustarg}{1749} +\glossaryentry{fs.op.temp.dir.path@ {\memgloterm{fs.op.temp.dir.path}}{\memglodesc{(\ref {fs.op.temp.dir.path})}} {\memgloref{}}|memjustarg}{1749} +\glossaryentry{fs.op.weakly.canonical@ {\memgloterm{fs.op.weakly.canonical}}{\memglodesc{(\ref {fs.op.weakly.canonical})}} {\memgloref{}}|memjustarg}{1749} +\glossaryentry{c.files@ {\memgloterm{c.files}}{\memglodesc{(\ref {c.files})}} {\memgloref{}}|memjustarg}{1750} +\glossaryentry{cstdio.syn@ {\memgloterm{cstdio.syn}}{\memglodesc{(\ref {cstdio.syn})}} {\memgloref{}}|memjustarg}{1750} +\glossaryentry{cinttypes.syn@ {\memgloterm{cinttypes.syn}}{\memglodesc{(\ref {cinttypes.syn})}} {\memgloref{}}|memjustarg}{1751} +\glossaryentry{re@ {\memgloterm{re}}{\memglodesc{(\ref {re})}} {\memgloref{}}|memjustarg}{1753} +\glossaryentry{re.general@ {\memgloterm{re.general}}{\memglodesc{(\ref {re.general})}} {\memgloref{}}|memjustarg}{1753} +\glossaryentry{re.req@ {\memgloterm{re.req}}{\memglodesc{(\ref {re.req})}} {\memgloref{}}|memjustarg}{1753} +\glossaryentry{re.syn@ {\memgloterm{re.syn}}{\memglodesc{(\ref {re.syn})}} {\memgloref{}}|memjustarg}{1755} +\glossaryentry{re.const@ {\memgloterm{re.const}}{\memglodesc{(\ref {re.const})}} {\memgloref{}}|memjustarg}{1759} +\glossaryentry{re.const.general@ {\memgloterm{re.const.general}}{\memglodesc{(\ref {re.const.general})}} {\memgloref{}}|memjustarg}{1759} +\glossaryentry{re.synopt@ {\memgloterm{re.synopt}}{\memglodesc{(\ref {re.synopt})}} {\memgloref{}}|memjustarg}{1759} +\glossaryentry{re.matchflag@ {\memgloterm{re.matchflag}}{\memglodesc{(\ref {re.matchflag})}} {\memgloref{}}|memjustarg}{1759} +\glossaryentry{re.err@ {\memgloterm{re.err}}{\memglodesc{(\ref {re.err})}} {\memgloref{}}|memjustarg}{1761} +\glossaryentry{re.badexp@ {\memgloterm{re.badexp}}{\memglodesc{(\ref {re.badexp})}} {\memgloref{}}|memjustarg}{1761} +\glossaryentry{re.traits@ {\memgloterm{re.traits}}{\memglodesc{(\ref {re.traits})}} {\memgloref{}}|memjustarg}{1762} +\glossaryentry{re.regex@ {\memgloterm{re.regex}}{\memglodesc{(\ref {re.regex})}} {\memgloref{}}|memjustarg}{1764} +\glossaryentry{re.regex.general@ {\memgloterm{re.regex.general}}{\memglodesc{(\ref {re.regex.general})}} {\memgloref{}}|memjustarg}{1764} +\glossaryentry{re.regex.construct@ {\memgloterm{re.regex.construct}}{\memglodesc{(\ref {re.regex.construct})}} {\memgloref{}}|memjustarg}{1766} +\glossaryentry{re.regex.assign@ {\memgloterm{re.regex.assign}}{\memglodesc{(\ref {re.regex.assign})}} {\memgloref{}}|memjustarg}{1767} +\glossaryentry{re.regex.operations@ {\memgloterm{re.regex.operations}}{\memglodesc{(\ref {re.regex.operations})}} {\memgloref{}}|memjustarg}{1768} +\glossaryentry{re.regex.locale@ {\memgloterm{re.regex.locale}}{\memglodesc{(\ref {re.regex.locale})}} {\memgloref{}}|memjustarg}{1768} +\glossaryentry{re.regex.swap@ {\memgloterm{re.regex.swap}}{\memglodesc{(\ref {re.regex.swap})}} {\memgloref{}}|memjustarg}{1768} +\glossaryentry{re.regex.nonmemb@ {\memgloterm{re.regex.nonmemb}}{\memglodesc{(\ref {re.regex.nonmemb})}} {\memgloref{}}|memjustarg}{1768} +\glossaryentry{re.submatch@ {\memgloterm{re.submatch}}{\memglodesc{(\ref {re.submatch})}} {\memgloref{}}|memjustarg}{1768} +\glossaryentry{re.submatch.general@ {\memgloterm{re.submatch.general}}{\memglodesc{(\ref {re.submatch.general})}} {\memgloref{}}|memjustarg}{1768} +\glossaryentry{re.submatch.members@ {\memgloterm{re.submatch.members}}{\memglodesc{(\ref {re.submatch.members})}} {\memgloref{}}|memjustarg}{1769} +\glossaryentry{re.submatch.op@ {\memgloterm{re.submatch.op}}{\memglodesc{(\ref {re.submatch.op})}} {\memgloref{}}|memjustarg}{1769} +\glossaryentry{re.results@ {\memgloterm{re.results}}{\memglodesc{(\ref {re.results})}} {\memgloref{}}|memjustarg}{1770} +\glossaryentry{re.results.general@ {\memgloterm{re.results.general}}{\memglodesc{(\ref {re.results.general})}} {\memgloref{}}|memjustarg}{1770} +\glossaryentry{re.results.const@ {\memgloterm{re.results.const}}{\memglodesc{(\ref {re.results.const})}} {\memgloref{}}|memjustarg}{1772} +\glossaryentry{re.results.state@ {\memgloterm{re.results.state}}{\memglodesc{(\ref {re.results.state})}} {\memgloref{}}|memjustarg}{1772} +\glossaryentry{re.results.size@ {\memgloterm{re.results.size}}{\memglodesc{(\ref {re.results.size})}} {\memgloref{}}|memjustarg}{1773} +\glossaryentry{re.results.acc@ {\memgloterm{re.results.acc}}{\memglodesc{(\ref {re.results.acc})}} {\memgloref{}}|memjustarg}{1773} +\glossaryentry{re.results.form@ {\memgloterm{re.results.form}}{\memglodesc{(\ref {re.results.form})}} {\memgloref{}}|memjustarg}{1774} +\glossaryentry{re.results.all@ {\memgloterm{re.results.all}}{\memglodesc{(\ref {re.results.all})}} {\memgloref{}}|memjustarg}{1775} +\glossaryentry{re.results.swap@ {\memgloterm{re.results.swap}}{\memglodesc{(\ref {re.results.swap})}} {\memgloref{}}|memjustarg}{1775} +\glossaryentry{re.results.nonmember@ {\memgloterm{re.results.nonmember}}{\memglodesc{(\ref {re.results.nonmember})}} {\memgloref{}}|memjustarg}{1775} +\glossaryentry{re.alg@ {\memgloterm{re.alg}}{\memglodesc{(\ref {re.alg})}} {\memgloref{}}|memjustarg}{1775} +\glossaryentry{re.except@ {\memgloterm{re.except}}{\memglodesc{(\ref {re.except})}} {\memgloref{}}|memjustarg}{1775} +\glossaryentry{re.alg.match@ {\memgloterm{re.alg.match}}{\memglodesc{(\ref {re.alg.match})}} {\memgloref{}}|memjustarg}{1775} +\glossaryentry{re.alg.search@ {\memgloterm{re.alg.search}}{\memglodesc{(\ref {re.alg.search})}} {\memgloref{}}|memjustarg}{1777} +\glossaryentry{re.alg.replace@ {\memgloterm{re.alg.replace}}{\memglodesc{(\ref {re.alg.replace})}} {\memgloref{}}|memjustarg}{1778} +\glossaryentry{re.iter@ {\memgloterm{re.iter}}{\memglodesc{(\ref {re.iter})}} {\memgloref{}}|memjustarg}{1779} +\glossaryentry{re.regiter@ {\memgloterm{re.regiter}}{\memglodesc{(\ref {re.regiter})}} {\memgloref{}}|memjustarg}{1779} +\glossaryentry{re.regiter.general@ {\memgloterm{re.regiter.general}}{\memglodesc{(\ref {re.regiter.general})}} {\memgloref{}}|memjustarg}{1779} +\glossaryentry{re.regiter.cnstr@ {\memgloterm{re.regiter.cnstr}}{\memglodesc{(\ref {re.regiter.cnstr})}} {\memgloref{}}|memjustarg}{1780} +\glossaryentry{re.regiter.comp@ {\memgloterm{re.regiter.comp}}{\memglodesc{(\ref {re.regiter.comp})}} {\memgloref{}}|memjustarg}{1780} +\glossaryentry{re.regiter.deref@ {\memgloterm{re.regiter.deref}}{\memglodesc{(\ref {re.regiter.deref})}} {\memgloref{}}|memjustarg}{1781} +\glossaryentry{re.regiter.incr@ {\memgloterm{re.regiter.incr}}{\memglodesc{(\ref {re.regiter.incr})}} {\memgloref{}}|memjustarg}{1781} +\glossaryentry{re.tokiter@ {\memgloterm{re.tokiter}}{\memglodesc{(\ref {re.tokiter})}} {\memgloref{}}|memjustarg}{1781} +\glossaryentry{re.tokiter.general@ {\memgloterm{re.tokiter.general}}{\memglodesc{(\ref {re.tokiter.general})}} {\memgloref{}}|memjustarg}{1781} +\glossaryentry{re.tokiter.cnstr@ {\memgloterm{re.tokiter.cnstr}}{\memglodesc{(\ref {re.tokiter.cnstr})}} {\memgloref{}}|memjustarg}{1783} +\glossaryentry{re.tokiter.comp@ {\memgloterm{re.tokiter.comp}}{\memglodesc{(\ref {re.tokiter.comp})}} {\memgloref{}}|memjustarg}{1784} +\glossaryentry{re.tokiter.deref@ {\memgloterm{re.tokiter.deref}}{\memglodesc{(\ref {re.tokiter.deref})}} {\memgloref{}}|memjustarg}{1784} +\glossaryentry{re.tokiter.incr@ {\memgloterm{re.tokiter.incr}}{\memglodesc{(\ref {re.tokiter.incr})}} {\memgloref{}}|memjustarg}{1784} +\glossaryentry{re.grammar@ {\memgloterm{re.grammar}}{\memglodesc{(\ref {re.grammar})}} {\memgloref{}}|memjustarg}{1785} +\glossaryentry{thread@ {\memgloterm{thread}}{\memglodesc{(\ref {thread})}} {\memgloref{}}|memjustarg}{1787} +\glossaryentry{thread.general@ {\memgloterm{thread.general}}{\memglodesc{(\ref {thread.general})}} {\memgloref{}}|memjustarg}{1787} +\glossaryentry{thread.req@ {\memgloterm{thread.req}}{\memglodesc{(\ref {thread.req})}} {\memgloref{}}|memjustarg}{1787} +\glossaryentry{thread.req.paramname@ {\memgloterm{thread.req.paramname}}{\memglodesc{(\ref {thread.req.paramname})}} {\memgloref{}}|memjustarg}{1787} +\glossaryentry{thread.req.exception@ {\memgloterm{thread.req.exception}}{\memglodesc{(\ref {thread.req.exception})}} {\memgloref{}}|memjustarg}{1787} +\glossaryentry{thread.req.native@ {\memgloterm{thread.req.native}}{\memglodesc{(\ref {thread.req.native})}} {\memgloref{}}|memjustarg}{1787} +\glossaryentry{thread.req.timing@ {\memgloterm{thread.req.timing}}{\memglodesc{(\ref {thread.req.timing})}} {\memgloref{}}|memjustarg}{1787} +\glossaryentry{thread.req.lockable@ {\memgloterm{thread.req.lockable}}{\memglodesc{(\ref {thread.req.lockable})}} {\memgloref{}}|memjustarg}{1788} +\glossaryentry{thread.req.lockable.general@ {\memgloterm{thread.req.lockable.general}}{\memglodesc{(\ref {thread.req.lockable.general})}} {\memgloref{}}|memjustarg}{1788} +\glossaryentry{thread.req.lockable.basic@ {\memgloterm{thread.req.lockable.basic}}{\memglodesc{(\ref {thread.req.lockable.basic})}} {\memgloref{}}|memjustarg}{1789} +\glossaryentry{thread.req.lockable.req@ {\memgloterm{thread.req.lockable.req}}{\memglodesc{(\ref {thread.req.lockable.req})}} {\memgloref{}}|memjustarg}{1789} +\glossaryentry{thread.req.lockable.timed@ {\memgloterm{thread.req.lockable.timed}}{\memglodesc{(\ref {thread.req.lockable.timed})}} {\memgloref{}}|memjustarg}{1789} +\glossaryentry{thread.req.lockable.shared@ {\memgloterm{thread.req.lockable.shared}}{\memglodesc{(\ref {thread.req.lockable.shared})}} {\memgloref{}}|memjustarg}{1790} +\glossaryentry{thread.req.lockable.shared.timed@ {\memgloterm{thread.req.lockable.shared.timed}}{\memglodesc{(\ref {thread.req.lockable.shared.timed})}} {\memgloref{}}|memjustarg}{1790} +\glossaryentry{thread.stoptoken@ {\memgloterm{thread.stoptoken}}{\memglodesc{(\ref {thread.stoptoken})}} {\memgloref{}}|memjustarg}{1790} +\glossaryentry{thread.stoptoken.intro@ {\memgloterm{thread.stoptoken.intro}}{\memglodesc{(\ref {thread.stoptoken.intro})}} {\memgloref{}}|memjustarg}{1790} +\glossaryentry{thread.stoptoken.syn@ {\memgloterm{thread.stoptoken.syn}}{\memglodesc{(\ref {thread.stoptoken.syn})}} {\memgloref{}}|memjustarg}{1791} +\glossaryentry{stoptoken@ {\memgloterm{stoptoken}}{\memglodesc{(\ref {stoptoken})}} {\memgloref{}}|memjustarg}{1791} +\glossaryentry{stoptoken.general@ {\memgloterm{stoptoken.general}}{\memglodesc{(\ref {stoptoken.general})}} {\memgloref{}}|memjustarg}{1791} +\glossaryentry{stoptoken.cons@ {\memgloterm{stoptoken.cons}}{\memglodesc{(\ref {stoptoken.cons})}} {\memgloref{}}|memjustarg}{1791} +\glossaryentry{stoptoken.mem@ {\memgloterm{stoptoken.mem}}{\memglodesc{(\ref {stoptoken.mem})}} {\memgloref{}}|memjustarg}{1792} +\glossaryentry{stoptoken.nonmembers@ {\memgloterm{stoptoken.nonmembers}}{\memglodesc{(\ref {stoptoken.nonmembers})}} {\memgloref{}}|memjustarg}{1792} +\glossaryentry{stopsource@ {\memgloterm{stopsource}}{\memglodesc{(\ref {stopsource})}} {\memgloref{}}|memjustarg}{1792} +\glossaryentry{stopsource.general@ {\memgloterm{stopsource.general}}{\memglodesc{(\ref {stopsource.general})}} {\memgloref{}}|memjustarg}{1792} +\glossaryentry{stopsource.cons@ {\memgloterm{stopsource.cons}}{\memglodesc{(\ref {stopsource.cons})}} {\memgloref{}}|memjustarg}{1793} +\glossaryentry{stopsource.mem@ {\memgloterm{stopsource.mem}}{\memglodesc{(\ref {stopsource.mem})}} {\memgloref{}}|memjustarg}{1794} +\glossaryentry{stopsource.nonmembers@ {\memgloterm{stopsource.nonmembers}}{\memglodesc{(\ref {stopsource.nonmembers})}} {\memgloref{}}|memjustarg}{1794} +\glossaryentry{stopcallback@ {\memgloterm{stopcallback}}{\memglodesc{(\ref {stopcallback})}} {\memgloref{}}|memjustarg}{1794} +\glossaryentry{stopcallback.general@ {\memgloterm{stopcallback.general}}{\memglodesc{(\ref {stopcallback.general})}} {\memgloref{}}|memjustarg}{1794} +\glossaryentry{stopcallback.cons@ {\memgloterm{stopcallback.cons}}{\memglodesc{(\ref {stopcallback.cons})}} {\memgloref{}}|memjustarg}{1795} +\glossaryentry{thread.threads@ {\memgloterm{thread.threads}}{\memglodesc{(\ref {thread.threads})}} {\memgloref{}}|memjustarg}{1795} +\glossaryentry{thread.threads.general@ {\memgloterm{thread.threads.general}}{\memglodesc{(\ref {thread.threads.general})}} {\memgloref{}}|memjustarg}{1795} +\glossaryentry{thread.syn@ {\memgloterm{thread.syn}}{\memglodesc{(\ref {thread.syn})}} {\memgloref{}}|memjustarg}{1795} +\glossaryentry{thread.thread.class@ {\memgloterm{thread.thread.class}}{\memglodesc{(\ref {thread.thread.class})}} {\memgloref{}}|memjustarg}{1796} +\glossaryentry{thread.thread.class.general@ {\memgloterm{thread.thread.class.general}}{\memglodesc{(\ref {thread.thread.class.general})}} {\memgloref{}}|memjustarg}{1796} +\glossaryentry{thread.thread.id@ {\memgloterm{thread.thread.id}}{\memglodesc{(\ref {thread.thread.id})}} {\memgloref{}}|memjustarg}{1796} +\glossaryentry{thread.thread.constr@ {\memgloterm{thread.thread.constr}}{\memglodesc{(\ref {thread.thread.constr})}} {\memgloref{}}|memjustarg}{1797} +\glossaryentry{thread.thread.destr@ {\memgloterm{thread.thread.destr}}{\memglodesc{(\ref {thread.thread.destr})}} {\memgloref{}}|memjustarg}{1798} +\glossaryentry{thread.thread.assign@ {\memgloterm{thread.thread.assign}}{\memglodesc{(\ref {thread.thread.assign})}} {\memgloref{}}|memjustarg}{1798} +\glossaryentry{thread.thread.member@ {\memgloterm{thread.thread.member}}{\memglodesc{(\ref {thread.thread.member})}} {\memgloref{}}|memjustarg}{1798} +\glossaryentry{thread.thread.static@ {\memgloterm{thread.thread.static}}{\memglodesc{(\ref {thread.thread.static})}} {\memgloref{}}|memjustarg}{1799} +\glossaryentry{thread.thread.algorithm@ {\memgloterm{thread.thread.algorithm}}{\memglodesc{(\ref {thread.thread.algorithm})}} {\memgloref{}}|memjustarg}{1799} +\glossaryentry{thread.jthread.class@ {\memgloterm{thread.jthread.class}}{\memglodesc{(\ref {thread.jthread.class})}} {\memgloref{}}|memjustarg}{1799} +\glossaryentry{thread.jthread.class.general@ {\memgloterm{thread.jthread.class.general}}{\memglodesc{(\ref {thread.jthread.class.general})}} {\memgloref{}}|memjustarg}{1799} +\glossaryentry{thread.jthread.cons@ {\memgloterm{thread.jthread.cons}}{\memglodesc{(\ref {thread.jthread.cons})}} {\memgloref{}}|memjustarg}{1800} +\glossaryentry{thread.jthread.mem@ {\memgloterm{thread.jthread.mem}}{\memglodesc{(\ref {thread.jthread.mem})}} {\memgloref{}}|memjustarg}{1801} +\glossaryentry{thread.jthread.stop@ {\memgloterm{thread.jthread.stop}}{\memglodesc{(\ref {thread.jthread.stop})}} {\memgloref{}}|memjustarg}{1802} +\glossaryentry{thread.jthread.special@ {\memgloterm{thread.jthread.special}}{\memglodesc{(\ref {thread.jthread.special})}} {\memgloref{}}|memjustarg}{1802} +\glossaryentry{thread.jthread.static@ {\memgloterm{thread.jthread.static}}{\memglodesc{(\ref {thread.jthread.static})}} {\memgloref{}}|memjustarg}{1802} +\glossaryentry{thread.thread.this@ {\memgloterm{thread.thread.this}}{\memglodesc{(\ref {thread.thread.this})}} {\memgloref{}}|memjustarg}{1802} +\glossaryentry{atomics@ {\memgloterm{atomics}}{\memglodesc{(\ref {atomics})}} {\memgloref{}}|memjustarg}{1803} +\glossaryentry{atomics.general@ {\memgloterm{atomics.general}}{\memglodesc{(\ref {atomics.general})}} {\memgloref{}}|memjustarg}{1803} +\glossaryentry{atomics.syn@ {\memgloterm{atomics.syn}}{\memglodesc{(\ref {atomics.syn})}} {\memgloref{}}|memjustarg}{1803} +\glossaryentry{atomics.alias@ {\memgloterm{atomics.alias}}{\memglodesc{(\ref {atomics.alias})}} {\memgloref{}}|memjustarg}{1807} +\glossaryentry{atomics.order@ {\memgloterm{atomics.order}}{\memglodesc{(\ref {atomics.order})}} {\memgloref{}}|memjustarg}{1807} +\glossaryentry{atomics.lockfree@ {\memgloterm{atomics.lockfree}}{\memglodesc{(\ref {atomics.lockfree})}} {\memgloref{}}|memjustarg}{1809} +\glossaryentry{atomics.wait@ {\memgloterm{atomics.wait}}{\memglodesc{(\ref {atomics.wait})}} {\memgloref{}}|memjustarg}{1809} +\glossaryentry{atomics.ref.generic@ {\memgloterm{atomics.ref.generic}}{\memglodesc{(\ref {atomics.ref.generic})}} {\memgloref{}}|memjustarg}{1810} +\glossaryentry{atomics.ref.generic.general@ {\memgloterm{atomics.ref.generic.general}}{\memglodesc{(\ref {atomics.ref.generic.general})}} {\memgloref{}}|memjustarg}{1810} +\glossaryentry{atomics.ref.ops@ {\memgloterm{atomics.ref.ops}}{\memglodesc{(\ref {atomics.ref.ops})}} {\memgloref{}}|memjustarg}{1811} +\glossaryentry{atomics.ref.int@ {\memgloterm{atomics.ref.int}}{\memglodesc{(\ref {atomics.ref.int})}} {\memgloref{}}|memjustarg}{1813} +\glossaryentry{atomics.ref.float@ {\memgloterm{atomics.ref.float}}{\memglodesc{(\ref {atomics.ref.float})}} {\memgloref{}}|memjustarg}{1814} +\glossaryentry{atomics.ref.pointer@ {\memgloterm{atomics.ref.pointer}}{\memglodesc{(\ref {atomics.ref.pointer})}} {\memgloref{}}|memjustarg}{1815} +\glossaryentry{atomics.ref.memop@ {\memgloterm{atomics.ref.memop}}{\memglodesc{(\ref {atomics.ref.memop})}} {\memgloref{}}|memjustarg}{1816} +\glossaryentry{atomics.types.generic@ {\memgloterm{atomics.types.generic}}{\memglodesc{(\ref {atomics.types.generic})}} {\memgloref{}}|memjustarg}{1816} +\glossaryentry{atomics.types.generic.general@ {\memgloterm{atomics.types.generic.general}}{\memglodesc{(\ref {atomics.types.generic.general})}} {\memgloref{}}|memjustarg}{1816} +\glossaryentry{atomics.types.operations@ {\memgloterm{atomics.types.operations}}{\memglodesc{(\ref {atomics.types.operations})}} {\memgloref{}}|memjustarg}{1817} +\glossaryentry{atomics.types.int@ {\memgloterm{atomics.types.int}}{\memglodesc{(\ref {atomics.types.int})}} {\memgloref{}}|memjustarg}{1821} +\glossaryentry{atomics.types.float@ {\memgloterm{atomics.types.float}}{\memglodesc{(\ref {atomics.types.float})}} {\memgloref{}}|memjustarg}{1823} +\glossaryentry{atomics.types.pointer@ {\memgloterm{atomics.types.pointer}}{\memglodesc{(\ref {atomics.types.pointer})}} {\memgloref{}}|memjustarg}{1825} +\glossaryentry{atomics.types.memop@ {\memgloterm{atomics.types.memop}}{\memglodesc{(\ref {atomics.types.memop})}} {\memgloref{}}|memjustarg}{1826} +\glossaryentry{util.smartptr.atomic@ {\memgloterm{util.smartptr.atomic}}{\memglodesc{(\ref {util.smartptr.atomic})}} {\memgloref{}}|memjustarg}{1827} +\glossaryentry{util.smartptr.atomic.general@ {\memgloterm{util.smartptr.atomic.general}}{\memglodesc{(\ref {util.smartptr.atomic.general})}} {\memgloref{}}|memjustarg}{1827} +\glossaryentry{util.smartptr.atomic.shared@ {\memgloterm{util.smartptr.atomic.shared}}{\memglodesc{(\ref {util.smartptr.atomic.shared})}} {\memgloref{}}|memjustarg}{1827} +\glossaryentry{util.smartptr.atomic.weak@ {\memgloterm{util.smartptr.atomic.weak}}{\memglodesc{(\ref {util.smartptr.atomic.weak})}} {\memgloref{}}|memjustarg}{1829} +\glossaryentry{atomics.nonmembers@ {\memgloterm{atomics.nonmembers}}{\memglodesc{(\ref {atomics.nonmembers})}} {\memgloref{}}|memjustarg}{1832} +\glossaryentry{atomics.flag@ {\memgloterm{atomics.flag}}{\memglodesc{(\ref {atomics.flag})}} {\memgloref{}}|memjustarg}{1832} +\glossaryentry{atomics.fences@ {\memgloterm{atomics.fences}}{\memglodesc{(\ref {atomics.fences})}} {\memgloref{}}|memjustarg}{1834} +\glossaryentry{stdatomic.h.syn@ {\memgloterm{stdatomic.h.syn}}{\memglodesc{(\ref {stdatomic.h.syn})}} {\memgloref{}}|memjustarg}{1834} +\glossaryentry{thread.mutex@ {\memgloterm{thread.mutex}}{\memglodesc{(\ref {thread.mutex})}} {\memgloref{}}|memjustarg}{1836} +\glossaryentry{thread.mutex.general@ {\memgloterm{thread.mutex.general}}{\memglodesc{(\ref {thread.mutex.general})}} {\memgloref{}}|memjustarg}{1836} +\glossaryentry{mutex.syn@ {\memgloterm{mutex.syn}}{\memglodesc{(\ref {mutex.syn})}} {\memgloref{}}|memjustarg}{1836} +\glossaryentry{shared.mutex.syn@ {\memgloterm{shared.mutex.syn}}{\memglodesc{(\ref {shared.mutex.syn})}} {\memgloref{}}|memjustarg}{1837} +\glossaryentry{thread.mutex.requirements@ {\memgloterm{thread.mutex.requirements}}{\memglodesc{(\ref {thread.mutex.requirements})}} {\memgloref{}}|memjustarg}{1837} +\glossaryentry{thread.mutex.requirements.general@ {\memgloterm{thread.mutex.requirements.general}}{\memglodesc{(\ref {thread.mutex.requirements.general})}} {\memgloref{}}|memjustarg}{1837} +\glossaryentry{thread.mutex.requirements.mutex@ {\memgloterm{thread.mutex.requirements.mutex}}{\memglodesc{(\ref {thread.mutex.requirements.mutex})}} {\memgloref{}}|memjustarg}{1837} +\glossaryentry{thread.mutex.requirements.mutex.general@ {\memgloterm{thread.mutex.requirements.mutex.general}}{\memglodesc{(\ref {thread.mutex.requirements.mutex.general})}} {\memgloref{}}|memjustarg}{1837} +\glossaryentry{thread.mutex.class@ {\memgloterm{thread.mutex.class}}{\memglodesc{(\ref {thread.mutex.class})}} {\memgloref{}}|memjustarg}{1838} +\glossaryentry{thread.mutex.recursive@ {\memgloterm{thread.mutex.recursive}}{\memglodesc{(\ref {thread.mutex.recursive})}} {\memgloref{}}|memjustarg}{1839} +\glossaryentry{thread.timedmutex.requirements@ {\memgloterm{thread.timedmutex.requirements}}{\memglodesc{(\ref {thread.timedmutex.requirements})}} {\memgloref{}}|memjustarg}{1839} +\glossaryentry{thread.timedmutex.requirements.general@ {\memgloterm{thread.timedmutex.requirements.general}}{\memglodesc{(\ref {thread.timedmutex.requirements.general})}} {\memgloref{}}|memjustarg}{1839} +\glossaryentry{thread.timedmutex.class@ {\memgloterm{thread.timedmutex.class}}{\memglodesc{(\ref {thread.timedmutex.class})}} {\memgloref{}}|memjustarg}{1840} +\glossaryentry{thread.timedmutex.recursive@ {\memgloterm{thread.timedmutex.recursive}}{\memglodesc{(\ref {thread.timedmutex.recursive})}} {\memgloref{}}|memjustarg}{1841} +\glossaryentry{thread.sharedmutex.requirements@ {\memgloterm{thread.sharedmutex.requirements}}{\memglodesc{(\ref {thread.sharedmutex.requirements})}} {\memgloref{}}|memjustarg}{1841} +\glossaryentry{thread.sharedmutex.requirements.general@ {\memgloterm{thread.sharedmutex.requirements.general}}{\memglodesc{(\ref {thread.sharedmutex.requirements.general})}} {\memgloref{}}|memjustarg}{1841} +\glossaryentry{thread.sharedmutex.class@ {\memgloterm{thread.sharedmutex.class}}{\memglodesc{(\ref {thread.sharedmutex.class})}} {\memgloref{}}|memjustarg}{1842} +\glossaryentry{thread.sharedtimedmutex.requirements@ {\memgloterm{thread.sharedtimedmutex.requirements}}{\memglodesc{(\ref {thread.sharedtimedmutex.requirements})}} {\memgloref{}}|memjustarg}{1843} +\glossaryentry{thread.sharedtimedmutex.requirements.general@ {\memgloterm{thread.sharedtimedmutex.requirements.general}}{\memglodesc{(\ref {thread.sharedtimedmutex.requirements.general})}} {\memgloref{}}|memjustarg}{1843} +\glossaryentry{thread.sharedtimedmutex.class@ {\memgloterm{thread.sharedtimedmutex.class}}{\memglodesc{(\ref {thread.sharedtimedmutex.class})}} {\memgloref{}}|memjustarg}{1844} +\glossaryentry{thread.lock@ {\memgloterm{thread.lock}}{\memglodesc{(\ref {thread.lock})}} {\memgloref{}}|memjustarg}{1844} +\glossaryentry{thread.lock.general@ {\memgloterm{thread.lock.general}}{\memglodesc{(\ref {thread.lock.general})}} {\memgloref{}}|memjustarg}{1844} +\glossaryentry{thread.lock.guard@ {\memgloterm{thread.lock.guard}}{\memglodesc{(\ref {thread.lock.guard})}} {\memgloref{}}|memjustarg}{1845} +\glossaryentry{thread.lock.scoped@ {\memgloterm{thread.lock.scoped}}{\memglodesc{(\ref {thread.lock.scoped})}} {\memgloref{}}|memjustarg}{1845} +\glossaryentry{thread.lock.unique@ {\memgloterm{thread.lock.unique}}{\memglodesc{(\ref {thread.lock.unique})}} {\memgloref{}}|memjustarg}{1846} +\glossaryentry{thread.lock.unique.general@ {\memgloterm{thread.lock.unique.general}}{\memglodesc{(\ref {thread.lock.unique.general})}} {\memgloref{}}|memjustarg}{1846} +\glossaryentry{thread.lock.unique.cons@ {\memgloterm{thread.lock.unique.cons}}{\memglodesc{(\ref {thread.lock.unique.cons})}} {\memgloref{}}|memjustarg}{1847} +\glossaryentry{thread.lock.unique.locking@ {\memgloterm{thread.lock.unique.locking}}{\memglodesc{(\ref {thread.lock.unique.locking})}} {\memgloref{}}|memjustarg}{1848} +\glossaryentry{thread.lock.unique.mod@ {\memgloterm{thread.lock.unique.mod}}{\memglodesc{(\ref {thread.lock.unique.mod})}} {\memgloref{}}|memjustarg}{1849} +\glossaryentry{thread.lock.unique.obs@ {\memgloterm{thread.lock.unique.obs}}{\memglodesc{(\ref {thread.lock.unique.obs})}} {\memgloref{}}|memjustarg}{1849} +\glossaryentry{thread.lock.shared@ {\memgloterm{thread.lock.shared}}{\memglodesc{(\ref {thread.lock.shared})}} {\memgloref{}}|memjustarg}{1849} +\glossaryentry{thread.lock.shared.general@ {\memgloterm{thread.lock.shared.general}}{\memglodesc{(\ref {thread.lock.shared.general})}} {\memgloref{}}|memjustarg}{1849} +\glossaryentry{thread.lock.shared.cons@ {\memgloterm{thread.lock.shared.cons}}{\memglodesc{(\ref {thread.lock.shared.cons})}} {\memgloref{}}|memjustarg}{1850} +\glossaryentry{thread.lock.shared.locking@ {\memgloterm{thread.lock.shared.locking}}{\memglodesc{(\ref {thread.lock.shared.locking})}} {\memgloref{}}|memjustarg}{1851} +\glossaryentry{thread.lock.shared.mod@ {\memgloterm{thread.lock.shared.mod}}{\memglodesc{(\ref {thread.lock.shared.mod})}} {\memgloref{}}|memjustarg}{1852} +\glossaryentry{thread.lock.shared.obs@ {\memgloterm{thread.lock.shared.obs}}{\memglodesc{(\ref {thread.lock.shared.obs})}} {\memgloref{}}|memjustarg}{1853} +\glossaryentry{thread.lock.algorithm@ {\memgloterm{thread.lock.algorithm}}{\memglodesc{(\ref {thread.lock.algorithm})}} {\memgloref{}}|memjustarg}{1853} +\glossaryentry{thread.once@ {\memgloterm{thread.once}}{\memglodesc{(\ref {thread.once})}} {\memgloref{}}|memjustarg}{1853} +\glossaryentry{thread.once.onceflag@ {\memgloterm{thread.once.onceflag}}{\memglodesc{(\ref {thread.once.onceflag})}} {\memgloref{}}|memjustarg}{1853} +\glossaryentry{thread.once.callonce@ {\memgloterm{thread.once.callonce}}{\memglodesc{(\ref {thread.once.callonce})}} {\memgloref{}}|memjustarg}{1854} +\glossaryentry{thread.condition@ {\memgloterm{thread.condition}}{\memglodesc{(\ref {thread.condition})}} {\memgloref{}}|memjustarg}{1854} +\glossaryentry{thread.condition.general@ {\memgloterm{thread.condition.general}}{\memglodesc{(\ref {thread.condition.general})}} {\memgloref{}}|memjustarg}{1854} +\glossaryentry{condition.variable.syn@ {\memgloterm{condition.variable.syn}}{\memglodesc{(\ref {condition.variable.syn})}} {\memgloref{}}|memjustarg}{1855} +\glossaryentry{thread.condition.nonmember@ {\memgloterm{thread.condition.nonmember}}{\memglodesc{(\ref {thread.condition.nonmember})}} {\memgloref{}}|memjustarg}{1855} +\glossaryentry{thread.condition.condvar@ {\memgloterm{thread.condition.condvar}}{\memglodesc{(\ref {thread.condition.condvar})}} {\memgloref{}}|memjustarg}{1855} +\glossaryentry{thread.condition.condvarany@ {\memgloterm{thread.condition.condvarany}}{\memglodesc{(\ref {thread.condition.condvarany})}} {\memgloref{}}|memjustarg}{1858} +\glossaryentry{thread.condition.condvarany.general@ {\memgloterm{thread.condition.condvarany.general}}{\memglodesc{(\ref {thread.condition.condvarany.general})}} {\memgloref{}}|memjustarg}{1858} +\glossaryentry{thread.condvarany.wait@ {\memgloterm{thread.condvarany.wait}}{\memglodesc{(\ref {thread.condvarany.wait})}} {\memgloref{}}|memjustarg}{1859} +\glossaryentry{thread.condvarany.intwait@ {\memgloterm{thread.condvarany.intwait}}{\memglodesc{(\ref {thread.condvarany.intwait})}} {\memgloref{}}|memjustarg}{1861} +\glossaryentry{thread.sema@ {\memgloterm{thread.sema}}{\memglodesc{(\ref {thread.sema})}} {\memgloref{}}|memjustarg}{1862} +\glossaryentry{thread.sema.general@ {\memgloterm{thread.sema.general}}{\memglodesc{(\ref {thread.sema.general})}} {\memgloref{}}|memjustarg}{1862} +\glossaryentry{semaphore.syn@ {\memgloterm{semaphore.syn}}{\memglodesc{(\ref {semaphore.syn})}} {\memgloref{}}|memjustarg}{1862} +\glossaryentry{thread.sema.cnt@ {\memgloterm{thread.sema.cnt}}{\memglodesc{(\ref {thread.sema.cnt})}} {\memgloref{}}|memjustarg}{1862} +\glossaryentry{thread.coord@ {\memgloterm{thread.coord}}{\memglodesc{(\ref {thread.coord})}} {\memgloref{}}|memjustarg}{1863} +\glossaryentry{thread.coord.general@ {\memgloterm{thread.coord.general}}{\memglodesc{(\ref {thread.coord.general})}} {\memgloref{}}|memjustarg}{1863} +\glossaryentry{thread.latch@ {\memgloterm{thread.latch}}{\memglodesc{(\ref {thread.latch})}} {\memgloref{}}|memjustarg}{1863} +\glossaryentry{thread.latch.general@ {\memgloterm{thread.latch.general}}{\memglodesc{(\ref {thread.latch.general})}} {\memgloref{}}|memjustarg}{1863} +\glossaryentry{latch.syn@ {\memgloterm{latch.syn}}{\memglodesc{(\ref {latch.syn})}} {\memgloref{}}|memjustarg}{1864} +\glossaryentry{thread.latch.class@ {\memgloterm{thread.latch.class}}{\memglodesc{(\ref {thread.latch.class})}} {\memgloref{}}|memjustarg}{1864} +\glossaryentry{thread.barrier@ {\memgloterm{thread.barrier}}{\memglodesc{(\ref {thread.barrier})}} {\memgloref{}}|memjustarg}{1865} +\glossaryentry{thread.barrier.general@ {\memgloterm{thread.barrier.general}}{\memglodesc{(\ref {thread.barrier.general})}} {\memgloref{}}|memjustarg}{1865} +\glossaryentry{barrier.syn@ {\memgloterm{barrier.syn}}{\memglodesc{(\ref {barrier.syn})}} {\memgloref{}}|memjustarg}{1865} +\glossaryentry{thread.barrier.class@ {\memgloterm{thread.barrier.class}}{\memglodesc{(\ref {thread.barrier.class})}} {\memgloref{}}|memjustarg}{1865} +\glossaryentry{futures@ {\memgloterm{futures}}{\memglodesc{(\ref {futures})}} {\memgloref{}}|memjustarg}{1867} +\glossaryentry{futures.overview@ {\memgloterm{futures.overview}}{\memglodesc{(\ref {futures.overview})}} {\memgloref{}}|memjustarg}{1867} +\glossaryentry{future.syn@ {\memgloterm{future.syn}}{\memglodesc{(\ref {future.syn})}} {\memgloref{}}|memjustarg}{1867} +\glossaryentry{futures.errors@ {\memgloterm{futures.errors}}{\memglodesc{(\ref {futures.errors})}} {\memgloref{}}|memjustarg}{1868} +\glossaryentry{futures.future.error@ {\memgloterm{futures.future.error}}{\memglodesc{(\ref {futures.future.error})}} {\memgloref{}}|memjustarg}{1868} +\glossaryentry{futures.state@ {\memgloterm{futures.state}}{\memglodesc{(\ref {futures.state})}} {\memgloref{}}|memjustarg}{1869} +\glossaryentry{futures.promise@ {\memgloterm{futures.promise}}{\memglodesc{(\ref {futures.promise})}} {\memgloref{}}|memjustarg}{1870} +\glossaryentry{futures.unique.future@ {\memgloterm{futures.unique.future}}{\memglodesc{(\ref {futures.unique.future})}} {\memgloref{}}|memjustarg}{1872} +\glossaryentry{futures.shared.future@ {\memgloterm{futures.shared.future}}{\memglodesc{(\ref {futures.shared.future})}} {\memgloref{}}|memjustarg}{1874} +\glossaryentry{futures.async@ {\memgloterm{futures.async}}{\memglodesc{(\ref {futures.async})}} {\memgloref{}}|memjustarg}{1877} +\glossaryentry{futures.task@ {\memgloterm{futures.task}}{\memglodesc{(\ref {futures.task})}} {\memgloref{}}|memjustarg}{1878} +\glossaryentry{futures.task.general@ {\memgloterm{futures.task.general}}{\memglodesc{(\ref {futures.task.general})}} {\memgloref{}}|memjustarg}{1878} +\glossaryentry{futures.task.members@ {\memgloterm{futures.task.members}}{\memglodesc{(\ref {futures.task.members})}} {\memgloref{}}|memjustarg}{1879} +\glossaryentry{futures.task.nonmembers@ {\memgloterm{futures.task.nonmembers}}{\memglodesc{(\ref {futures.task.nonmembers})}} {\memgloref{}}|memjustarg}{1880} +\glossaryentry{gram@ {\memgloterm{gram}}{\memglodesc{(\ref {gram})}} {\memgloref{}}|memjustarg}{1881} +\glossaryentry{gram.general@ {\memgloterm{gram.general}}{\memglodesc{(\ref {gram.general})}} {\memgloref{}}|memjustarg}{1881} +\glossaryentry{gram.key@ {\memgloterm{gram.key}}{\memglodesc{(\ref {gram.key})}} {\memgloref{}}|memjustarg}{1881} +\glossaryentry{gram.lex@ {\memgloterm{gram.lex}}{\memglodesc{(\ref {gram.lex})}} {\memgloref{}}|memjustarg}{1881} +\glossaryentry{gram.basic@ {\memgloterm{gram.basic}}{\memglodesc{(\ref {gram.basic})}} {\memgloref{}}|memjustarg}{1886} +\glossaryentry{gram.expr@ {\memgloterm{gram.expr}}{\memglodesc{(\ref {gram.expr})}} {\memgloref{}}|memjustarg}{1886} +\glossaryentry{gram.stmt@ {\memgloterm{gram.stmt}}{\memglodesc{(\ref {gram.stmt})}} {\memgloref{}}|memjustarg}{1890} +\glossaryentry{gram.dcl@ {\memgloterm{gram.dcl}}{\memglodesc{(\ref {gram.dcl})}} {\memgloref{}}|memjustarg}{1891} +\glossaryentry{gram.module@ {\memgloterm{gram.module}}{\memglodesc{(\ref {gram.module})}} {\memgloref{}}|memjustarg}{1897} +\glossaryentry{gram.class@ {\memgloterm{gram.class}}{\memglodesc{(\ref {gram.class})}} {\memgloref{}}|memjustarg}{1898} +\glossaryentry{gram.over@ {\memgloterm{gram.over}}{\memglodesc{(\ref {gram.over})}} {\memgloref{}}|memjustarg}{1899} +\glossaryentry{gram.temp@ {\memgloterm{gram.temp}}{\memglodesc{(\ref {gram.temp})}} {\memgloref{}}|memjustarg}{1899} +\glossaryentry{gram.except@ {\memgloterm{gram.except}}{\memglodesc{(\ref {gram.except})}} {\memgloref{}}|memjustarg}{1900} +\glossaryentry{gram.cpp@ {\memgloterm{gram.cpp}}{\memglodesc{(\ref {gram.cpp})}} {\memgloref{}}|memjustarg}{1901} +\glossaryentry{implimits@ {\memgloterm{implimits}}{\memglodesc{(\ref {implimits})}} {\memgloref{}}|memjustarg}{1903} +\glossaryentry{diff@ {\memgloterm{diff}}{\memglodesc{(\ref {diff})}} {\memgloref{}}|memjustarg}{1905} +\glossaryentry{diff.cpp20@ {\memgloterm{diff.cpp20}}{\memglodesc{(\ref {diff.cpp20})}} {\memgloref{}}|memjustarg}{1905} +\glossaryentry{diff.cpp20.general@ {\memgloterm{diff.cpp20.general}}{\memglodesc{(\ref {diff.cpp20.general})}} {\memgloref{}}|memjustarg}{1905} +\glossaryentry{diff.cpp20.lex@ {\memgloterm{diff.cpp20.lex}}{\memglodesc{(\ref {diff.cpp20.lex})}} {\memgloref{}}|memjustarg}{1905} +\glossaryentry{diff.cpp20.expr@ {\memgloterm{diff.cpp20.expr}}{\memglodesc{(\ref {diff.cpp20.expr})}} {\memgloref{}}|memjustarg}{1905} +\glossaryentry{diff.cpp20.stmt@ {\memgloterm{diff.cpp20.stmt}}{\memglodesc{(\ref {diff.cpp20.stmt})}} {\memgloref{}}|memjustarg}{1905} +\glossaryentry{diff.cpp20.dcl@ {\memgloterm{diff.cpp20.dcl}}{\memglodesc{(\ref {diff.cpp20.dcl})}} {\memgloref{}}|memjustarg}{1906} +\glossaryentry{diff.cpp20.temp@ {\memgloterm{diff.cpp20.temp}}{\memglodesc{(\ref {diff.cpp20.temp})}} {\memgloref{}}|memjustarg}{1906} +\glossaryentry{diff.cpp20.library@ {\memgloterm{diff.cpp20.library}}{\memglodesc{(\ref {diff.cpp20.library})}} {\memgloref{}}|memjustarg}{1906} +\glossaryentry{diff.cpp20.concepts@ {\memgloterm{diff.cpp20.concepts}}{\memglodesc{(\ref {diff.cpp20.concepts})}} {\memgloref{}}|memjustarg}{1906} +\glossaryentry{diff.cpp20.memory@ {\memgloterm{diff.cpp20.memory}}{\memglodesc{(\ref {diff.cpp20.memory})}} {\memgloref{}}|memjustarg}{1907} +\glossaryentry{diff.cpp20.utilities@ {\memgloterm{diff.cpp20.utilities}}{\memglodesc{(\ref {diff.cpp20.utilities})}} {\memgloref{}}|memjustarg}{1907} +\glossaryentry{diff.cpp20.strings@ {\memgloterm{diff.cpp20.strings}}{\memglodesc{(\ref {diff.cpp20.strings})}} {\memgloref{}}|memjustarg}{1907} +\glossaryentry{diff.cpp20.containers@ {\memgloterm{diff.cpp20.containers}}{\memglodesc{(\ref {diff.cpp20.containers})}} {\memgloref{}}|memjustarg}{1908} +\glossaryentry{diff.cpp20.thread@ {\memgloterm{diff.cpp20.thread}}{\memglodesc{(\ref {diff.cpp20.thread})}} {\memgloref{}}|memjustarg}{1908} +\glossaryentry{diff.cpp17@ {\memgloterm{diff.cpp17}}{\memglodesc{(\ref {diff.cpp17})}} {\memgloref{}}|memjustarg}{1908} +\glossaryentry{diff.cpp17.general@ {\memgloterm{diff.cpp17.general}}{\memglodesc{(\ref {diff.cpp17.general})}} {\memgloref{}}|memjustarg}{1908} +\glossaryentry{diff.cpp17.lex@ {\memgloterm{diff.cpp17.lex}}{\memglodesc{(\ref {diff.cpp17.lex})}} {\memgloref{}}|memjustarg}{1908} +\glossaryentry{diff.cpp17.basic@ {\memgloterm{diff.cpp17.basic}}{\memglodesc{(\ref {diff.cpp17.basic})}} {\memgloref{}}|memjustarg}{1910} +\glossaryentry{diff.cpp17.expr@ {\memgloterm{diff.cpp17.expr}}{\memglodesc{(\ref {diff.cpp17.expr})}} {\memgloref{}}|memjustarg}{1910} +\glossaryentry{diff.cpp17.dcl.dcl@ {\memgloterm{diff.cpp17.dcl.dcl}}{\memglodesc{(\ref {diff.cpp17.dcl.dcl})}} {\memgloref{}}|memjustarg}{1910} +\glossaryentry{diff.cpp17.class@ {\memgloterm{diff.cpp17.class}}{\memglodesc{(\ref {diff.cpp17.class})}} {\memgloref{}}|memjustarg}{1911} +\glossaryentry{diff.cpp17.over@ {\memgloterm{diff.cpp17.over}}{\memglodesc{(\ref {diff.cpp17.over})}} {\memgloref{}}|memjustarg}{1912} +\glossaryentry{diff.cpp17.temp@ {\memgloterm{diff.cpp17.temp}}{\memglodesc{(\ref {diff.cpp17.temp})}} {\memgloref{}}|memjustarg}{1913} +\glossaryentry{diff.cpp17.except@ {\memgloterm{diff.cpp17.except}}{\memglodesc{(\ref {diff.cpp17.except})}} {\memgloref{}}|memjustarg}{1913} +\glossaryentry{diff.cpp17.library@ {\memgloterm{diff.cpp17.library}}{\memglodesc{(\ref {diff.cpp17.library})}} {\memgloref{}}|memjustarg}{1913} +\glossaryentry{diff.cpp17.containers@ {\memgloterm{diff.cpp17.containers}}{\memglodesc{(\ref {diff.cpp17.containers})}} {\memgloref{}}|memjustarg}{1914} +\glossaryentry{diff.cpp17.iterators@ {\memgloterm{diff.cpp17.iterators}}{\memglodesc{(\ref {diff.cpp17.iterators})}} {\memgloref{}}|memjustarg}{1914} +\glossaryentry{diff.cpp17.alg.reqs@ {\memgloterm{diff.cpp17.alg.reqs}}{\memglodesc{(\ref {diff.cpp17.alg.reqs})}} {\memgloref{}}|memjustarg}{1914} +\glossaryentry{diff.cpp17.input.output@ {\memgloterm{diff.cpp17.input.output}}{\memglodesc{(\ref {diff.cpp17.input.output})}} {\memgloref{}}|memjustarg}{1914} +\glossaryentry{diff.cpp17.depr@ {\memgloterm{diff.cpp17.depr}}{\memglodesc{(\ref {diff.cpp17.depr})}} {\memgloref{}}|memjustarg}{1915} +\glossaryentry{diff.cpp14@ {\memgloterm{diff.cpp14}}{\memglodesc{(\ref {diff.cpp14})}} {\memgloref{}}|memjustarg}{1916} +\glossaryentry{diff.cpp14.general@ {\memgloterm{diff.cpp14.general}}{\memglodesc{(\ref {diff.cpp14.general})}} {\memgloref{}}|memjustarg}{1916} +\glossaryentry{diff.cpp14.lex@ {\memgloterm{diff.cpp14.lex}}{\memglodesc{(\ref {diff.cpp14.lex})}} {\memgloref{}}|memjustarg}{1916} +\glossaryentry{diff.cpp14.expr@ {\memgloterm{diff.cpp14.expr}}{\memglodesc{(\ref {diff.cpp14.expr})}} {\memgloref{}}|memjustarg}{1916} +\glossaryentry{diff.cpp14.dcl.dcl@ {\memgloterm{diff.cpp14.dcl.dcl}}{\memglodesc{(\ref {diff.cpp14.dcl.dcl})}} {\memgloref{}}|memjustarg}{1916} +\glossaryentry{diff.cpp14.class@ {\memgloterm{diff.cpp14.class}}{\memglodesc{(\ref {diff.cpp14.class})}} {\memgloref{}}|memjustarg}{1917} +\glossaryentry{diff.cpp14.temp@ {\memgloterm{diff.cpp14.temp}}{\memglodesc{(\ref {diff.cpp14.temp})}} {\memgloref{}}|memjustarg}{1917} +\glossaryentry{diff.cpp14.except@ {\memgloterm{diff.cpp14.except}}{\memglodesc{(\ref {diff.cpp14.except})}} {\memgloref{}}|memjustarg}{1918} +\glossaryentry{diff.cpp14.library@ {\memgloterm{diff.cpp14.library}}{\memglodesc{(\ref {diff.cpp14.library})}} {\memgloref{}}|memjustarg}{1918} +\glossaryentry{diff.cpp14.utilities@ {\memgloterm{diff.cpp14.utilities}}{\memglodesc{(\ref {diff.cpp14.utilities})}} {\memgloref{}}|memjustarg}{1918} +\glossaryentry{diff.cpp14.string@ {\memgloterm{diff.cpp14.string}}{\memglodesc{(\ref {diff.cpp14.string})}} {\memgloref{}}|memjustarg}{1918} +\glossaryentry{diff.cpp14.containers@ {\memgloterm{diff.cpp14.containers}}{\memglodesc{(\ref {diff.cpp14.containers})}} {\memgloref{}}|memjustarg}{1919} +\glossaryentry{diff.cpp14.depr@ {\memgloterm{diff.cpp14.depr}}{\memglodesc{(\ref {diff.cpp14.depr})}} {\memgloref{}}|memjustarg}{1919} +\glossaryentry{diff.cpp11@ {\memgloterm{diff.cpp11}}{\memglodesc{(\ref {diff.cpp11})}} {\memgloref{}}|memjustarg}{1919} +\glossaryentry{diff.cpp11.general@ {\memgloterm{diff.cpp11.general}}{\memglodesc{(\ref {diff.cpp11.general})}} {\memgloref{}}|memjustarg}{1919} +\glossaryentry{diff.cpp11.lex@ {\memgloterm{diff.cpp11.lex}}{\memglodesc{(\ref {diff.cpp11.lex})}} {\memgloref{}}|memjustarg}{1919} +\glossaryentry{diff.cpp11.basic@ {\memgloterm{diff.cpp11.basic}}{\memglodesc{(\ref {diff.cpp11.basic})}} {\memgloref{}}|memjustarg}{1920} +\glossaryentry{diff.cpp11.expr@ {\memgloterm{diff.cpp11.expr}}{\memglodesc{(\ref {diff.cpp11.expr})}} {\memgloref{}}|memjustarg}{1920} +\glossaryentry{diff.cpp11.dcl.dcl@ {\memgloterm{diff.cpp11.dcl.dcl}}{\memglodesc{(\ref {diff.cpp11.dcl.dcl})}} {\memgloref{}}|memjustarg}{1920} +\glossaryentry{diff.cpp11.library@ {\memgloterm{diff.cpp11.library}}{\memglodesc{(\ref {diff.cpp11.library})}} {\memgloref{}}|memjustarg}{1921} +\glossaryentry{diff.cpp11.input.output@ {\memgloterm{diff.cpp11.input.output}}{\memglodesc{(\ref {diff.cpp11.input.output})}} {\memgloref{}}|memjustarg}{1921} +\glossaryentry{diff.cpp03@ {\memgloterm{diff.cpp03}}{\memglodesc{(\ref {diff.cpp03})}} {\memgloref{}}|memjustarg}{1921} +\glossaryentry{diff.cpp03.general@ {\memgloterm{diff.cpp03.general}}{\memglodesc{(\ref {diff.cpp03.general})}} {\memgloref{}}|memjustarg}{1921} +\glossaryentry{diff.cpp03.lex@ {\memgloterm{diff.cpp03.lex}}{\memglodesc{(\ref {diff.cpp03.lex})}} {\memgloref{}}|memjustarg}{1921} +\glossaryentry{diff.cpp03.expr@ {\memgloterm{diff.cpp03.expr}}{\memglodesc{(\ref {diff.cpp03.expr})}} {\memgloref{}}|memjustarg}{1922} +\glossaryentry{diff.cpp03.dcl.dcl@ {\memgloterm{diff.cpp03.dcl.dcl}}{\memglodesc{(\ref {diff.cpp03.dcl.dcl})}} {\memgloref{}}|memjustarg}{1922} +\glossaryentry{diff.cpp03.class@ {\memgloterm{diff.cpp03.class}}{\memglodesc{(\ref {diff.cpp03.class})}} {\memgloref{}}|memjustarg}{1922} +\glossaryentry{diff.cpp03.temp@ {\memgloterm{diff.cpp03.temp}}{\memglodesc{(\ref {diff.cpp03.temp})}} {\memgloref{}}|memjustarg}{1923} +\glossaryentry{diff.cpp03.library@ {\memgloterm{diff.cpp03.library}}{\memglodesc{(\ref {diff.cpp03.library})}} {\memgloref{}}|memjustarg}{1923} +\glossaryentry{diff.cpp03.language.support@ {\memgloterm{diff.cpp03.language.support}}{\memglodesc{(\ref {diff.cpp03.language.support})}} {\memgloref{}}|memjustarg}{1924} +\glossaryentry{diff.cpp03.diagnostics@ {\memgloterm{diff.cpp03.diagnostics}}{\memglodesc{(\ref {diff.cpp03.diagnostics})}} {\memgloref{}}|memjustarg}{1924} +\glossaryentry{diff.cpp03.utilities@ {\memgloterm{diff.cpp03.utilities}}{\memglodesc{(\ref {diff.cpp03.utilities})}} {\memgloref{}}|memjustarg}{1924} +\glossaryentry{diff.cpp03.strings@ {\memgloterm{diff.cpp03.strings}}{\memglodesc{(\ref {diff.cpp03.strings})}} {\memgloref{}}|memjustarg}{1924} +\glossaryentry{diff.cpp03.containers@ {\memgloterm{diff.cpp03.containers}}{\memglodesc{(\ref {diff.cpp03.containers})}} {\memgloref{}}|memjustarg}{1924} +\glossaryentry{diff.cpp03.algorithms@ {\memgloterm{diff.cpp03.algorithms}}{\memglodesc{(\ref {diff.cpp03.algorithms})}} {\memgloref{}}|memjustarg}{1925} +\glossaryentry{diff.cpp03.numerics@ {\memgloterm{diff.cpp03.numerics}}{\memglodesc{(\ref {diff.cpp03.numerics})}} {\memgloref{}}|memjustarg}{1925} +\glossaryentry{diff.cpp03.locale@ {\memgloterm{diff.cpp03.locale}}{\memglodesc{(\ref {diff.cpp03.locale})}} {\memgloref{}}|memjustarg}{1925} +\glossaryentry{diff.cpp03.input.output@ {\memgloterm{diff.cpp03.input.output}}{\memglodesc{(\ref {diff.cpp03.input.output})}} {\memgloref{}}|memjustarg}{1926} +\glossaryentry{diff.iso@ {\memgloterm{diff.iso}}{\memglodesc{(\ref {diff.iso})}} {\memgloref{}}|memjustarg}{1926} +\glossaryentry{diff.iso.general@ {\memgloterm{diff.iso.general}}{\memglodesc{(\ref {diff.iso.general})}} {\memgloref{}}|memjustarg}{1926} +\glossaryentry{diff.lex@ {\memgloterm{diff.lex}}{\memglodesc{(\ref {diff.lex})}} {\memgloref{}}|memjustarg}{1926} +\glossaryentry{diff.basic@ {\memgloterm{diff.basic}}{\memglodesc{(\ref {diff.basic})}} {\memgloref{}}|memjustarg}{1927} +\glossaryentry{diff.expr@ {\memgloterm{diff.expr}}{\memglodesc{(\ref {diff.expr})}} {\memgloref{}}|memjustarg}{1928} +\glossaryentry{diff.stat@ {\memgloterm{diff.stat}}{\memglodesc{(\ref {diff.stat})}} {\memgloref{}}|memjustarg}{1929} +\glossaryentry{diff.dcl@ {\memgloterm{diff.dcl}}{\memglodesc{(\ref {diff.dcl})}} {\memgloref{}}|memjustarg}{1929} +\glossaryentry{diff.class@ {\memgloterm{diff.class}}{\memglodesc{(\ref {diff.class})}} {\memgloref{}}|memjustarg}{1932} +\glossaryentry{diff.cpp@ {\memgloterm{diff.cpp}}{\memglodesc{(\ref {diff.cpp})}} {\memgloref{}}|memjustarg}{1934} +\glossaryentry{diff.library@ {\memgloterm{diff.library}}{\memglodesc{(\ref {diff.library})}} {\memgloref{}}|memjustarg}{1934} +\glossaryentry{diff.library.general@ {\memgloterm{diff.library.general}}{\memglodesc{(\ref {diff.library.general})}} {\memgloref{}}|memjustarg}{1934} +\glossaryentry{diff.mods.to.headers@ {\memgloterm{diff.mods.to.headers}}{\memglodesc{(\ref {diff.mods.to.headers})}} {\memgloref{}}|memjustarg}{1934} +\glossaryentry{diff.mods.to.definitions@ {\memgloterm{diff.mods.to.definitions}}{\memglodesc{(\ref {diff.mods.to.definitions})}} {\memgloref{}}|memjustarg}{1934} +\glossaryentry{diff.char16@ {\memgloterm{diff.char16}}{\memglodesc{(\ref {diff.char16})}} {\memgloref{}}|memjustarg}{1934} +\glossaryentry{diff.wchar.t@ {\memgloterm{diff.wchar.t}}{\memglodesc{(\ref {diff.wchar.t})}} {\memgloref{}}|memjustarg}{1934} +\glossaryentry{diff.header.assert.h@ {\memgloterm{diff.header.assert.h}}{\memglodesc{(\ref {diff.header.assert.h})}} {\memgloref{}}|memjustarg}{1935} +\glossaryentry{diff.header.iso646.h@ {\memgloterm{diff.header.iso646.h}}{\memglodesc{(\ref {diff.header.iso646.h})}} {\memgloref{}}|memjustarg}{1935} +\glossaryentry{diff.header.stdalign.h@ {\memgloterm{diff.header.stdalign.h}}{\memglodesc{(\ref {diff.header.stdalign.h})}} {\memgloref{}}|memjustarg}{1935} +\glossaryentry{diff.header.stdbool.h@ {\memgloterm{diff.header.stdbool.h}}{\memglodesc{(\ref {diff.header.stdbool.h})}} {\memgloref{}}|memjustarg}{1935} +\glossaryentry{diff.null@ {\memgloterm{diff.null}}{\memglodesc{(\ref {diff.null})}} {\memgloref{}}|memjustarg}{1935} +\glossaryentry{diff.mods.to.declarations@ {\memgloterm{diff.mods.to.declarations}}{\memglodesc{(\ref {diff.mods.to.declarations})}} {\memgloref{}}|memjustarg}{1935} +\glossaryentry{diff.mods.to.behavior@ {\memgloterm{diff.mods.to.behavior}}{\memglodesc{(\ref {diff.mods.to.behavior})}} {\memgloref{}}|memjustarg}{1935} +\glossaryentry{diff.mods.to.behavior.general@ {\memgloterm{diff.mods.to.behavior.general}}{\memglodesc{(\ref {diff.mods.to.behavior.general})}} {\memgloref{}}|memjustarg}{1935} +\glossaryentry{diff.offsetof@ {\memgloterm{diff.offsetof}}{\memglodesc{(\ref {diff.offsetof})}} {\memgloref{}}|memjustarg}{1936} +\glossaryentry{diff.malloc@ {\memgloterm{diff.malloc}}{\memglodesc{(\ref {diff.malloc})}} {\memgloref{}}|memjustarg}{1936} +\glossaryentry{depr@ {\memgloterm{depr}}{\memglodesc{(\ref {depr})}} {\memgloref{}}|memjustarg}{1937} +\glossaryentry{depr.general@ {\memgloterm{depr.general}}{\memglodesc{(\ref {depr.general})}} {\memgloref{}}|memjustarg}{1937} +\glossaryentry{depr.arith.conv.enum@ {\memgloterm{depr.arith.conv.enum}}{\memglodesc{(\ref {depr.arith.conv.enum})}} {\memgloref{}}|memjustarg}{1937} +\glossaryentry{depr.capture.this@ {\memgloterm{depr.capture.this}}{\memglodesc{(\ref {depr.capture.this})}} {\memgloref{}}|memjustarg}{1937} +\glossaryentry{depr.array.comp@ {\memgloterm{depr.array.comp}}{\memglodesc{(\ref {depr.array.comp})}} {\memgloref{}}|memjustarg}{1937} +\glossaryentry{depr.volatile.type@ {\memgloterm{depr.volatile.type}}{\memglodesc{(\ref {depr.volatile.type})}} {\memgloref{}}|memjustarg}{1937} +\glossaryentry{depr.static.constexpr@ {\memgloterm{depr.static.constexpr}}{\memglodesc{(\ref {depr.static.constexpr})}} {\memgloref{}}|memjustarg}{1938} +\glossaryentry{depr.local@ {\memgloterm{depr.local}}{\memglodesc{(\ref {depr.local})}} {\memgloref{}}|memjustarg}{1938} +\glossaryentry{depr.impldec@ {\memgloterm{depr.impldec}}{\memglodesc{(\ref {depr.impldec})}} {\memgloref{}}|memjustarg}{1939} +\glossaryentry{depr.lit@ {\memgloterm{depr.lit}}{\memglodesc{(\ref {depr.lit})}} {\memgloref{}}|memjustarg}{1939} +\glossaryentry{depr.template.template@ {\memgloterm{depr.template.template}}{\memglodesc{(\ref {depr.template.template})}} {\memgloref{}}|memjustarg}{1939} +\glossaryentry{depr.res.on.required@ {\memgloterm{depr.res.on.required}}{\memglodesc{(\ref {depr.res.on.required})}} {\memgloref{}}|memjustarg}{1939} +\glossaryentry{depr.numeric.limits.has.denorm@ {\memgloterm{depr.numeric.limits.has.denorm}}{\memglodesc{(\ref {depr.numeric.limits.has.denorm})}} {\memgloref{}}|memjustarg}{1939} +\glossaryentry{depr.c.macros@ {\memgloterm{depr.c.macros}}{\memglodesc{(\ref {depr.c.macros})}} {\memgloref{}}|memjustarg}{1939} +\glossaryentry{depr.relops@ {\memgloterm{depr.relops}}{\memglodesc{(\ref {depr.relops})}} {\memgloref{}}|memjustarg}{1939} +\glossaryentry{depr.str.strstreams@ {\memgloterm{depr.str.strstreams}}{\memglodesc{(\ref {depr.str.strstreams})}} {\memgloref{}}|memjustarg}{1940} +\glossaryentry{depr.strstream.syn@ {\memgloterm{depr.strstream.syn}}{\memglodesc{(\ref {depr.strstream.syn})}} {\memgloref{}}|memjustarg}{1940} +\glossaryentry{depr.strstreambuf@ {\memgloterm{depr.strstreambuf}}{\memglodesc{(\ref {depr.strstreambuf})}} {\memgloref{}}|memjustarg}{1940} +\glossaryentry{depr.strstreambuf.general@ {\memgloterm{depr.strstreambuf.general}}{\memglodesc{(\ref {depr.strstreambuf.general})}} {\memgloref{}}|memjustarg}{1940} +\glossaryentry{depr.strstreambuf.cons@ {\memgloterm{depr.strstreambuf.cons}}{\memglodesc{(\ref {depr.strstreambuf.cons})}} {\memgloref{}}|memjustarg}{1941} +\glossaryentry{depr.strstreambuf.members@ {\memgloterm{depr.strstreambuf.members}}{\memglodesc{(\ref {depr.strstreambuf.members})}} {\memgloref{}}|memjustarg}{1942} +\glossaryentry{depr.strstreambuf.virtuals@ {\memgloterm{depr.strstreambuf.virtuals}}{\memglodesc{(\ref {depr.strstreambuf.virtuals})}} {\memgloref{}}|memjustarg}{1943} +\glossaryentry{depr.istrstream@ {\memgloterm{depr.istrstream}}{\memglodesc{(\ref {depr.istrstream})}} {\memgloref{}}|memjustarg}{1945} +\glossaryentry{depr.istrstream.general@ {\memgloterm{depr.istrstream.general}}{\memglodesc{(\ref {depr.istrstream.general})}} {\memgloref{}}|memjustarg}{1945} +\glossaryentry{depr.istrstream.cons@ {\memgloterm{depr.istrstream.cons}}{\memglodesc{(\ref {depr.istrstream.cons})}} {\memgloref{}}|memjustarg}{1945} +\glossaryentry{depr.istrstream.members@ {\memgloterm{depr.istrstream.members}}{\memglodesc{(\ref {depr.istrstream.members})}} {\memgloref{}}|memjustarg}{1945} +\glossaryentry{depr.ostrstream@ {\memgloterm{depr.ostrstream}}{\memglodesc{(\ref {depr.ostrstream})}} {\memgloref{}}|memjustarg}{1945} +\glossaryentry{depr.ostrstream.general@ {\memgloterm{depr.ostrstream.general}}{\memglodesc{(\ref {depr.ostrstream.general})}} {\memgloref{}}|memjustarg}{1945} +\glossaryentry{depr.ostrstream.cons@ {\memgloterm{depr.ostrstream.cons}}{\memglodesc{(\ref {depr.ostrstream.cons})}} {\memgloref{}}|memjustarg}{1946} +\glossaryentry{depr.ostrstream.members@ {\memgloterm{depr.ostrstream.members}}{\memglodesc{(\ref {depr.ostrstream.members})}} {\memgloref{}}|memjustarg}{1946} +\glossaryentry{depr.strstream@ {\memgloterm{depr.strstream}}{\memglodesc{(\ref {depr.strstream})}} {\memgloref{}}|memjustarg}{1946} +\glossaryentry{depr.strstream.general@ {\memgloterm{depr.strstream.general}}{\memglodesc{(\ref {depr.strstream.general})}} {\memgloref{}}|memjustarg}{1946} +\glossaryentry{depr.strstream.cons@ {\memgloterm{depr.strstream.cons}}{\memglodesc{(\ref {depr.strstream.cons})}} {\memgloref{}}|memjustarg}{1947} +\glossaryentry{depr.strstream.dest@ {\memgloterm{depr.strstream.dest}}{\memglodesc{(\ref {depr.strstream.dest})}} {\memgloref{}}|memjustarg}{1947} +\glossaryentry{depr.strstream.oper@ {\memgloterm{depr.strstream.oper}}{\memglodesc{(\ref {depr.strstream.oper})}} {\memgloref{}}|memjustarg}{1947} +\glossaryentry{depr.cerrno@ {\memgloterm{depr.cerrno}}{\memglodesc{(\ref {depr.cerrno})}} {\memgloref{}}|memjustarg}{1947} +\glossaryentry{depr.default.allocator@ {\memgloterm{depr.default.allocator}}{\memglodesc{(\ref {depr.default.allocator})}} {\memgloref{}}|memjustarg}{1948} +\glossaryentry{depr.mem.poly.allocator.mem@ {\memgloterm{depr.mem.poly.allocator.mem}}{\memglodesc{(\ref {depr.mem.poly.allocator.mem})}} {\memgloref{}}|memjustarg}{1948} +\glossaryentry{depr.meta.types@ {\memgloterm{depr.meta.types}}{\memglodesc{(\ref {depr.meta.types})}} {\memgloref{}}|memjustarg}{1948} +\glossaryentry{depr.tuple@ {\memgloterm{depr.tuple}}{\memglodesc{(\ref {depr.tuple})}} {\memgloref{}}|memjustarg}{1949} +\glossaryentry{depr.variant@ {\memgloterm{depr.variant}}{\memglodesc{(\ref {depr.variant})}} {\memgloref{}}|memjustarg}{1950} +\glossaryentry{depr.iterator@ {\memgloterm{depr.iterator}}{\memglodesc{(\ref {depr.iterator})}} {\memgloref{}}|memjustarg}{1950} +\glossaryentry{depr.move.iter.elem@ {\memgloterm{depr.move.iter.elem}}{\memglodesc{(\ref {depr.move.iter.elem})}} {\memgloref{}}|memjustarg}{1950} +\glossaryentry{depr.util.smartptr.shared.atomic@ {\memgloterm{depr.util.smartptr.shared.atomic}}{\memglodesc{(\ref {depr.util.smartptr.shared.atomic})}} {\memgloref{}}|memjustarg}{1951} +\glossaryentry{depr.string.capacity@ {\memgloterm{depr.string.capacity}}{\memglodesc{(\ref {depr.string.capacity})}} {\memgloref{}}|memjustarg}{1953} +\glossaryentry{depr.locale.stdcvt@ {\memgloterm{depr.locale.stdcvt}}{\memglodesc{(\ref {depr.locale.stdcvt})}} {\memgloref{}}|memjustarg}{1953} +\glossaryentry{depr.locale.stdcvt.general@ {\memgloterm{depr.locale.stdcvt.general}}{\memglodesc{(\ref {depr.locale.stdcvt.general})}} {\memgloref{}}|memjustarg}{1953} +\glossaryentry{depr.codecvt.syn@ {\memgloterm{depr.codecvt.syn}}{\memglodesc{(\ref {depr.codecvt.syn})}} {\memgloref{}}|memjustarg}{1953} +\glossaryentry{depr.locale.stdcvt.req@ {\memgloterm{depr.locale.stdcvt.req}}{\memglodesc{(\ref {depr.locale.stdcvt.req})}} {\memgloref{}}|memjustarg}{1954} +\glossaryentry{depr.conversions@ {\memgloterm{depr.conversions}}{\memglodesc{(\ref {depr.conversions})}} {\memgloref{}}|memjustarg}{1954} +\glossaryentry{depr.conversions.general@ {\memgloterm{depr.conversions.general}}{\memglodesc{(\ref {depr.conversions.general})}} {\memgloref{}}|memjustarg}{1954} +\glossaryentry{depr.conversions.string@ {\memgloterm{depr.conversions.string}}{\memglodesc{(\ref {depr.conversions.string})}} {\memgloref{}}|memjustarg}{1954} +\glossaryentry{depr.conversions.buffer@ {\memgloterm{depr.conversions.buffer}}{\memglodesc{(\ref {depr.conversions.buffer})}} {\memgloref{}}|memjustarg}{1956} +\glossaryentry{depr.locale.category@ {\memgloterm{depr.locale.category}}{\memglodesc{(\ref {depr.locale.category})}} {\memgloref{}}|memjustarg}{1958} +\glossaryentry{depr.fs.path.factory@ {\memgloterm{depr.fs.path.factory}}{\memglodesc{(\ref {depr.fs.path.factory})}} {\memgloref{}}|memjustarg}{1958} +\glossaryentry{depr.atomics@ {\memgloterm{depr.atomics}}{\memglodesc{(\ref {depr.atomics})}} {\memgloref{}}|memjustarg}{1958} +\glossaryentry{depr.atomics.general@ {\memgloterm{depr.atomics.general}}{\memglodesc{(\ref {depr.atomics.general})}} {\memgloref{}}|memjustarg}{1958} +\glossaryentry{depr.atomics.volatile@ {\memgloterm{depr.atomics.volatile}}{\memglodesc{(\ref {depr.atomics.volatile})}} {\memgloref{}}|memjustarg}{1959} +\glossaryentry{depr.atomics.nonmembers@ {\memgloterm{depr.atomics.nonmembers}}{\memglodesc{(\ref {depr.atomics.nonmembers})}} {\memgloref{}}|memjustarg}{1959} +\glossaryentry{depr.atomics.types.operations@ {\memgloterm{depr.atomics.types.operations}}{\memglodesc{(\ref {depr.atomics.types.operations})}} {\memgloref{}}|memjustarg}{1959} +\glossaryentry{uaxid@ {\memgloterm{uaxid}}{\memglodesc{(\ref {uaxid})}} {\memgloref{}}|memjustarg}{1960} +\glossaryentry{uaxid.general@ {\memgloterm{uaxid.general}}{\memglodesc{(\ref {uaxid.general})}} {\memgloref{}}|memjustarg}{1960} +\glossaryentry{uaxid.def@ {\memgloterm{uaxid.def}}{\memglodesc{(\ref {uaxid.def})}} {\memgloref{}}|memjustarg}{1960} +\glossaryentry{uaxid.def.general@ {\memgloterm{uaxid.def.general}}{\memglodesc{(\ref {uaxid.def.general})}} {\memgloref{}}|memjustarg}{1960} +\glossaryentry{uaxid.def.rfmt@ {\memgloterm{uaxid.def.rfmt}}{\memglodesc{(\ref {uaxid.def.rfmt})}} {\memgloref{}}|memjustarg}{1960} +\glossaryentry{uaxid.def.stable@ {\memgloterm{uaxid.def.stable}}{\memglodesc{(\ref {uaxid.def.stable})}} {\memgloref{}}|memjustarg}{1960} +\glossaryentry{uaxid.immutable@ {\memgloterm{uaxid.immutable}}{\memglodesc{(\ref {uaxid.immutable})}} {\memgloref{}}|memjustarg}{1960} +\glossaryentry{uaxid.pattern@ {\memgloterm{uaxid.pattern}}{\memglodesc{(\ref {uaxid.pattern})}} {\memgloref{}}|memjustarg}{1960} +\glossaryentry{uaxid.eqn@ {\memgloterm{uaxid.eqn}}{\memglodesc{(\ref {uaxid.eqn})}} {\memgloref{}}|memjustarg}{1961} +\glossaryentry{uaxid.eqci@ {\memgloterm{uaxid.eqci}}{\memglodesc{(\ref {uaxid.eqci})}} {\memgloref{}}|memjustarg}{1961} +\glossaryentry{uaxid.filter@ {\memgloterm{uaxid.filter}}{\memglodesc{(\ref {uaxid.filter})}} {\memgloref{}}|memjustarg}{1961} +\glossaryentry{uaxid.filterci@ {\memgloterm{uaxid.filterci}}{\memglodesc{(\ref {uaxid.filterci})}} {\memgloref{}}|memjustarg}{1961} +\glossaryentry{uaxid.hashtag@ {\memgloterm{uaxid.hashtag}}{\memglodesc{(\ref {uaxid.hashtag})}} {\memgloref{}}|memjustarg}{1961} diff --git a/tools/check-output.sh b/tools/check-output.sh index 206e2b4f98..867e38e661 100755 --- a/tools/check-output.sh +++ b/tools/check-output.sh @@ -73,6 +73,7 @@ for f in *.tex; do done # Cross references since the previous standard. +# Note: xrefprev should be a copy of the previous standard's xrefindex.glo. function indexentries() { sed 's,\\glossaryentry{\(.*\)@.*,\1,' "$1" | LANG=C sort; } function removals() { diff -u "$1" "$2" | grep '^-' | grep -v '^---' | sed 's/^-//'; } function difference() { diff -u "$1" "$2" | grep '^[-+]' | grep -v '^\(---\|+++\)'; } From e6c2f8fb0d5ad6cda3e2d3da63bd5d5e434635b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Tue, 18 Jul 2023 23:16:59 +0100 Subject: [PATCH 127/171] [diff.cpp23.expr] Fix environment ("example" should be "codeblock") --- source/compatibility.tex | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/compatibility.tex b/source/compatibility.tex index d3dad60bbf..6c6028419a 100644 --- a/source/compatibility.tex +++ b/source/compatibility.tex @@ -24,12 +24,12 @@ that relies on the result of pointer comparison between backing arrays may change behavior. For example: -\begin{example} +\begin{codeblock} bool ne(std::initializer_list a, std::initializer_list b) { return a.begin() != b.begin() + 1; } -bool b = ne({2,3}, {1,2,3}); // unspecified result; previously \tcode{false} -\end{example} +bool b = ne({2,3}, {1,2,3}); // unspecified result; previously \tcode{false} +\end{codeblock} \rSec2[diff.cpp23.strings]{\ref{strings}: strings library} From 2109f579cc6749d19ddf9cf892e8aec4762ba344 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Fri, 21 Jul 2023 16:21:54 +0100 Subject: [PATCH 128/171] [locale.general] Add cross-references to class synopsis --- source/locales.tex | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/source/locales.tex b/source/locales.tex index f66886e4b8..ce87b0d573 100644 --- a/source/locales.tex +++ b/source/locales.tex @@ -123,9 +123,12 @@ namespace std { class locale { public: - // types + // \ref{locale.types}, types + // \ref{locale.facet}, class \tcode{locale::facet} class facet; + // \ref{locale.id}, class \tcode{locale::id} class id; + // \ref{locale.category}, type \tcode{locale::category} using category = int; static const category // values assigned here are for exposition only none = 0, @@ -134,7 +137,7 @@ time = 0x100, messages = 0x200, all = collate | ctype | monetary | numeric | time | messages; - // construct/copy/destroy + // \ref{locale.cons}, construct/copy/destroy locale() noexcept; locale(const locale& other) noexcept; explicit locale(const char* std_name); @@ -145,9 +148,9 @@ locale(const locale& other, const locale& one, category); ~locale(); // not virtual const locale& operator=(const locale& other) noexcept; - template locale combine(const locale& other) const; - // locale operations + // \ref{locale.members}, locale operations + template locale combine(const locale& other) const; string name() const; text_encoding encoding() const; @@ -157,7 +160,7 @@ bool operator()(const basic_string& s1, const basic_string& s2) const; - // global locale objects + // \ref{locale.statics}, global locale objects static locale global(const locale&); static const locale& classic(); }; From c2e05a4080e8c79bcc9971054ca6fb6ae9b3e722 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Fri, 21 Jul 2023 17:05:10 +0100 Subject: [PATCH 129/171] [functional.syn] Tweak cross-references in class synopsis --- source/utilities.tex | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/source/utilities.tex b/source/utilities.tex index 663575d18a..89579fea1e 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -10636,16 +10636,18 @@ constexpr @\unspec@ mem_fn(R T::*) noexcept; // freestanding // \ref{func.wrap}, polymorphic function wrappers + // \ref{func.wrap.badcall}, class \tcode{bad_function_call} class bad_function_call; + // \ref{func.wrap.func}, class template \tcode{function} template class function; // \notdef template class function; - // \ref{func.wrap.func.alg}, specialized algorithms + // \ref{func.wrap.func.alg}, \tcode{function} specialized algorithms template void swap(function&, function&) noexcept; - // \ref{func.wrap.func.nullptr}, null pointer comparison operator functions + // \ref{func.wrap.func.nullptr}, \tcode{function} null pointer comparison operator functions template bool operator==(const function&, nullptr_t) noexcept; From 8334cc876d29595f0f2796a6de42acae937d8377 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Fri, 21 Jul 2023 23:29:54 +0100 Subject: [PATCH 130/171] [functional.syn, func.wrap.move] Hyphenate "move-only wrapper" --- source/utilities.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/utilities.tex b/source/utilities.tex index 89579fea1e..4a8ca0ed24 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -10651,7 +10651,7 @@ template bool operator==(const function&, nullptr_t) noexcept; - // \ref{func.wrap.move}, move only wrapper + // \ref{func.wrap.move}, move-only wrapper template class move_only_function; // \notdef template class move_only_function; // \seebelow @@ -13249,7 +13249,7 @@ As if by: \tcode{f1.swap(f2);} \end{itemdescr}% -\rSec3[func.wrap.move]{Move only wrapper} +\rSec3[func.wrap.move]{Move-only wrapper} \rSec4[func.wrap.move.general]{General} From 7fb62d5f50bfbfc159df4ca0af932ee82d26bc41 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Fri, 21 Jul 2023 18:13:28 +0100 Subject: [PATCH 131/171] [version.syn] Rename smart_pointer_owner_equality to smart_ptr_owner_equality For consistency: the use of "ptr" is already prevailing. --- source/support.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/support.tex b/source/support.tex index 8ca7d174b0..af70b8474d 100644 --- a/source/support.tex +++ b/source/support.tex @@ -748,7 +748,7 @@ #define @\defnlibxname{cpp_lib_shared_ptr_weak_type}@ 201606L // also in \libheader{memory} #define @\defnlibxname{cpp_lib_shared_timed_mutex}@ 201402L // also in \libheader{shared_mutex} #define @\defnlibxname{cpp_lib_shift}@ 202202L // also in \libheader{algorithm} -#define @\defnlibxname{cpp_lib_smart_pointer_owner_equality}@ 202306L // also in \libheader{memory} +#define @\defnlibxname{cpp_lib_smart_ptr_owner_equality}@ 202306L // also in \libheader{memory} #define @\defnlibxname{cpp_lib_smart_ptr_for_overwrite}@ 202002L // also in \libheader{memory} #define @\defnlibxname{cpp_lib_source_location}@ 201907L // freestanding, also in \libheader{source_location} #define @\defnlibxname{cpp_lib_span}@ 202002L // also in \libheader{span} From a8ab06c4e866d2abe9041cafd3a869cef57fbbfc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Fri, 21 Jul 2023 22:18:20 +0100 Subject: [PATCH 132/171] [filebuf.general] Whitespace improvements, fewer linebreaks --- source/iostreams.tex | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/source/iostreams.tex b/source/iostreams.tex index bba66ad08e..6de3e1a0f6 100644 --- a/source/iostreams.tex +++ b/source/iostreams.tex @@ -10890,10 +10890,8 @@ basic_filebuf* open(const char* s, ios_base::openmode mode); basic_filebuf* open(const filesystem::path::value_type* s, ios_base::openmode mode); // wide systems only; see \ref{fstream.syn} - basic_filebuf* open(const string& s, - ios_base::openmode mode); - basic_filebuf* open(const filesystem::path& s, - ios_base::openmode mode); + basic_filebuf* open(const string& s, ios_base::openmode mode); + basic_filebuf* open(const filesystem::path& s, ios_base::openmode mode); basic_filebuf* close(); native_handle_type native_handle() const noexcept; @@ -10905,16 +10903,15 @@ int_type pbackfail(int_type c = traits::eof()) override; int_type overflow (int_type c = traits::eof()) override; - basic_streambuf* setbuf(char_type* s, - streamsize n) override; + basic_streambuf* setbuf(char_type* s, streamsize n) override; + pos_type seekoff(off_type off, ios_base::seekdir way, - ios_base::openmode which - = ios_base::in | ios_base::out) override; + ios_base::openmode which = ios_base::in | ios_base::out) override; pos_type seekpos(pos_type sp, - ios_base::openmode which - = ios_base::in | ios_base::out) override; - int sync() override; - void imbue(const locale& loc) override; + ios_base::openmode which = ios_base::in | ios_base::out) override; + + int sync() override; + void imbue(const locale& loc) override; }; } \end{codeblock} From 56a6b7fe068726ace9196366c968cc679653cc04 Mon Sep 17 00:00:00 2001 From: Hewill Kang <67143766+hewillk@users.noreply.github.com> Date: Wed, 17 May 2023 23:27:22 +0800 Subject: [PATCH 133/171] Add missing colon for the Effects: Equivalent to return format --- source/ranges.tex | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/source/ranges.tex b/source/ranges.tex index c30a56a901..0436ee08e9 100644 --- a/source/ranges.tex +++ b/source/ranges.tex @@ -8313,7 +8313,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to \tcode{return \exposid{cur_};} +Equivalent to: \tcode{return \exposid{cur_};} \end{itemdescr} \begin{itemdecl} @@ -8323,7 +8323,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to \tcode{return \{\exposid{cur_}, \exposid{next_}.begin()\};} +Equivalent to: \tcode{return \{\exposid{cur_}, \exposid{next_}.begin()\};} \end{itemdescr} \begin{itemdecl} @@ -10638,7 +10638,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to \tcode{return -(x - y);} +Equivalent to: \tcode{return -(x - y);} \end{itemdescr} \rSec2[range.zip.transform]{Zip transform view} @@ -12302,7 +12302,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to \tcode{return x.\exposid{inner_} == y.\exposid{inner_};} +Equivalent to: \tcode{return x.\exposid{inner_} == y.\exposid{inner_};} \end{itemdescr} \begin{itemdecl} @@ -12320,7 +12320,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to \tcode{return x.\exposid{inner_} - y.\exposid{inner_};} +Equivalent to: \tcode{return x.\exposid{inner_} - y.\exposid{inner_};} \end{itemdescr} \rSec2[range.chunk]{Chunk view} From a34d2e08bda9b1314ecec1b608745a88a678d664 Mon Sep 17 00:00:00 2001 From: vasama Date: Wed, 7 Jun 2023 11:01:02 +0300 Subject: [PATCH 134/171] [expr.pre] Clarify note on pointer subtraction --- source/expressions.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/expressions.tex b/source/expressions.tex index 65802d7594..480516076a 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -6283,13 +6283,13 @@ array elements $i$ and $j$ of the same array object \tcode{x}, the expression \tcode{P - Q} has the value $i - j$. -\item Otherwise, the behavior is undefined. \begin{note} If the value $i - j$ is not in the range of representable values of type \tcode{std::ptrdiff_t}, -the behavior is undefined. +the behavior is undefined\iref{expr.pre}. \end{note} +\item Otherwise, the behavior is undefined. \end{itemize} \pnum From 96f695aea7589a62e5ebb55a18a40f985f7d89ce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Tue, 13 Jun 2023 09:18:01 +0300 Subject: [PATCH 135/171] [basic.def.odr] Restructure requirements in p14-p15 --- source/basic.tex | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/source/basic.tex b/source/basic.tex index 4ba58bb4e7..5513533f4d 100644 --- a/source/basic.tex +++ b/source/basic.tex @@ -698,7 +698,12 @@ were present in the definition of \tcode{D}; that is, the default argument or default template argument is subject to the requirements described in this paragraph (recursively). +\end{itemize} + +\pnum +For the purposes of the preceding requirements: +\begin{itemize} \item If \tcode{D} is a class with an implicitly-declared constructor\iref{class.default.ctor,class.copy.ctor}, it is as if the constructor was @@ -738,14 +743,16 @@ implicitly defined in every translation unit where it is odr-used, and the implicit definition in every translation unit shall call the same comparison operators for each subobject of \tcode{D}. -\end{itemize} -\pnum +\item If \tcode{D} is a template and is defined in more than one -translation unit, then the preceding requirements -shall apply both to names from the template's enclosing scope used in the +translation unit, the requirements +apply both to names from the template's enclosing scope used in the template definition, and also to dependent names at the point of instantiation\iref{temp.dep}. +\end{itemize} + +\pnum These requirements also apply to corresponding entities defined within each definition of \tcode{D} (including the closure types of \grammarterm{lambda-expression}{s}, From ebba9f316ddd8c120608447b00ea32bf3926a18d Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Sun, 23 Jul 2023 02:29:17 +0100 Subject: [PATCH 136/171] [func.wrap.func.general, func.wrap.move.class] Remove redundant declaration (#6273) We don't need to repeat the declarations of the incomplete primary template, they are already present in the synopsis. --- source/utilities.tex | 4 ---- 1 file changed, 4 deletions(-) diff --git a/source/utilities.tex b/source/utilities.tex index 4a8ca0ed24..5c7040244b 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -12808,8 +12808,6 @@ \indexlibrarymember{result_type}{function}% \begin{codeblock} namespace std { - template class function; // \notdef - template class function { public: @@ -13281,8 +13279,6 @@ \indexlibraryglobal{move_only_function}% \begin{codeblock} namespace std { - template class move_only_function; // \notdef - template class move_only_function { public: From e6bd946d953b76e908a8e853d93834572c125d59 Mon Sep 17 00:00:00 2001 From: Richard Smith Date: Fri, 14 Jul 2023 13:31:47 -0700 Subject: [PATCH 137/171] [basic.scope.scope] Avoid hard-to-read except...unless construction. Factor out a name for the "unless" condition to avoid the double-negative. --- source/basic.tex | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/source/basic.tex b/source/basic.tex index 5513533f4d..6b9b5e3430 100644 --- a/source/basic.tex +++ b/source/basic.tex @@ -938,7 +938,11 @@ function, or function template, or \item -each declares a function or function template, except when +each declares a function or function template +and they do not declare corresponding overloads. +\end{itemize} +Two function or function template declarations declare +\defn{corresponding overloads} if: \begin{itemize} \item both declare functions with the same non-object-parameter-type-list, @@ -955,7 +959,6 @@ \grammarterm{template-head}s and trailing \grammarterm{requires-clause}s (if any). \end{itemize} -\end{itemize} \begin{note} Declarations can correspond even if neither binds a name. \begin{example} From 40aec1046e2c78affa245470400479b5f39df6b2 Mon Sep 17 00:00:00 2001 From: Jan Schultke Date: Sun, 23 Jul 2023 03:30:48 +0200 Subject: [PATCH 138/171] [dcl.enum] Remove extraneous spaces from example (#6381) --- source/declarations.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/declarations.tex b/source/declarations.tex index 15c6dc71e5..b71bd50b65 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -7289,7 +7289,7 @@ \begin{codeblock} enum direction { left='l', right='r' }; -void g() { +void g() { direction d; // OK d = left; // OK d = direction::right; // OK @@ -7297,7 +7297,7 @@ enum class altitude { high='h', low='l' }; -void h() { +void h() { altitude a; // OK a = high; // error: \tcode{high} not in scope a = altitude::low; // OK From 3769c701daf9ae38f8db054670106abca7c03d32 Mon Sep 17 00:00:00 2001 From: Roger Orr Date: Tue, 18 Jul 2023 23:54:34 +0100 Subject: [PATCH 139/171] [dcl.ambig.res] fix double declaration of 'y' in example --- source/declarations.tex | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/declarations.tex b/source/declarations.tex index b71bd50b65..2c2f20d3a0 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -2441,9 +2441,9 @@ typedef struct BB { int C[2]; } *B, C; void foo(double a) { - S w(int(a)); // function declaration - S x(int()); // function declaration - S y((int(a))); // object declaration + S v(int(a)); // function declaration + S w(int()); // function declaration + S x((int(a))); // object declaration S y((int)a); // object declaration S z = int(a); // object declaration S a(B()->C); // object declaration From 0bf51a3bc5c24b070265412c32e53a0060d73eef Mon Sep 17 00:00:00 2001 From: Christian Trott Date: Sat, 22 Jul 2023 19:33:41 -0600 Subject: [PATCH 140/171] [mdspan.layout.stride.cons] Fix missed rename of template parameter (#6385) "LayoutStrideMapping" should say "StridedLayoutMapping". --- source/containers.tex | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/containers.tex b/source/containers.tex index 17c000f74c..d9a81cbff2 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -20586,9 +20586,9 @@ Remarks: The expression inside \tcode{explicit} is equivalent to: \begin{codeblock} !(is_convertible_v && - (@\exposid{is-mapping-of}@ || - @\exposid{is-mapping-of}@ || - @\exposid{is-mapping-of}@)) + (@\exposid{is-mapping-of}@ || + @\exposid{is-mapping-of}@ || + @\exposid{is-mapping-of}@)) \end{codeblock} \end{itemdescr} From f8feaa6e5bc8e6d28e00c06a3de305f80f395913 Mon Sep 17 00:00:00 2001 From: Eelis van der Weegen Date: Fri, 21 Jul 2023 11:43:39 +0200 Subject: [PATCH 141/171] [version.syn] Fix header references. --- source/support.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/support.tex b/source/support.tex index af70b8474d..f9fb1a8c81 100644 --- a/source/support.tex +++ b/source/support.tex @@ -636,7 +636,7 @@ #define @\defnlibxname{cpp_lib_forward_like}@ 202207L // freestanding, also in \libheader{utility} #define @\defnlibxname{cpp_lib_freestanding_char_traits}@ 202306L // freestanding, also in \libheader{string} #define @\defnlibxname{cpp_lib_freestanding_charconv}@ 202306L // freestanding, also in \libheader{charconv} -#define @\defnlibxname{cpp_lib_freestanding_cstdlib}@ 202306L // freestanding, also in \libheader{stdlib}, \libheader{cmath} +#define @\defnlibxname{cpp_lib_freestanding_cstdlib}@ 202306L // freestanding, also in \libheader{cstdlib}, \libheader{cmath} #define @\defnlibxname{cpp_lib_freestanding_cstring}@ 202306L // freestanding, also in \libheader{cstring} #define @\defnlibxname{cpp_lib_freestanding_cwchar}@ 202306L // freestanding, also in \libheader{cwchar} #define @\defnlibxname{cpp_lib_freestanding_errc}@ 202306L @@ -644,7 +644,7 @@ #define @\defnlibxname{cpp_lib_freestanding_feature_test_macros}@ 202306L // freestanding #define @\defnlibxname{cpp_lib_freestanding_functional}@ 202306L // freestanding, also in \libheader{functional} #define @\defnlibxname{cpp_lib_freestanding_iterator}@ 202306L // freestanding, also in \libheader{iterator} -#define @\defnlibxname{cpp_lib_freestanding_memory}@ 202306L // freestanding, also in \libheader{memory>} +#define @\defnlibxname{cpp_lib_freestanding_memory}@ 202306L // freestanding, also in \libheader{memory} #define @\defnlibxname{cpp_lib_freestanding_operator_new}@ @\seebelow@ // freestanding, also in \libheader{new} #define @\defnlibxname{cpp_lib_freestanding_ranges}@ 202306L // freestanding, also in \libheader{ranges} #define @\defnlibxname{cpp_lib_freestanding_ratio}@ 202306L // freestanding, also in \libheader{ratio} From 982b323abe1e119093bd0a11c8c025d780ebe9df Mon Sep 17 00:00:00 2001 From: Jan Schultke Date: Sun, 23 Jul 2023 03:35:13 +0200 Subject: [PATCH 142/171] [over.call.func] Fix indentation in example (#6392) --- source/overloading.tex | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/source/overloading.tex b/source/overloading.tex index 04a4fb351c..9e187abfff 100644 --- a/source/overloading.tex +++ b/source/overloading.tex @@ -492,18 +492,18 @@ a(); // OK, \tcode{(*this).a()} } -void c(this const C&); // \#1 -void c()&; // \#2 -static void c(int = 0); // \#3 - -void d() { - c(); // error: ambiguous between \#2 and \#3 - (C::c)(); // error: as above - (&(C::c))(); // error: cannot resolve address of overloaded \tcode{this->C::c}\iref{over.over} - (&C::c)(C{}); // selects \#1 - (&C::c)(*this); // error: selects \#2, and is ill-formed\iref{over.match.call.general} - (&C::c)(); // selects \#3 -} + void c(this const C&); // \#1 + void c() &; // \#2 + static void c(int = 0); // \#3 + + void d() { + c(); // error: ambiguous between \#2 and \#3 + (C::c)(); // error: as above + (&(C::c))(); // error: cannot resolve address of overloaded \tcode{this->C::c}\iref{over.over} + (&C::c)(C{}); // selects \#1 + (&C::c)(*this); // error: selects \#2, and is ill-formed\iref{over.match.call.general} + (&C::c)(); // selects \#3 + } void f(this const C&); void g() const { From fde3d5c832d46c306e29d375be7c83c64320ec53 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johel=20Ernesto=20Guerrero=20Pe=C3=B1a?= Date: Sun, 18 Jun 2023 07:46:13 -0400 Subject: [PATCH 143/171] [README] Update Arch Linux instructions --- README.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.rst b/README.rst index 0bef62ee71..4ab1c20b2d 100644 --- a/README.rst +++ b/README.rst @@ -48,7 +48,7 @@ Getting Started on Arch Linux Install the following packages: - pacman -S texlive-latexextra + pacman -S make texlive-latexextra texlive-binextra texlive-plaingeneric texlive-fontsrecommended ----------------------------- Getting Started on Microsoft Windows From 872bda08678d1aeecfc555f26920cec28a2ad497 Mon Sep 17 00:00:00 2001 From: lprv <100177227+lprv@users.noreply.github.com> Date: Thu, 1 Jun 2023 14:59:00 +0000 Subject: [PATCH 144/171] [basic.stc.dynamic.allocation] Remove redundant 'address of' from a note --- source/basic.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/basic.tex b/source/basic.tex index 6b9b5e3430..d7b7e576b0 100644 --- a/source/basic.tex +++ b/source/basic.tex @@ -4046,7 +4046,7 @@ currently installed new-handler function\iref{new.handler}, if any. \begin{note} \indextext{\idxcode{new_handler}}% -A program-supplied allocation function can obtain the address of the +A program-supplied allocation function can obtain the currently installed \tcode{new_handler} using the \tcode{std::get_new_handler} function\iref{get.new.handler}. \end{note} From 880531fad125c4b806300151ddcb961a7f44a181 Mon Sep 17 00:00:00 2001 From: Arthur O'Dwyer Date: Sat, 22 Jul 2023 21:49:38 -0400 Subject: [PATCH 145/171] [flat.{,multi}{map,set}.cons]: zip_view should be views::zip (#6373) We don't expect to use CTAD on `ranges::zip_view(args...)`; what we expect is `views::zip`. --- source/containers.tex | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/source/containers.tex b/source/containers.tex index d9a81cbff2..86731245a6 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -15512,7 +15512,7 @@ sorts the range \range{begin()}{end()} with respect to \tcode{value_comp()}; and finally erases the duplicate elements as if by: \begin{codeblock} -auto zv = ranges::zip_view(c.keys, c.values); +auto zv = views::zip(c.keys, c.values); auto it = ranges::unique(zv, key_equiv(compare)).begin(); auto dist = distance(zv.begin(), it); c.keys.erase(c.keys.begin() + dist, c.keys.end()); @@ -15843,7 +15843,7 @@ the sorted range of pre-existing elements into a single sorted range; and finally erases the duplicate elements as if by: \begin{codeblock} -auto zv = ranges::zip_view(c.keys, c.values); +auto zv = views::zip(c.keys, c.values); auto it = ranges::unique(zv, key_equiv(compare)).begin(); auto dist = distance(zv.begin(), it); c.keys.erase(c.keys.begin() + dist, c.keys.end()); @@ -15882,7 +15882,7 @@ the sorted range of pre-existing elements into a single sorted range; and finally erases the duplicate elements as if by: \begin{codeblock} -auto zv = ranges::zip_view(c.keys, c.values); +auto zv = views::zip(c.keys, c.values); auto it = ranges::unique(zv, key_equiv(compare)).begin(); auto dist = distance(zv.begin(), it); c.keys.erase(c.keys.begin() + dist, c.keys.end()); @@ -15920,7 +15920,7 @@ the sorted range of pre-existing elements into a single sorted range; and finally erases the duplicate elements as if by: \begin{codeblock} -auto zv = ranges::zip_view(c.keys, c.values); +auto zv = views::zip(c.keys, c.values); auto it = ranges::unique(zv, key_equiv(compare)).begin(); auto dist = distance(zv.begin(), it); c.keys.erase(c.keys.begin() + dist, c.keys.end()); From a417ade53722d944481baac575292874c1bcc79a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johel=20Ernesto=20Guerrero=20Pe=C3=B1a?= Date: Sat, 22 Jul 2023 21:50:37 -0400 Subject: [PATCH 146/171] [range.enumerate.overview] Add cross reference to [range.adaptor.object] (#6219) --- source/ranges.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/ranges.tex b/source/ranges.tex index 0436ee08e9..eaddf6ba39 100644 --- a/source/ranges.tex +++ b/source/ranges.tex @@ -9483,7 +9483,7 @@ \pnum \indexlibrarymember{enumerate}{views}% -The name \tcode{views::enumerate} denotes a range adaptor object. +The name \tcode{views::enumerate} denotes a range adaptor object\iref{range.adaptor.object}. Given a subexpression \tcode{E}, the expression \tcode{views::enumerate(E)} is expression-equivalent to \tcode{enumerate_view>(E)}. From 7f100cc67b0bb263e2f438238e87555347ae45c0 Mon Sep 17 00:00:00 2001 From: Hewill Kang <67143766+hewillk@users.noreply.github.com> Date: Sun, 23 Jul 2023 17:50:27 +0800 Subject: [PATCH 147/171] [input.output] Fix the "Effects: Equivalent to" format (#6402) --- source/iostreams.tex | 40 ++++++++++++++++++++-------------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/source/iostreams.tex b/source/iostreams.tex index 6de3e1a0f6..1ecb1c598d 100644 --- a/source/iostreams.tex +++ b/source/iostreams.tex @@ -4460,7 +4460,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to: \tcode{swap(rhs)}. +Equivalent to \tcode{swap(rhs)}. \pnum \returns @@ -5857,7 +5857,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to: \tcode{swap(rhs)}. +Equivalent to \tcode{swap(rhs)}. \end{itemdescr} \indexlibrarymember{swap}{basic_iostream}% @@ -6130,7 +6130,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to: \tcode{swap(rhs)}. +Equivalent to \tcode{swap(rhs)}. \pnum \returns @@ -8267,7 +8267,7 @@ \remarks The exception specification is equivalent to:\\ \tcode{allocator_traits::propagate_on_container_swap::value ||}\\ -\tcode{allocator_traits::is_always_equal::value}. +\tcode{allocator_traits::is_always_equal::value} \end{itemdescr} \indexlibrarymember{swap}{basic_stringbuf}% @@ -8280,7 +8280,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to: \tcode{x.swap(y)}. +Equivalent to \tcode{x.swap(y)}. \end{itemdescr} \rSec3[stringbuf.members]{Member functions} @@ -9031,7 +9031,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to: \tcode{x.swap(y)}. +Equivalent to \tcode{x.swap(y)}. \end{itemdescr} \rSec3[istringstream.members]{Member functions} @@ -9403,7 +9403,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to: \tcode{x.swap(y)}. +Equivalent to \tcode{x.swap(y)}. \end{itemdescr} \rSec3[ostringstream.members]{Member functions} @@ -9781,7 +9781,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to: \tcode{x.swap(y)}. +Equivalent to \tcode{x.swap(y)}. \end{itemdescr} \rSec3[stringstream.members]{Member functions} @@ -10384,7 +10384,7 @@ \pnum \effects Let \tcode{sp} be \tcode{std::span(std::forward(s))}. -Equivalent to +Equivalent to: \begin{codeblock} basic_ispanstream(std::span(const_cast(sp.data()), sp.size())) \end{codeblock} @@ -10473,7 +10473,7 @@ Let \tcode{sp} be \tcode{std::span(std::forward(s))}. Equivalent to: \begin{codeblock} -this->span(std::span(const_cast(sp.data()), sp.size())) +this->span(std::span(const_cast(sp.data()), sp.size())); \end{codeblock} \end{itemdescr} @@ -11086,7 +11086,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to: \tcode{x.swap(y)}. +Equivalent to \tcode{x.swap(y)}. \end{itemdescr} \rSec3[filebuf.members]{Member functions} @@ -11769,7 +11769,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to: \tcode{basic_ifstream(s.c_str(), mode)}. +Equivalent to \tcode{basic_ifstream(s.c_str(), mode)}. \end{itemdescr} \indexlibraryctor{basic_ifstream}% @@ -11785,7 +11785,7 @@ \pnum \effects -Equivalent to: \tcode{basic_ifstream(s.c_str(), mode)}. +Equivalent to \tcode{basic_ifstream(s.c_str(), mode)}. \end{itemdescr} \indexlibraryctor{basic_ifstream}% @@ -11826,7 +11826,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to: \tcode{x.swap(y)}. +Equivalent to \tcode{x.swap(y)}. \end{itemdescr} \rSec3[ifstream.members]{Member functions} @@ -12028,7 +12028,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to: \tcode{basic_ofstream(s.c_str(), mode)}. +Equivalent to \tcode{basic_ofstream(s.c_str(), mode)}. \end{itemdescr} \indexlibraryctor{basic_ofstream}% @@ -12044,7 +12044,7 @@ \pnum \effects -Equivalent to: \tcode{basic_ofstream(s.c_str(), mode)}. +Equivalent to \tcode{basic_ofstream(s.c_str(), mode)}. \end{itemdescr} \indexlibraryctor{basic_ofstream}% @@ -12085,7 +12085,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to: \tcode{x.swap(y)}. +Equivalent to \tcode{x.swap(y)}. \end{itemdescr} \rSec3[ofstream.members]{Member functions} @@ -12298,7 +12298,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to: \tcode{basic_fstream(s.c_str(), mode)}. +Equivalent to \tcode{basic_fstream(s.c_str(), mode)}. \end{itemdescr} \indexlibraryctor{basic_fstream}% @@ -12314,7 +12314,7 @@ \pnum \effects -Equivalent to: \tcode{basic_fstream(s.c_str(), mode)}. +Equivalent to \tcode{basic_fstream(s.c_str(), mode)}. \end{itemdescr} \indexlibraryctor{basic_fstream}% @@ -12356,7 +12356,7 @@ \begin{itemdescr} \pnum \effects -Equivalent to: \tcode{x.swap(y)}. +Equivalent to \tcode{x.swap(y)}. \end{itemdescr} \rSec3[fstream.members]{Member functions} From 9334219bd95a85e86b20c8a712397f9f23f0f7a8 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Sun, 23 Jul 2023 06:59:28 +0200 Subject: [PATCH 148/171] [class.copy.assign] Remove note obsoleted by CWG2586 --- source/classes.tex | 4 ---- 1 file changed, 4 deletions(-) diff --git a/source/classes.tex b/source/classes.tex index 39c538ecbd..baaccc2cb9 100644 --- a/source/classes.tex +++ b/source/classes.tex @@ -1675,10 +1675,6 @@ copy assignment operators, and, if selected, will be used to assign an object. \end{footnote} \begin{note} -An overloaded assignment operator must be declared to have only one parameter; -see~\ref{over.ass}. -\end{note} -\begin{note} More than one form of copy assignment operator can be declared for a class. \end{note} \begin{note} From 503b4b261061bdd2481e1e4f1153481a0a75ecee Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Sun, 23 Jul 2023 08:29:10 +0200 Subject: [PATCH 149/171] [dcl.fct.def.default] Highlight different references in defaulted assignments --- source/declarations.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/declarations.tex b/source/declarations.tex index 2c2f20d3a0..a12259501d 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -6347,7 +6347,7 @@ if $\tcode{F}_2$ has an implicit object parameter of type ``reference to \tcode{C}'', $\tcode{F}_1$ may be an explicit object member function whose - explicit object parameter is of type ``reference to \tcode{C}'', + explicit object parameter is of (possibly different) type ``reference to \tcode{C}'', in which case the type of $\tcode{F}_1$ would differ from the type of $\tcode{F}_2$ in that the type of $\tcode{F}_1$ has an additional parameter; \item From a578867b11cee40b9e2071adcafd40ce75b90502 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Mon, 24 Jul 2023 12:10:18 +0100 Subject: [PATCH 150/171] [figures] Use NewComputerModernSans font for figures The new font fits into our main font family (Computer Modern). The PDFs are rebuilt as version 1.5 (up from 1.4). --- source/Makefile | 2 +- source/figdag.pdf | Bin 6175 -> 5907 bytes source/figname.pdf | Bin 5348 -> 5035 bytes source/fignonvirt.pdf | Bin 4828 -> 4702 bytes source/figvirt.pdf | Bin 4960 -> 4751 bytes source/figvirtnonvirt.pdf | Bin 5430 -> 4823 bytes source/valuecategories.pdf | Bin 6783 -> 6465 bytes 7 files changed, 1 insertion(+), 1 deletion(-) diff --git a/source/Makefile b/source/Makefile index 02f990cd01..dcc414f864 100644 --- a/source/Makefile +++ b/source/Makefile @@ -15,7 +15,7 @@ quiet: latexmk -pdf std -e '$$max_repeat = 1;' -silent || ( rm std.pdf; latexmk -pdf std -e '$$max_repeat = 4;' ) %.pdf: %.dot - dot -o $@ -Tpdf $< + dot -o $@ -Tpdf $< -Nfontname=NewComputerModernSans10 clean-figures: rm -f $(FIGURES) diff --git a/source/figdag.pdf b/source/figdag.pdf index e3d535caf2e5d045ac51c79884ed7e7cc99a4052..26c743ece5a4b3ea271b9b66fad7433d69cc919a 100644 GIT binary patch literal 5907 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 RTv8e(LoX<(uCGD={{W+;MC$+m diff --git a/source/figname.pdf b/source/figname.pdf index 5a603c462fe007c0437d531f1387cda8937d4a86..a7f5bd30c0e72adbb0f0b9d6492e01593bebb825 100644 GIT binary patch literal 5035 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 literal 5348 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 delta 3911 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 diff --git a/source/figvirt.pdf b/source/figvirt.pdf index 931e6a6097fc66e6ca8a9406412f1265d98faab4..ddbbeb317675a83fbcc408a6b66f17ea18e22fec 100644 GIT binary patch literal 4751 zcmbVQ2|QG7+kY(~Arg%(rzR?5&MXFzb�sYf*z^jAe$IAz3O4Md(RHDr*~}NTNr| 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 delta 4054 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 diff --git a/source/figvirtnonvirt.pdf b/source/figvirtnonvirt.pdf index ccfc2da16d850d9d391cba2039a5961383028fce..5591593dc5592d9f062aff4101b57e4379b52c1a 100644 GIT binary patch literal 4823 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 nEK@QW%!prIPEIib%UQ9UXH*)VLR~H0FD;6 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 J!$6br{{gRYJ%0cI From a567088b0ab8ca62f0ff5a7b4746337ac3f6df9b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Mon, 24 Jul 2023 12:45:57 +0100 Subject: [PATCH 151/171] [assets] Move separate assets into "assets" subdirectory --- source/Makefile | 2 +- source/{ => assets}/figdag.dot | 0 source/{ => assets}/figdag.pdf | Bin source/{ => assets}/figname.dot | 0 source/{ => assets}/figname.pdf | Bin source/{ => assets}/fignonvirt.dot | 0 source/{ => assets}/fignonvirt.pdf | Bin source/{ => assets}/figvirt.dot | 0 source/{ => assets}/figvirt.pdf | Bin source/{ => assets}/figvirtnonvirt.dot | 0 source/{ => assets}/figvirtnonvirt.pdf | Bin source/{ => assets}/valuecategories.dot | 0 source/{ => assets}/valuecategories.pdf | Bin source/macros.tex | 4 +++- 14 files changed, 4 insertions(+), 2 deletions(-) rename source/{ => assets}/figdag.dot (100%) rename source/{ => assets}/figdag.pdf (100%) rename source/{ => assets}/figname.dot (100%) rename source/{ => assets}/figname.pdf (100%) rename source/{ => assets}/fignonvirt.dot (100%) rename source/{ => assets}/fignonvirt.pdf (100%) rename source/{ => assets}/figvirt.dot (100%) rename source/{ => assets}/figvirt.pdf (100%) rename source/{ => assets}/figvirtnonvirt.dot (100%) rename source/{ => assets}/figvirtnonvirt.pdf (100%) rename source/{ => assets}/valuecategories.dot (100%) rename source/{ => assets}/valuecategories.pdf (100%) diff --git a/source/Makefile b/source/Makefile index dcc414f864..4f26b0b792 100644 --- a/source/Makefile +++ b/source/Makefile @@ -1,4 +1,4 @@ -FIGURES=$(patsubst %.dot,%.pdf,$(wildcard *.dot)) +FIGURES=$(patsubst %.dot,%.pdf,$(wildcard assets/*.dot)) default: full diff --git a/source/figdag.dot b/source/assets/figdag.dot similarity index 100% rename from source/figdag.dot rename to source/assets/figdag.dot diff --git a/source/figdag.pdf b/source/assets/figdag.pdf similarity index 100% rename from source/figdag.pdf rename to source/assets/figdag.pdf diff --git a/source/figname.dot b/source/assets/figname.dot similarity index 100% rename from source/figname.dot rename to source/assets/figname.dot diff --git a/source/figname.pdf b/source/assets/figname.pdf similarity index 100% rename from source/figname.pdf rename to source/assets/figname.pdf diff --git a/source/fignonvirt.dot b/source/assets/fignonvirt.dot similarity index 100% rename from source/fignonvirt.dot rename to source/assets/fignonvirt.dot diff --git a/source/fignonvirt.pdf b/source/assets/fignonvirt.pdf similarity index 100% rename from source/fignonvirt.pdf rename to source/assets/fignonvirt.pdf diff --git a/source/figvirt.dot b/source/assets/figvirt.dot similarity index 100% rename from source/figvirt.dot rename to source/assets/figvirt.dot diff --git a/source/figvirt.pdf b/source/assets/figvirt.pdf similarity index 100% rename from source/figvirt.pdf rename to source/assets/figvirt.pdf diff --git a/source/figvirtnonvirt.dot b/source/assets/figvirtnonvirt.dot similarity index 100% rename from source/figvirtnonvirt.dot rename to source/assets/figvirtnonvirt.dot diff --git a/source/figvirtnonvirt.pdf b/source/assets/figvirtnonvirt.pdf similarity index 100% rename from source/figvirtnonvirt.pdf rename to source/assets/figvirtnonvirt.pdf diff --git a/source/valuecategories.dot b/source/assets/valuecategories.dot similarity index 100% rename from source/valuecategories.dot rename to source/assets/valuecategories.dot diff --git a/source/valuecategories.pdf b/source/assets/valuecategories.pdf similarity index 100% rename from source/valuecategories.pdf rename to source/assets/valuecategories.pdf diff --git a/source/macros.tex b/source/macros.tex index b6ad3ceed5..2fb80ba799 100644 --- a/source/macros.tex +++ b/source/macros.tex @@ -716,13 +716,15 @@ %% Environment for imported graphics %%-------------------------------------------------- % usage: \begin{importgraphic}{CAPTION}{TAG}{FILE} +% +% The filename is relative to the source/assets directory. \newenvironment{importgraphic}[3] {% \newcommand{\cptn}{#1} \newcommand{\lbl}{#2} \begin{figure}[htp]\centering% -\includegraphics[scale=.35]{#3} +\includegraphics[scale=.35]{assets/#3} } { \caption{\cptn \quad [fig:\lbl]}\label{fig:\lbl}% From 7e2cc3ba6a30a693a96bbc37c4d8428d92ce1fa8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Fri, 19 Aug 2022 17:03:37 +0100 Subject: [PATCH 152/171] [assets] Unicode examples --- source/Makefile | 9 +++++++++ source/assets/example_01.pdf | Bin 0 -> 6007 bytes source/assets/example_01.tex | 14 ++++++++++++++ source/assets/example_02.pdf | Bin 0 -> 5189 bytes source/assets/example_02.tex | 14 ++++++++++++++ source/assets/example_03.pdf | Bin 0 -> 5859 bytes source/assets/example_03.tex | 14 ++++++++++++++ source/assets/example_04.pdf | Bin 0 -> 4576 bytes source/assets/example_04.tex | 14 ++++++++++++++ source/assets/example_05.pdf | Bin 0 -> 7959 bytes source/assets/example_05.tex | 14 ++++++++++++++ source/assets/example_06.pdf | Bin 0 -> 2527 bytes source/assets/example_06.tex | 10 ++++++++++ 13 files changed, 89 insertions(+) create mode 100644 source/assets/example_01.pdf create mode 100644 source/assets/example_01.tex create mode 100644 source/assets/example_02.pdf create mode 100644 source/assets/example_02.tex create mode 100644 source/assets/example_03.pdf create mode 100644 source/assets/example_03.tex create mode 100644 source/assets/example_04.pdf create mode 100644 source/assets/example_04.tex create mode 100644 source/assets/example_05.pdf create mode 100644 source/assets/example_05.tex create mode 100644 source/assets/example_06.pdf create mode 100644 source/assets/example_06.tex diff --git a/source/Makefile b/source/Makefile index 4f26b0b792..d4a2ff4064 100644 --- a/source/Makefile +++ b/source/Makefile @@ -1,4 +1,5 @@ FIGURES=$(patsubst %.dot,%.pdf,$(wildcard assets/*.dot)) +EXAMPLES=$(patsubst %.tex,%.pdf,$(wildcard assets/*.tex)) default: full @@ -21,3 +22,11 @@ clean-figures: rm -f $(FIGURES) figures: $(FIGURES) + +%.pdf: %.tex + lualatex -output-directory assets $< + +clean-examples: + rm -f $(EXAMPLES) + +examples: $(EXAMPLES) diff --git a/source/assets/example_01.pdf b/source/assets/example_01.pdf new file mode 100644 index 0000000000000000000000000000000000000000..2d4c06ffe43084062bd73d623eb4147005d84f7a GIT binary patch literal 6007 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 literal 0 HcmV?d00001 diff --git a/source/assets/example_02.tex b/source/assets/example_02.tex new file mode 100644 index 0000000000..0b48a5aacc --- /dev/null +++ b/source/assets/example_02.tex @@ -0,0 +1,14 @@ +\documentclass[9pt]{standalone} + +\usepackage{fontspec} + +\setmainfont{NewCM10-Regular} +\setmonofont{NewCMMono10-Regular} + +\newfontfamily\notoemoji{Noto Color Emoji}[Renderer=HarfBuzz] + +\newcommand{\emo}[1]{{\notoemoji\scriptsize #1}} + +\begin{document} +\emo{🤷🏻‍♂️} +\end{document} diff --git a/source/assets/example_03.pdf b/source/assets/example_03.pdf new file mode 100644 index 0000000000000000000000000000000000000000..74f7bd263cd5c2dcab28c2a0cec926095175a60d GIT binary patch literal 5859 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 W*nki$(j6c#FDC;K6x24=0sIS8@jVs* literal 0 HcmV?d00001 diff --git a/source/assets/example_03.tex b/source/assets/example_03.tex new file mode 100644 index 0000000000..17479d4b6d --- /dev/null +++ b/source/assets/example_03.tex @@ -0,0 +1,14 @@ +\documentclass[9pt]{standalone} + +\usepackage{fontspec} + +\setmainfont{NewCM10-Regular} +\setmonofont{NewCMMono10-Regular} + +\newfontfamily\notoemoji{Noto Color Emoji}[Renderer=HarfBuzz] + +\newcommand{\emo}[1]{{\notoemoji\scriptsize #1}} + +\begin{document} +\emo{🤷} +\end{document} diff --git a/source/assets/example_04.pdf b/source/assets/example_04.pdf new file mode 100644 index 0000000000000000000000000000000000000000..b02c6214d2c1d8d6430aaac4214099edceb4f7c4 GIT binary patch literal 4576 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 ad5uDZEP*gw0QmtV644mIU>FCjfIk7(Zztpc literal 0 HcmV?d00001 diff --git a/source/assets/example_06.tex b/source/assets/example_06.tex new file mode 100644 index 0000000000..f63b99cc89 --- /dev/null +++ b/source/assets/example_06.tex @@ -0,0 +1,10 @@ +\documentclass[9pt]{standalone} + +\usepackage{fontspec} + +\setmainfont{NewCM10-Regular} +\setmonofont{NewCMMono10-Regular} + +\begin{document} +\texttt{ẹ́} +\end{document} From 589af92ce99b91444a3e6155cb64f8009918e885 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Sun, 28 Aug 2022 02:09:47 +0100 Subject: [PATCH 153/171] [format.string.{std,escaped}, macros] Add missing examples --- source/macros.tex | 5 ++++- source/utilities.tex | 15 ++++++++++----- 2 files changed, 14 insertions(+), 6 deletions(-) diff --git a/source/macros.tex b/source/macros.tex index 2fb80ba799..928f0c845c 100644 --- a/source/macros.tex +++ b/source/macros.tex @@ -715,7 +715,8 @@ %%-------------------------------------------------- %% Environment for imported graphics %%-------------------------------------------------- -% usage: \begin{importgraphic}{CAPTION}{TAG}{FILE} +% usage: \begin{importgraphic}{CAPTION}{TAG}{FILE}\end{importgraphic} +% \importexample[VERTICAL OFFESET]{FILE} % % The filename is relative to the source/assets directory. @@ -730,6 +731,8 @@ \caption{\cptn \quad [fig:\lbl]}\label{fig:\lbl}% \end{figure}} +\newcommand{\importexample}[2][-0.9pt]{\raisebox{#1}{\includegraphics{assets/#2}}} + %%-------------------------------------------------- %% Definitions section for "Terms and definitions" %%-------------------------------------------------- diff --git a/source/utilities.tex b/source/utilities.tex index 5c7040244b..58e9e7d23d 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -1,4 +1,5 @@ %!TEX root = std.tex + \rSec0[utilities]{General utilities library} \rSec1[utilities.general]{General} @@ -15915,6 +15916,8 @@ string s8 = format("{:02}", 1234); // value of \tcode{s8} is \tcode{"1234"} string s9 = format("{:*<}", "12"); // value of \tcode{s9} is \tcode{"12"} string sA = format("{:*<6}", "12345678"); // value of \tcode{sA} is \tcode{"12345678"} +string sB = format("{:@\importexample[-2pt]{example_05}\caret{}@6}", "x"); // value of \tcode{sB} is \tcode{"\importexample[-2pt]{example_05}\importexample[-2pt]{example_05}x\importexample[-2pt]{example_05}\importexample[-2pt]{example_05}\importexample[-2pt]{example_05}"} +string sC = format("{:*@\caret{}@6}", "@\importexample[-2pt]{example_05}@"); // value of \tcode{sC} is \tcode{"\importexample[-2pt]{example_05}\importexample[-2pt]{example_05}\importexample[-2pt]{example_05}"} \end{codeblock} \end{example} \begin{note} @@ -15924,8 +15927,7 @@ because padding width is \tcode{0} in that case. Since fill characters are assumed to have a field width of \tcode{1}, use of a character with a different field width can produce misaligned output. -%FIXME: cannot show clown face character below. -The \unicode{1f921}{clown face} character has a field width of \tcode{2}. +The \importexample[-2pt]{example_05} (\unicode{1f921}{clown face}) character has a field width of \tcode{2}. The examples above that include that character illustrate the effect of the field width when that character is used as a fill character @@ -17142,16 +17144,19 @@ %% FIXME: their Unicode characters are not available in our font (Latin Modern). \begin{example} \begin{codeblock} -string s0 = format("[{}]", "h\tllo"); // \tcode{s0} has value: \tcode{[h\ \ \ \ llo]} -string s1 = format("[{:?}]", "h\tllo"); // \tcode{s1} has value: \tcode{["h\textbackslash tllo"]} -string s3 = format("[{:?}, {:?}]", '\'', '"'); // \tcode{s3} has value: \tcode{['\textbackslash '', '"']} +string s0 = format("[{}]", "h\tllo"); // \tcode{s0} has value: \tcode{[h\ \ \ \ llo]} +string s1 = format("[{:?}]", "h\tllo"); // \tcode{s1} has value: \tcode{["h\textbackslash tllo"]} +string s2 = format("[{:?}]", "@\importexample[-2.5pt]{example_01}@"); @\kern1.25pt@// \tcode{s2} has value: \tcode{["\importexample[-2.5pt]{example_01}"]} +string s3 = format("[{:?}, {:?}]", '\'', '"'); // \tcode{s3} has value: \tcode{['\textbackslash '', '"']} // The following examples assume use of the UTF-8 encoding string s4 = format("[{:?}]", string("\0 \n \t \x02 \x1b", 9)); // \tcode{s4} has value: \tcode{["\textbackslash u\{0\} \textbackslash n \textbackslash t \textbackslash u\{2\} \textbackslash u\{1b\}"]} string s5 = format("[{:?}]", "\xc3\x28"); // invalid UTF-8, \tcode{s5} has value: \tcode{["\textbackslash x\{c3\}("]} +string s6 = format("[{:?}]", "@\importexample{example_02}@"); @\kern0.75pt@// \tcode{s6} has value: \tcode{["\importexample{example_03}\textbackslash{u}\{200d\}\importexample{example_04}\textbackslash{u}\{fe0f\}"]} string s7 = format("[{:?}]", "\u0301"); // \tcode{s7} has value: \tcode{["\textbackslash u{301}"]} string s8 = format("[{:?}]", "\\\u0301"); // \tcode{s8} has value: \tcode{["\textbackslash \textbackslash \textbackslash u{301}"]} +string s9 = format("[{:?}]", "e\u0301\u0323"); // \tcode{s9} has value: \tcode{["\importexample[-2pt]{example_06}"]} \end{codeblock} \end{example} From f61a2c8a847e846ba1167c876b0fc1532ab433d7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Mon, 24 Jul 2023 21:27:00 +0100 Subject: [PATCH 154/171] [format.string.escape] Fix mis{sing,escaped} braces This was an oversight in the application of https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2713r0.html in e38ea31d46ca2964c4f9169f049e2f15e2cd5957. --- source/utilities.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/utilities.tex b/source/utilities.tex index 58e9e7d23d..12fcfed839 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -17154,8 +17154,8 @@ // \tcode{s4} has value: \tcode{["\textbackslash u\{0\} \textbackslash n \textbackslash t \textbackslash u\{2\} \textbackslash u\{1b\}"]} string s5 = format("[{:?}]", "\xc3\x28"); // invalid UTF-8, \tcode{s5} has value: \tcode{["\textbackslash x\{c3\}("]} string s6 = format("[{:?}]", "@\importexample{example_02}@"); @\kern0.75pt@// \tcode{s6} has value: \tcode{["\importexample{example_03}\textbackslash{u}\{200d\}\importexample{example_04}\textbackslash{u}\{fe0f\}"]} -string s7 = format("[{:?}]", "\u0301"); // \tcode{s7} has value: \tcode{["\textbackslash u{301}"]} -string s8 = format("[{:?}]", "\\\u0301"); // \tcode{s8} has value: \tcode{["\textbackslash \textbackslash \textbackslash u{301}"]} +string s7 = format("[{:?}]", "\u0301"); // \tcode{s7} has value: \tcode{["\textbackslash u\{301\}"]} +string s8 = format("[{:?}]", "\\\u0301"); // \tcode{s8} has value: \tcode{["\textbackslash \textbackslash \textbackslash u\{301\}"]} string s9 = format("[{:?}]", "e\u0301\u0323"); // \tcode{s9} has value: \tcode{["\importexample[-2pt]{example_06}"]} \end{codeblock} \end{example} From 3b2a8ee11725eb485df89dec40a7e0fc965debb2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johel=20Ernesto=20Guerrero=20Pe=C3=B1a?= Date: Fri, 21 Jul 2023 12:46:48 -0400 Subject: [PATCH 155/171] [func.wrap.ref.class] change deduction guide to match its detailed specifications --- source/utilities.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/utilities.tex b/source/utilities.tex index 12fcfed839..de5b358b4b 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -14130,8 +14130,8 @@ function_ref(F*) -> function_ref; template function_ref(nontype_t) -> function_ref<@\seebelow@>; - template - function_ref(nontype_t, auto) -> function_ref<@\seebelow@>; + template + function_ref(nontype_t, T&&) -> function_ref<@\seebelow@>; } \end{codeblock} From d5160c6ff6c09fc0c52b5b11676c03ff179f4554 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Sun, 23 Jul 2023 02:51:25 +0100 Subject: [PATCH 156/171] [mdspan.submdspan.extents] Factor out common result expression --- source/containers.tex | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/source/containers.tex b/source/containers.tex index 86731245a6..cd5c2a28a9 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -21817,20 +21817,17 @@ \returns A value \tcode{ext} of type \tcode{SubExtents} such that for each $k$ -for which \tcode{\placeholder{map-rank}[$k$] != dynamic_extent} is \tcode{true}: +for which \tcode{\placeholder{map-rank}[$k$] != dynamic_extent} is \tcode{true}, +\tcode{ext.extent(\placeholder{map-rank}[$k$])} equals: \begin{itemize} \item -\tcode{ext.extent(\placeholder{map-rank}[$k$])} equals -\tcode{$s_k$.extent == 0 ? 0 : 1 + (\exposid{de-ice}($s_k$.extent) - 1) /}\linebreak{} -\tcode{\exposid{de-ice}($s_k$.stride)} +\tcode{$s_k$.extent == 0 ? 0 : 1 + (\exposid{de-ice}($s_k$.extent) - 1) / \exposid{de-ice}($s_k$.stride)} if $S_k$ is a specialization of \tcode{strided_slice}, \item otherwise, -\tcode{ext.extent(\placeholder{map-rank}[$k$])} equals -\tcode{\exposid{last_}<$k$>(src, slices...) -} -\tcode{\exposid{first_}(slices...)}. +\tcode{\exposid{last_}<$k$>(src, slices...) - \exposid{first_}(slices...)}. \end{itemize} \end{itemdescr} From 84cf8ef63a479a3fda05a219dd26ab4b8c6a8e32 Mon Sep 17 00:00:00 2001 From: Jakub Mazurkiewicz Date: Tue, 25 Jul 2023 01:06:49 +0200 Subject: [PATCH 157/171] [mdspan.mdspan.cons] `OtherIndexType` is not a parameter pack; missing _v (#6263) --- source/containers.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/containers.tex b/source/containers.tex index cd5c2a28a9..4d8d192249 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -21199,7 +21199,7 @@ \item \tcode{is_convertible_v} is \tcode{true}, \item -\tcode{(is_nothrow_constructible \&\& ...)} is \tcode{true}, +\tcode{is_nothrow_constructible_v} is \tcode{true}, \item \tcode{N == rank() || N == rank_dynamic()} is \tcode{true}, \item From a636f553369825bc37ac0d95c171a00c526af499 Mon Sep 17 00:00:00 2001 From: lprv <100177227+lprv@users.noreply.github.com> Date: Mon, 24 Jul 2023 16:16:14 +0000 Subject: [PATCH 158/171] [intro.object] Fix cross-references for library implicit object creation --- source/basic.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/basic.tex b/source/basic.tex index d7b7e576b0..e5dcc0d553 100644 --- a/source/basic.tex +++ b/source/basic.tex @@ -3393,7 +3393,7 @@ returns a pointer to a suitable created object. \begin{note} Some functions in the \Cpp{} standard library implicitly create objects% -\iref{obj.lifetime,allocator.traits.members,c.malloc,cstring.syn,bit.cast}. +\iref{obj.lifetime,c.malloc,mem.res.public,bit.cast,cstring.syn}. \end{note} \indextext{object model|)} From d09a77e09a5210c50994b89d999f3cbdfcc9a436 Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Wed, 17 May 2023 18:51:00 +0100 Subject: [PATCH 159/171] [re.results.general, string.cons] Fix references to container reqmts [re.results.general] should refer to [container.alloc.reqmts] for an allocator-aware container, [strings.cons] should refer to sequence container requirements. --- source/regex.tex | 2 +- source/strings.tex | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/source/regex.tex b/source/regex.tex index dcd432b3e1..eb015cc6ed 100644 --- a/source/regex.tex +++ b/source/regex.tex @@ -2132,7 +2132,7 @@ \indextext{requirements!sequence}% The class template \tcode{match_results} meets the requirements of an allocator-aware container and of -a sequence container\iref{container.requirements.general,sequence.reqmts} +a sequence container\iref{container.alloc.reqmts,sequence.reqmts} except that only copy assignment, move assignment, and diff --git a/source/strings.tex b/source/strings.tex index 31e778e991..659a6097bd 100644 --- a/source/strings.tex +++ b/source/strings.tex @@ -2725,7 +2725,7 @@ \begin{itemdescr} \pnum \effects -Move assigns as a sequence container\iref{container.requirements}, +Move assigns as a sequence container\iref{sequence.reqmts}, except that iterators, pointers and references may be invalidated. \pnum From dd32b7eeb21e0ca8be7aae1996814a2ffda0ed83 Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Thu, 18 May 2023 12:54:12 +0100 Subject: [PATCH 160/171] [container.gen.reqmts] Adjust subclause names and stable tags There are no more cross-references to [container.gen.reqmts] or [container.requirements.general], so this doesn't affect anything else. --- source/containers.tex | 8 ++++---- source/xrefdelta.tex | 3 +++ 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/source/containers.tex b/source/containers.tex index 4d8d192249..77cde090b4 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -69,12 +69,12 @@ aligned buffers and call \tcode{construct} to place the element into the buffer. \end{note} -\rSec2[container.gen.reqmts]{General containers} +\rSec2[container.requirements.general]{General containers} -\rSec3[container.requirements.general]{General} +\rSec3[container.intro.reqmts]{Introduction} \pnum -In subclause \ref{container.gen.reqmts}, +In subclause \ref{container.requirements.general}, \begin{itemize} \item \tcode{X} denotes a container class containing objects of type \tcode{T}, @@ -103,7 +103,7 @@ ranges::@\libconcept{input_range}@ && @\libconcept{convertible_to}@, T>; \end{codeblock} -\rSec3[container.reqmts]{Containers} +\rSec3[container.reqmts]{Container requirements} % Local command to index names as members of all containers. \newcommand{\indexcont}[1]{% diff --git a/source/xrefdelta.tex b/source/xrefdelta.tex index cce5770ba8..0dfd2c1380 100644 --- a/source/xrefdelta.tex +++ b/source/xrefdelta.tex @@ -30,6 +30,9 @@ % \movedxrefiii{old.label}{new.label.1}{new.label.2}{new.label.3} % \movedxrefs{old.label}{new place (e.g., \tref{blah})} +% https://github.com/cplusplus/draft/pull/6255 +\movedxref{container.gen.reqmts}{container.requirements.general} + %%% Deprecated features. %%% Example: % From a0e6740cda724c192ea14979e2fa92e9f38cf242 Mon Sep 17 00:00:00 2001 From: Janet Cobb Date: Mon, 24 Jul 2023 12:09:44 -0400 Subject: [PATCH 161/171] [basic.fundamental] Clarify that table of minimum integral type widths applies only to standard integral types --- source/basic.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/basic.tex b/source/basic.tex index e5dcc0d553..0f0473e3d9 100644 --- a/source/basic.tex +++ b/source/basic.tex @@ -4970,7 +4970,7 @@ \end{floattable} \pnum -The width of each signed integer type +The width of each standard signed integer type shall not be less than the values specified in \tref{basic.fundamental.width}. The value representation of a signed or unsigned integer type comprises $N$ bits, where N is the respective width. From 3a2586ccb4112f32f08643f7fcafab0b6b7956e2 Mon Sep 17 00:00:00 2001 From: Joshua Berne Date: Fri, 28 Jul 2023 15:31:51 -0400 Subject: [PATCH 162/171] [dcl.attr.grammar] Fix typo "appeartain" -> "appertain" (#6420) --- source/declarations.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/declarations.tex b/source/declarations.tex index a12259501d..d4302e71cd 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -8651,7 +8651,7 @@ appertains to a friend declaration\iref{class.friend}, that declaration shall be a definition. \begin{note} -An \grammarterm{attribute-specifier-seq} cannot appeartain to +An \grammarterm{attribute-specifier-seq} cannot appertain to an explicit instantiation\iref{temp.explicit}. \end{note} From 00b4bb25e7b881cc53dca91dd44ef87c9696b19c Mon Sep 17 00:00:00 2001 From: Jan Schultke Date: Sun, 13 Aug 2023 22:35:57 +0200 Subject: [PATCH 163/171] [over.ics.list] Fix missing std:: in example (#6453) --- source/overloading.tex | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/overloading.tex b/source/overloading.tex index 9e187abfff..2c02f343f8 100644 --- a/source/overloading.tex +++ b/source/overloading.tex @@ -2424,9 +2424,9 @@ f( {1.0} ); // error: narrowing struct A { - A(std::initializer_list); // \#1 - A(std::initializer_list>); // \#2 - A(std::initializer_list); // \#3 + A(std::initializer_list); // \#1 + A(std::initializer_list>); // \#2 + A(std::initializer_list); // \#3 }; A a{ 1.0,2.0 }; // OK, uses \#1 From cf7d5820d2ab8352d96462c647b735dc575cc1cb Mon Sep 17 00:00:00 2001 From: Alisdair Meredith Date: Tue, 15 Aug 2023 00:12:21 +0200 Subject: [PATCH 164/171] [depr.static.constexpr] Cross-reference core clauses for deprecated feature (#6448) --- source/basic.tex | 2 +- source/future.tex | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/source/basic.tex b/source/basic.tex index 0f0473e3d9..62ae3796ac 100644 --- a/source/basic.tex +++ b/source/basic.tex @@ -182,7 +182,7 @@ \item it declares a static data member outside a class definition and the variable was defined within the class with the \keyword{constexpr} -specifier (this usage is deprecated; see \ref{depr.static.constexpr}), +specifier\iref{class.static.data} (this usage is deprecated; see \ref{depr.static.constexpr}), \item \indextext{declaration!class name}% it is an \grammarterm{elaborated-type-specifier}\iref{class.name}, diff --git a/source/future.tex b/source/future.tex index 3fad5ca3e3..450109745c 100644 --- a/source/future.tex +++ b/source/future.tex @@ -140,7 +140,8 @@ \pnum For compatibility with prior revisions of \Cpp{}, a \keyword{constexpr} -static data member may be redundantly redeclared outside the class with no initializer. +static data member may be redundantly redeclared outside the class with no +initializer\iref{basic.def,class.static.data}. This usage is deprecated. \begin{example} \begin{codeblock} From 1353359777de653346dd05ed117bba3627b6c7ca Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Tue, 24 Jan 2023 18:51:02 +0100 Subject: [PATCH 165/171] [class.mem.general] Clarify class completeness --- source/classes.tex | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/source/classes.tex b/source/classes.tex index baaccc2cb9..d0235a3f3c 100644 --- a/source/classes.tex +++ b/source/classes.tex @@ -605,11 +605,10 @@ \end{note} \pnum -A class is regarded as complete -where its definition is reachable and -within its complete-class contexts; -otherwise it is regarded as incomplete within its own class -\grammarterm{member-specification}. +A class \tcode{C} is complete at a program point $P$ +if the definition of \tcode{C} is reachable from $P$\iref{module.reach} +or if $P$ is in a complete-class context of \tcode{C}. +Otherwise, \tcode{C} is incomplete at $P$. \pnum In a \grammarterm{member-declarator}, From 77d1b66193d5324b121979474d0e35645bbcfb1c Mon Sep 17 00:00:00 2001 From: "A. Jiang" Date: Tue, 1 Aug 2023 13:39:55 +0800 Subject: [PATCH 166/171] [memory.syn] Remove redundant freestanding mark for members Making `allocator_arg_t` shown like `from_range_t` in [ranges.syn]. --- source/memory.tex | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/source/memory.tex b/source/memory.tex index a6cde5dbf2..e77503a8c4 100644 --- a/source/memory.tex +++ b/source/memory.tex @@ -104,9 +104,7 @@ size_t n) noexcept; // \ref{allocator.tag}, allocator argument tag - struct allocator_arg_t { // freestanding - explicit allocator_arg_t() = default; // freestanding - }; + struct allocator_arg_t { explicit allocator_arg_t() = default; }; // freestanding inline constexpr allocator_arg_t allocator_arg{}; // freestanding // \ref{allocator.uses}, \tcode{uses_allocator} From bf304328b603d96b9da5dc38dfeb04057c67cc53 Mon Sep 17 00:00:00 2001 From: "A. Jiang" Date: Tue, 1 Aug 2023 13:42:07 +0800 Subject: [PATCH 167/171] [ranges.syn] Remove redundant freestanding mark for members --- source/ranges.tex | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/source/ranges.tex b/source/ranges.tex index eaddf6ba39..920e777617 100644 --- a/source/ranges.tex +++ b/source/ranges.tex @@ -552,19 +552,19 @@ : integral_constant {}; template struct tuple_element<0, ranges::subrange> { // freestanding - using type = I; // freestanding + using type = I; }; template struct tuple_element<1, ranges::subrange> { // freestanding - using type = S; // freestanding + using type = S; }; template struct tuple_element<0, const ranges::subrange> { // freestanding - using type = I; // freestanding + using type = I; }; template struct tuple_element<1, const ranges::subrange> { // freestanding - using type = S; // freestanding + using type = S; }; struct from_range_t { explicit from_range_t() = default; }; // freestanding From ffe255330e46613a80d8a37e081c2f023fec219d Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Mon, 14 Aug 2023 21:49:36 +0200 Subject: [PATCH 168/171] [lib] Avoid redundant \tcode{\exposid{...}} and add a check --- source/containers.tex | 12 ++++++------ source/locales.tex | 6 +++--- source/ranges.tex | 2 +- tools/check-source.sh | 4 ++++ 4 files changed, 14 insertions(+), 10 deletions(-) diff --git a/source/containers.tex b/source/containers.tex index 77cde090b4..21abef6cad 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -18389,8 +18389,8 @@ \pnum \effects -Initializes \tcode{\exposid{data_}} with \tcode{to_address(first)} and -\tcode{\exposid{size_}} with \tcode{count}. +Initializes \exposid{data_} with \tcode{to_address(first)} and +\exposid{size_} with \tcode{count}. \pnum \throws @@ -18432,8 +18432,8 @@ \pnum \effects -Initializes \tcode{\exposid{data_}} with \tcode{to_address(first)} and -\tcode{\exposid{size_}} with \tcode{last - first}. +Initializes \exposid{data_} with \tcode{to_address(first)} and +\exposid{size_} with \tcode{last - first}. \pnum \throws @@ -18510,8 +18510,8 @@ \pnum \effects -Initializes \tcode{\exposid{data_}} with \tcode{ranges::data(r)} and -\tcode{\exposid{size_}} with \tcode{ranges::size(r)}. +Initializes \exposid{data_} with \tcode{ranges::data(r)} and +\exposid{size_} with \tcode{ranges::size(r)}. \pnum \throws diff --git a/source/locales.tex b/source/locales.tex index ce87b0d573..e36f215d68 100644 --- a/source/locales.tex +++ b/source/locales.tex @@ -4855,7 +4855,7 @@ \begin{itemdescr} \pnum \returns -\tcode{\exposid{mib_}}. +\exposid{mib_}. \end{itemdescr} \indexlibrarymember{name}{text_encoding}% @@ -4866,7 +4866,7 @@ \begin{itemdescr} \pnum \returns -\tcode{\exposid{name_}} if \tcode{(\exposid{name_}[0] != '\textbackslash 0')} +\exposid{name_} if \tcode{(\exposid{name_}[0] != '\textbackslash 0')} is \tcode{true}, and \keyword{nullptr} otherwise. @@ -4874,7 +4874,7 @@ \remarks If \tcode{name() == nullptr} is \tcode{false}, \tcode{name()} is an \ntbs{} and -accessing elements of \tcode{\exposid{name_}} +accessing elements of \exposid{name_} outside of the range \countedrange{name()}{strlen(name()) + 1} is undefined behavior. \end{itemdescr} diff --git a/source/ranges.tex b/source/ranges.tex index 920e777617..db6e8be4e8 100644 --- a/source/ranges.tex +++ b/source/ranges.tex @@ -13529,7 +13529,7 @@ using @\exposid{Base}@ = @\exposid{maybe-const}@; // \expos iterator_t<@\exposid{Base}@> @\exposid{current_}@ = iterator_t<@\exposid{Base}@>(); // \expos iterator_t<@\exposid{Base}@> @\exposid{last_ele_}@ = iterator_t<@\exposid{Base}@>(); // \expos, - // present only if \tcode{\exposid{Base}} models \tcode{\exposconcept{slide-caches-first}} + // present only if \exposid{Base} models \tcode{\exposconcept{slide-caches-first}} range_difference_t<@\exposid{Base}@> @\exposid{n_}@ = 0; // \expos constexpr @\exposid{iterator}@(iterator_t<@\exposid{Base}@> current, range_difference_t<@\exposid{Base}@> n) // \expos diff --git a/tools/check-source.sh b/tools/check-source.sh index 3af7f80691..97c15335e4 100755 --- a/tools/check-source.sh +++ b/tools/check-source.sh @@ -83,6 +83,10 @@ fgrep -n '\^' $texfiles | grep -n 'U+' $texfiles | fail 'use \\unicode or \\ucode or \\uname instead' || failed=1 +# Discourage double-wrapping \tcode{\exposid{data_}} +grep -n '\\tcode{\\exposid{[a-zA-Z0-9_]*}}' $texfiles | + fail 'double-wrapped \\exposid in \\tcode' || failed=1 + # Hex digits inside \ucode and \unicode must be lowercase so that \textsc works grep -n 'ucode{[^}]*[^0-9a-f}][^}]*}' $texfiles | fail 'use lowercase hex digits inside \\ucode' || failed=1 From d347b328e058bb4b357a2b7b4733c923fca6fd98 Mon Sep 17 00:00:00 2001 From: Jan Schultke Date: Tue, 15 Aug 2023 00:42:54 +0200 Subject: [PATCH 169/171] [temp.over] itemize parts of long paragraph (#6443) --- source/templates.tex | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/source/templates.tex b/source/templates.tex index 67600f17e5..2dab2f99dc 100644 --- a/source/templates.tex +++ b/source/templates.tex @@ -8757,16 +8757,18 @@ can be used with that function template to instantiate a function template specialization that can be invoked with the call arguments or, for conversion function templates, that can convert to the required type. -For each function template, if the argument deduction and checking succeeds, -the +For each function template: +\begin{itemize} +\item If the argument deduction and checking succeeds, the \grammarterm{template-argument}{s} (deduced and/or explicit) are used to synthesize the declaration of a single function template specialization which is added to the candidate functions set to be used in overload resolution. -If, for a given function template, argument deduction fails or +\item If the argument deduction fails or the synthesized function template specialization would be ill-formed, no such function is added to the set of candidate functions for that template. +\end{itemize} The complete set of candidate functions includes all the synthesized declarations and all of the non-template functions found by name lookup. The synthesized declarations are From e34a8e15e1de7eab0980af328765957c6118fc04 Mon Sep 17 00:00:00 2001 From: Jan Schultke Date: Tue, 15 Aug 2023 00:45:43 +0200 Subject: [PATCH 170/171] [meta.unary.prop] itemize long sentence (#6436) --- source/meta.tex | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/source/meta.tex b/source/meta.tex index 82c1f374c9..1ae428cfe9 100644 --- a/source/meta.tex +++ b/source/meta.tex @@ -1344,11 +1344,13 @@ \item \tcode{T} is trivially copyable, and \item any two objects of type \tcode{T} with the same value have the same object representation, where -two objects of array or non-union class type are considered to have the same value +\begin{itemize} +\item two objects of array or non-union class type are considered to have the same value if their respective sequences of direct subobjects have the same values, and -two objects of union type are considered to have the same value +\item two objects of union type are considered to have the same value if they have the same active member and the corresponding members have the same value. \end{itemize} +\end{itemize} The set of scalar types for which this condition holds is \impldef{which scalar types have unique object representations}. \begin{note} From 956f85984bc513af58379c39881df6073583042d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20K=C3=B6ppe?= Date: Mon, 14 Aug 2023 00:17:29 +0100 Subject: [PATCH 171/171] Update configuration for new working draft N4958 and add corresponding Editors' Report N4959 --- papers/n4959.html | 698 +++++++++++++++++++++++++++++++++++++++++++++ papers/n4959.md | 553 +++++++++++++++++++++++++++++++++++ papers/wd-index.md | 1 + source/config.tex | 2 +- 4 files changed, 1253 insertions(+), 1 deletion(-) create mode 100644 papers/n4959.html create mode 100644 papers/n4959.md diff --git a/papers/n4959.html b/papers/n4959.html new file mode 100644 index 0000000000..958923da9f --- /dev/null +++ b/papers/n4959.html @@ -0,0 +1,698 @@ + + + + + +Codestin Search App + + +

N4959 Editors' Report -- Programming Languages -- C++

+ +

Date: 2023-08-14

+ +

Thomas Köppe (editor, Google DeepMind)
+Jens Maurer (co-editor)
+Dawn Perchik (co-editor, Bright Side Computing, LLC)
+Richard Smith (co-editor, Google Inc)

+ +

Email: cxxeditor@gmail.com

+ +

Acknowledgements

+ + + +

New papers

+ +
    +
  • N4958 is the +current working draft for C++26. It replaces +N4950.
    • +
  • N4959 is this Editors' Report.
    • +
+ +

Motions incorporated into working draft

+ +

Notes on motions

+ +

All motions were applied cleanly. In a small number of cases, the approved +wording was based on an older draft and needed reconciliation with intervening +changes, but it was clear how to do this.

+ +
    +
  • The wording for P1854R4 +("Making non-encodable string literals ill-formed", CWG Poll 3) +has been reconciled with previous changes from +P2314R4 +("Character sets and encodings").
    • +
  • For P0792R14 +("function_ref: a type-erased callable reference", LWG Poll 18), +among some minor fixes for correctness and consistency, +exposition-only members have been added explicitly to the class synopsis, +which had only been mentioned in the descriptive text in the approved wording.
    • +
  • The feature test macro __cpp_lib_format has been modified three times, as follows: +
      +
    • 202304L by +P2510R3 +("Formatting pointers", LWG Poll 10)
      • +
    • 202305L by +P2757R3 +("Type checking format args", LWG Poll 20)
      • +
    • 202306L by +P2637R3 +("Member visit", LWG Poll 21)
      • +
    • +
  • The feature test macro for +P2641R4 +("Checking if a union alternative is active", LWG Poll 22) +has been renamed from __cpp_lib_within_lifetime to __cpp_lib_is_within_lifetime, +which seems more appropriate and follows existing practice.
    • +
  • For P2630R4 +(submdspan, LWG Poll 29), numerous minor editorial corrections and improvements +have been applied; see the full commit log for details.
    • +
+ +

Core working group polls

+ +

CWG Poll 1: Accept as Defect Reports and apply the proposed resolutions of all issues in +P2922R0 +(Core Language Working Group "ready" Issues for the June, 2023 meeting) to the C++ Working Paper.

+ +

CWG Poll 2: Accept as a Defect Report and apply the changes in +P2621R2 +(UB? In my Lexer?) to the C++26 Working Paper.

+ +

CWG Poll 3: Accept as a Defect Report and apply the changes in +P1854R4 +(Making non-encodable string literals ill-formed) to the C++26 Working Paper.

+ +

CWG Poll 4: Apply the changes in P2361R6 +(Unevaluated strings) to the C++26 Working Paper.

+ +

CWG Poll 5: Apply the changes in P2558R2 +(Add @, $, and ` to the basic character set) to the C++26 Working Paper.

+ +

CWG Poll 6: Apply the changes in P2738R1 +(constexpr cast from void*: towards constexpr type-erasure) to the C++26 Working Paper.

+ +

CWG Poll 7: Accept as a Defect Report and apply the changes in +P2915R0 +(Proposed resolution for CWG1223) to the C++26 Working Paper.

+ +

CWG Poll 8: Accept as a Defect Report and apply the changes in +P2552R3 +(On the ignorability of standard attributes) to the C++26 Working Paper.

+ +

CWG Poll 9: Accept as a Defect Report and apply the changes in +P2752R3 +(Static storage for braced initializers) to the C++26 Working Paper.

+ +

CWG Poll 10: Apply the changes in P2741R3 +(User-generated static_assert messages) to the C++26 Working Paper.

+ +

CWG Poll 11: Apply the changes in P2169R4 +(A nice placeholder with no name) to the C++26 Working Paper.

+ +

Library working group polls

+ +

LWG Poll 1: Apply the changes for all Tentatively Ready issues in +P2910R0 +(C++ Standard Library Issues to be moved in Varna, Jun. 2023) to the C++ working paper.

+ +

LWG Poll 2: Apply the changes in P2497R0 +(Testing for success or failure of <charconv> functions) to the C++ working paper.

+ +

LWG Poll 3: Apply the changes in P2592R3 +(Hashing support for std::chrono value classes) to the C++ working paper.

+ +

LWG Poll 4: Apply the changes in P2587R3 +(to_string or not to_string) to the C++ working paper.

+ +

LWG Poll 5: Apply the changes in P2562R1 +(constexpr Stable Sorting) to the C++ working paper.

+ +

LWG Poll 6: Apply the changes in P2545R4 +(Read-Copy Update (RCU)) to the C++ working paper.

+ +

LWG Poll 7: Apply the changes in P2530R3 +(Hazard Pointers for C++26) to the C++ working paper.

+ +

LWG Poll 8: Apply the changes in P2538R1 +(ADL-proof std::projected) to the C++ working paper.

+ +

LWG Poll 9: Apply the changes in P2495R3 +(Interfacing stringstreams with string_view) to the C++ working paper.

+ +

LWG Poll 10: Apply the changes in P2510R3 +(Formatting pointers) to the C++ working paper.

+ +

LWG Poll 11: Apply the changes in P2198R7 +(Freestanding Feature-Test Macros and Implementation-Defined Extensions) to the C++ working paper.

+ +

LWG Poll 12: Apply the changes in P2338R4 +(Freestanding Library: Character primitives and the C library) to the C++ working paper.

+ +

LWG Poll 13: Apply the changes in P2013R5 +(Freestanding Language: Optional ::operator new) to the C++ working paper.

+ +

LWG Poll 14: Apply the changes in P0493R4 +(Atomic maximum/minimum) to the C++ working paper.

+ +

LWG Poll 15: Apply the changes in P2363R5 +(Extending associative containers with the remaining heterogeneous overloads) to the C++ working paper.

+ +

LWG Poll 16: Apply the changes in P1901R2 +(Enabling the Use of weak_ptr as Keys in Unordered Associative Containers) to the C++ working paper.

+ +

LWG Poll 17: Apply the changes in P1885R12 +(Naming Text Encodings to Demystify Them) to the C++ working paper.

+ +

LWG Poll 18: Apply the changes in P0792R14 +(function_ref: a type-erased callable reference) to the C++ working paper.

+ +

LWG Poll 19: Apply the changes in P2874R2 +(Mandating Annex D) to the C++ working paper.

+ +

LWG Poll 20: Apply the changes in P2757R3 +(Type checking format args) to the C++ working paper.

+ +

LWG Poll 21: Apply the changes in P2637R3 +(Member visit) to the C++ working paper.

+ +

LWG Poll 22: Apply the changes in P2641R4 +(Checking if a union alternative is active) to the C++ working paper.

+ +

LWG Poll 23: Apply the changes in P1759R6 +(Native handles and file streams) to the C++ working paper.

+ +

LWG Poll 24: Apply the changes in P2697R1 +(Interfacing bitset with string_view) to the C++ working paper.

+ +

LWG Poll 25: Apply the changes in P1383R2 +(More constexpr for <cmath> and <complex>) to the C++ working paper.

+ +

LWG Poll 26: Apply the changes in P2734R0 +(Adding the new 2022 SI prefixes) to the C++ working paper.

+ +

LWG Poll 27: Apply the changes in P2548R6 +(copyable_function) to the C++ working paper.

+ +

LWG Poll 28: Apply the changes in P2714R1 +(Bind front and back to NTTP callables) to the C++ working paper.

+ +

LWG Poll 29: Apply the changes in P2630R4 +(submdspan) to the C++ working paper.

+ +

Editorial changes

+ +

Noteworthy changes

+ +

Some Unicode examples of the new formatting facilities had been missing from the +last few working drafts (but are present in the C++23 DIS) because they needed +some bespoke handling. This has now been integrated into the main branch, and +the examples now appear correctly in the working draft. (The examples are +generated with LuaTeX. As a side effect, the typeface used in existing diagrams +has been changed to match the one used for the main body text. We have also +explored switching the typesetting engine for the main document from eTeX to +LuaTeX. This is possible in principle, but results in slightly lower typographic +quality at the moment, so we are holding off on this and will revisit this +change in the future.)

+ +

The title of the working draft has been changed to "Working Draft, Programming +Languages — C++", to match the official title of the standard more closely.

+ +

Minor editorial changes

+ +

A log of editorial fixes made to the working draft since N4950 is below. This +list excludes changes that do not affect the body text or only affect whitespace +or typeface. For a complete list including such changes (or for the actual +deltas applied by these changes), consult the draft sources on +github.

+ +
commit abb81facf56f82a7487b3f64ae337ce2802c4bf3
+Author: Jens Maurer <Jens.Maurer@gmx.net>
+Date:   Fri May 12 09:38:16 2023 +0200
+
+    [intro.execution] Fix bad function call in example
+
+commit 42f21d84fb374b11d44c0b367bda649636128b6a
+Author: Andrew Rogers <adr26__github@nunsway.co.uk>
+Date:   Wed Apr 19 01:03:57 2023 +0100
+
+    [dcl.init.aggr] Add missing apostrophe
+
+commit 4514233a48954d0fd0669236cc986640e33feb04
+Author: lprv <100177227+lprv@users.noreply.github.com>
+Date:   Fri May 12 23:14:43 2023 +0200
+
+    [basic.compound] Fix cross-reference for 'incomplete type' (#6210)
+
+commit 4fac9f97a2c25d39a01f75cf198d0783bfa8deda
+Author: Jonathan Wakely <cxx@kayari.org>
+Date:   Tue May 16 17:01:51 2023 +0100
+
+    [strings], [unord.req.general], [stringbuf.members]: Fix xrefs to [container.requirements.general]
+
+    All the references for "qualifies as an input iterator" and "qualifies
+    as an allocator" are supposed to be to [container.reqmts] p69 which
+    begins:
+
+    > The behavior of certain container member functions and deduction
+    > guides depends on whether types qualify as input iterators or
+    > allocators.
+
+    The reference in [string.require] for obtaining an allocator should be
+    to [container.reqmts] p64.
+
+    The reference in [string.require] Note 2 should be to
+    [container.requirements.pre] p3.
+
+    Fixes #6184
+
+commit 1be4801ac1f90aca9a8f5804a48e8bcd082f5bb9
+Author: lprv <100177227+lprv@users.noreply.github.com>
+Date:   Thu Jun 1 20:57:05 2023 +0200
+
+    [lib] Refer to exposition-only function templates as templates, not functions (#6265)
+
+     * [tuple.apply]/1, /4
+     * [expected.object.assign]/1
+     * [iterator.cust.swap]/2
+     * [specialized.algorithms.general]/3
+
+commit c0685a584ea51d3e47381478a750729da3202b37
+Author: Géry Ogam <gery.ogam@gmail.com>
+Date:   Tue Jun 13 18:21:59 2023 +0200
+
+    [basic.lval] Reword the misused term ‘classifications’ (#4913)
+
+commit ae4cba4dc8ee2437f39a451268ad6bc924076da0
+Author: Thomas Köppe <tkoeppe@google.com>
+Date:   Tue Jun 20 13:29:38 2023 +0100
+
+    [cover-wd] A more appropriate title, and better line spacing
+
+commit 7e7afe0965e4e16ff651167212ea05ed9c0ef788
+Author: Eisenwave <me@eisenwave.net>
+Date:   Thu Jul 6 12:45:54 2023 +0200
+
+    [expr.mul] Add missing commas (#6366)
+
+commit 384d36a0d30e6a8050e23f7193db40fb56ff4f06
+Author: Jonathan Wakely <cxx@kayari.org>
+Date:   Thu Jul 6 20:45:10 2023 +0100
+
+    [filebuf.virtuals] fix "if width if less than zero" typo
+
+commit 964015779245341d64d93bbd0d1e11f050b32e70
+Author: Hewill Kang <67143766+hewillk@users.noreply.github.com>
+Date:   Mon Jul 10 18:53:10 2023 +0800
+
+    [time.duration.cons] Fix duplicate definition in example (#6372)
+
+commit e6c2f8fb0d5ad6cda3e2d3da63bd5d5e434635b4
+Author: Thomas Köppe <tkoeppe@google.com>
+Date:   Tue Jul 18 23:16:59 2023 +0100
+
+    [diff.cpp23.expr] Fix environment ("example" should be "codeblock")
+
+commit 2109f579cc6749d19ddf9cf892e8aec4762ba344
+Author: Thomas Köppe <tkoeppe@google.com>
+Date:   Fri Jul 21 16:21:54 2023 +0100
+
+    [locale.general] Add cross-references to class synopsis
+
+commit c2e05a4080e8c79bcc9971054ca6fb6ae9b3e722
+Author: Thomas Köppe <tkoeppe@google.com>
+Date:   Fri Jul 21 17:05:10 2023 +0100
+
+    [functional.syn] Tweak cross-references in class synopsis
+
+commit 8334cc876d29595f0f2796a6de42acae937d8377
+Author: Thomas Köppe <tkoeppe@google.com>
+Date:   Fri Jul 21 23:29:54 2023 +0100
+
+    [functional.syn, func.wrap.move] Hyphenate "move-only wrapper"
+
+commit 7fb62d5f50bfbfc159df4ca0af932ee82d26bc41
+Author: Thomas Köppe <tkoeppe@google.com>
+Date:   Fri Jul 21 18:13:28 2023 +0100
+
+    [version.syn] Rename smart_pointer_owner_equality to smart_ptr_owner_equality
+
+    For consistency: the use of "ptr" is already prevailing.
+
+commit 56a6b7fe068726ace9196366c968cc679653cc04
+Author: Hewill Kang <67143766+hewillk@users.noreply.github.com>
+Date:   Wed May 17 23:27:22 2023 +0800
+
+    <ranges> Add missing colon for the Effects: Equivalent to return format
+
+commit a34d2e08bda9b1314ecec1b608745a88a678d664
+Author: vasama <git@vasama.org>
+Date:   Wed Jun 7 11:01:02 2023 +0300
+
+    [expr.pre] Clarify note on pointer subtraction
+
+commit 96f695aea7589a62e5ebb55a18a40f985f7d89ce
+Author: Thomas Köppe <tkoeppe@google.com>
+Date:   Tue Jun 13 09:18:01 2023 +0300
+
+    [basic.def.odr] Restructure requirements in p14-p15
+
+commit ebba9f316ddd8c120608447b00ea32bf3926a18d
+Author: Jonathan Wakely <cxx@kayari.org>
+Date:   Sun Jul 23 02:29:17 2023 +0100
+
+    [func.wrap.func.general, func.wrap.move.class] Remove redundant declaration (#6273)
+
+    We don't need to repeat the declarations of the incomplete primary
+    template, they are already present in the <functional> synopsis.
+
+commit e6bd946d953b76e908a8e853d93834572c125d59
+Author: Richard Smith <richard@metafoo.co.uk>
+Date:   Fri Jul 14 13:31:47 2023 -0700
+
+    [basic.scope.scope] Avoid hard-to-read except...unless construction.
+
+    Factor out a name for the "unless" condition to avoid the double-negative.
+
+commit 3769c701daf9ae38f8db054670106abca7c03d32
+Author: Roger Orr <rogero@howzatt.co.uk>
+Date:   Tue Jul 18 23:54:34 2023 +0100
+
+    [dcl.ambig.res] fix double declaration of 'y' in example
+
+commit 0bf51a3bc5c24b070265412c32e53a0060d73eef
+Author: Christian Trott <crtrott@sandia.gov>
+Date:   Sat Jul 22 19:33:41 2023 -0600
+
+    [mdspan.layout.stride.cons] Fix missed rename of template parameter (#6385)
+
+    "LayoutStrideMapping" should say "StridedLayoutMapping".
+
+commit f8feaa6e5bc8e6d28e00c06a3de305f80f395913
+Author: Eelis van der Weegen <eelis@eelis.net>
+Date:   Fri Jul 21 11:43:39 2023 +0200
+
+    [version.syn] Fix header references.
+
+commit 872bda08678d1aeecfc555f26920cec28a2ad497
+Author: lprv <100177227+lprv@users.noreply.github.com>
+Date:   Thu Jun 1 14:59:00 2023 +0000
+
+    [basic.stc.dynamic.allocation] Remove redundant 'address of' from a note
+
+commit 880531fad125c4b806300151ddcb961a7f44a181
+Author: Arthur O'Dwyer <arthur.j.odwyer@gmail.com>
+Date:   Sat Jul 22 21:49:38 2023 -0400
+
+    [flat.{,multi}{map,set}.cons]: zip_view should be views::zip (#6373)
+
+    We don't expect to use CTAD on `ranges::zip_view(args...)`;
+    what we expect is `views::zip`.
+
+commit a417ade53722d944481baac575292874c1bcc79a
+Author: Johel Ernesto Guerrero Peña <johelegp@gmail.com>
+Date:   Sat Jul 22 21:50:37 2023 -0400
+
+    [range.enumerate.overview] Add cross reference to [range.adaptor.object] (#6219)
+
+commit 7f100cc67b0bb263e2f438238e87555347ae45c0
+Author: Hewill Kang <67143766+hewillk@users.noreply.github.com>
+Date:   Sun Jul 23 17:50:27 2023 +0800
+
+    [input.output] Fix the "Effects: Equivalent to" format (#6402)
+
+commit 9334219bd95a85e86b20c8a712397f9f23f0f7a8
+Author: Jens Maurer <Jens.Maurer@gmx.net>
+Date:   Sun Jul 23 06:59:28 2023 +0200
+
+    [class.copy.assign] Remove note obsoleted by CWG2586
+
+commit 503b4b261061bdd2481e1e4f1153481a0a75ecee
+Author: Jens Maurer <Jens.Maurer@gmx.net>
+Date:   Sun Jul 23 08:29:10 2023 +0200
+
+    [dcl.fct.def.default] Highlight different references in defaulted assignments
+
+commit a567088b0ab8ca62f0ff5a7b4746337ac3f6df9b
+Author: Thomas Köppe <tkoeppe@google.com>
+Date:   Mon Jul 24 12:45:57 2023 +0100
+
+    [assets] Move separate assets into "assets" subdirectory
+
+commit 7e2cc3ba6a30a693a96bbc37c4d8428d92ce1fa8
+Author: Thomas Köppe <tkoeppe@google.com>
+Date:   Fri Aug 19 17:03:37 2022 +0100
+
+    [assets] Unicode examples
+
+commit 589af92ce99b91444a3e6155cb64f8009918e885
+Author: Thomas Köppe <tkoeppe@google.com>
+Date:   Sun Aug 28 02:09:47 2022 +0100
+
+    [format.string.{std,escaped}, macros] Add missing examples
+
+commit f61a2c8a847e846ba1167c876b0fc1532ab433d7
+Author: Thomas Köppe <tkoeppe@google.com>
+Date:   Mon Jul 24 21:27:00 2023 +0100
+
+    [format.string.escape] Fix mis{sing,escaped} braces
+
+    This was an oversight in the application of
+    https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2713r0.html
+    in e38ea31d46ca2964c4f9169f049e2f15e2cd5957.
+
+commit 3b2a8ee11725eb485df89dec40a7e0fc965debb2
+Author: Johel Ernesto Guerrero Peña <johelegp@gmail.com>
+Date:   Fri Jul 21 12:46:48 2023 -0400
+
+    [func.wrap.ref.class] change deduction guide to match its detailed specifications
+
+commit d5160c6ff6c09fc0c52b5b11676c03ff179f4554
+Author: Thomas Köppe <tkoeppe@google.com>
+Date:   Sun Jul 23 02:51:25 2023 +0100
+
+    [mdspan.submdspan.extents] Factor out common result expression
+
+commit 84cf8ef63a479a3fda05a219dd26ab4b8c6a8e32
+Author: Jakub Mazurkiewicz <mazkuba3@gmail.com>
+Date:   Tue Jul 25 01:06:49 2023 +0200
+
+    [mdspan.mdspan.cons] `OtherIndexType` is not a parameter pack; missing _v (#6263)
+
+commit a636f553369825bc37ac0d95c171a00c526af499
+Author: lprv <100177227+lprv@users.noreply.github.com>
+Date:   Mon Jul 24 16:16:14 2023 +0000
+
+    [intro.object] Fix cross-references for library implicit object creation
+
+commit d09a77e09a5210c50994b89d999f3cbdfcc9a436
+Author: Jonathan Wakely <cxx@kayari.org>
+Date:   Wed May 17 18:51:00 2023 +0100
+
+    [re.results.general, string.cons] Fix references to container reqmts
+
+    [re.results.general] should refer to [container.alloc.reqmts] for an
+    allocator-aware container, [strings.cons] should refer to sequence
+    container requirements.
+
+commit dd32b7eeb21e0ca8be7aae1996814a2ffda0ed83
+Author: Jonathan Wakely <cxx@kayari.org>
+Date:   Thu May 18 12:54:12 2023 +0100
+
+    [container.gen.reqmts] Adjust subclause names and stable tags
+
+    There are no more cross-references to [container.gen.reqmts] or
+    [container.requirements.general], so this doesn't affect anything else.
+
+commit a0e6740cda724c192ea14979e2fa92e9f38cf242
+Author: Janet Cobb <git@randomcat.org>
+Date:   Mon Jul 24 12:09:44 2023 -0400
+
+    [basic.fundamental] Clarify that table of minimum integral type widths applies only to standard integral types
+
+commit 3a2586ccb4112f32f08643f7fcafab0b6b7956e2
+Author: Joshua Berne <berne@notadragon.com>
+Date:   Fri Jul 28 15:31:51 2023 -0400
+
+    [dcl.attr.grammar] Fix typo "appeartain" -> "appertain" (#6420)
+
+commit 00b4bb25e7b881cc53dca91dd44ef87c9696b19c
+Author: Jan Schultke <me@eisenwave.net>
+Date:   Sun Aug 13 22:35:57 2023 +0200
+
+    [over.ics.list] Fix missing std:: in example (#6453)
+
+commit cf7d5820d2ab8352d96462c647b735dc575cc1cb
+Author: Alisdair Meredith <alisdairm@me.com>
+Date:   Tue Aug 15 00:12:21 2023 +0200
+
+    [depr.static.constexpr] Cross-reference core clauses for deprecated feature (#6448)
+
+commit 1353359777de653346dd05ed117bba3627b6c7ca
+Author: Jens Maurer <Jens.Maurer@gmx.net>
+Date:   Tue Jan 24 18:51:02 2023 +0100
+
+    [class.mem.general] Clarify class completeness
+
+commit 77d1b66193d5324b121979474d0e35645bbcfb1c
+Author: A. Jiang <de34@live.cn>
+Date:   Tue Aug 1 13:39:55 2023 +0800
+
+    [memory.syn] Remove redundant freestanding mark for members
+
+    Making `allocator_arg_t` shown like `from_range_t` in [ranges.syn].
+
+commit bf304328b603d96b9da5dc38dfeb04057c67cc53
+Author: A. Jiang <de34@live.cn>
+Date:   Tue Aug 1 13:42:07 2023 +0800
+
+    [ranges.syn] Remove redundant freestanding mark for members
+
+commit d347b328e058bb4b357a2b7b4733c923fca6fd98
+Author: Jan Schultke <me@eisenwave.net>
+Date:   Tue Aug 15 00:42:54 2023 +0200
+
+    [temp.over] itemize parts of long paragraph (#6443)
+
+commit e34a8e15e1de7eab0980af328765957c6118fc04
+Author: Jan Schultke <me@eisenwave.net>
+Date:   Tue Aug 15 00:45:43 2023 +0200
+
+    [meta.unary.prop] itemize long sentence (#6436)
+
+ + diff --git a/papers/n4959.md b/papers/n4959.md new file mode 100644 index 0000000000..a1f6effec6 --- /dev/null +++ b/papers/n4959.md @@ -0,0 +1,553 @@ +# N4959 Editors' Report -- Programming Languages -- C++ + +Date: 2023-08-14 + +Thomas Köppe (editor, Google DeepMind) +Jens Maurer (co-editor) +Dawn Perchik (co-editor, Bright Side Computing, LLC) +Richard Smith (co-editor, Google Inc) + +Email: `cxxeditor@gmail.com` + +## Acknowledgements + +Thanks to all those who have [submitted editorial +issues](https://github.com/cplusplus/draft/wiki/How-to-submit-an-editorial-issue) +and to those who have provided pull requests with fixes, +and special thanks to Johel Ernesto Guerrero Peña for providing in-depth review +of many of the draft motion applications. + +## New papers + + * [N4958](https://open-std.org/jtc1/sc22/wg21/docs/papers/2023/n4958.pdf) is the + current working draft for C++26. It replaces + [N4950](https://open-std.org/jtc1/sc22/wg21/docs/papers/2023/n4950.pdf). + * N4959 is this Editors' Report. + +## Motions incorporated into working draft + +### Notes on motions + +All motions were applied cleanly. In a small number of cases, the approved +wording was based on an older draft and needed reconciliation with intervening +changes, but it was clear how to do this. + +* The wording for [P1854R4](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p1854r4.pdf) + ("Making non-encodable string literals ill-formed", CWG Poll 3) + has been reconciled with previous changes from + [P2314R4](http://open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2314r4.html) + ("Character sets and encodings"). +* For [P0792R14](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p0792r14.html) + ("`function_ref`: a type-erased callable reference", LWG Poll 18), + among some minor fixes for correctness and consistency, + exposition-only members have been added explicitly to the class synopsis, + which had only been mentioned in the descriptive text in the approved wording. +* The feature test macro `__cpp_lib_format` has been modified three times, as follows: + * `202304L` by + [P2510R3](http://open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2510r3.pdf) + ("Formatting pointers", LWG Poll 10) + * `202305L` by + [P2757R3](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2757r3.html) + ("Type checking format args", LWG Poll 20) + * `202306L` by + [P2637R3](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2637r3.html) + ("Member `visit`", LWG Poll 21) +* The feature test macro for + [P2641R4](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2641r4.html) + ("Checking if a union alternative is active", LWG Poll 22) + has been renamed from `__cpp_lib_within_lifetime` to `__cpp_lib_is_within_lifetime`, + which seems more appropriate and follows existing practice. +* For [P2630R4](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2630r4.html) + (`submdspan`, LWG Poll 29), numerous minor editorial corrections and improvements + have been applied; see the full commit log for details. + +### Core working group polls + +CWG Poll 1: Accept as Defect Reports and apply the proposed resolutions of all issues in +[P2922R0](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2922r0.html) +(Core Language Working Group "ready" Issues for the June, 2023 meeting) to the C++ Working Paper. + +CWG Poll 2: Accept as a Defect Report and apply the changes in +[P2621R2](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2621r2.pdf) +(UB? In my Lexer?) to the C++26 Working Paper. + +CWG Poll 3: Accept as a Defect Report and apply the changes in +[P1854R4](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p1854r4.pdf) +(Making non-encodable string literals ill-formed) to the C++26 Working Paper. + +CWG Poll 4: Apply the changes in [P2361R6](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2361r6.pdf) +(Unevaluated strings) to the C++26 Working Paper. + +CWG Poll 5: Apply the changes in [P2558R2](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2558r2.html) +(Add `@`, `$`, and ` to the basic character set) to the C++26 Working Paper. + +CWG Poll 6: Apply the changes in [P2738R1](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2738r1.pdf) +(constexpr cast from `void*`: towards constexpr type-erasure) to the C++26 Working Paper. + +CWG Poll 7: Accept as a Defect Report and apply the changes in +[P2915R0](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2915r0.pdf) +(Proposed resolution for CWG1223) to the C++26 Working Paper. + +CWG Poll 8: Accept as a Defect Report and apply the changes in +[P2552R3](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2552r3.pdf) +(On the ignorability of standard attributes) to the C++26 Working Paper. + +CWG Poll 9: Accept as a Defect Report and apply the changes in +[P2752R3](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2752r3.html) +(Static storage for braced initializers) to the C++26 Working Paper. + +CWG Poll 10: Apply the changes in [P2741R3](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2741r3.pdf) +(User-generated `static_assert` messages) to the C++26 Working Paper. + +CWG Poll 11: Apply the changes in [P2169R4](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2169r4.pdf) +(A nice placeholder with no name) to the C++26 Working Paper. + +### Library working group polls + +LWG Poll 1: Apply the changes for all Tentatively Ready issues in +[P2910R0](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2910r0.html) +(C++ Standard Library Issues to be moved in Varna, Jun. 2023) to the C++ working paper. + +LWG Poll 2: Apply the changes in [P2497R0](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2497r0.html) +(Testing for success or failure of `` functions) to the C++ working paper. + +LWG Poll 3: Apply the changes in [P2592R3](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2592r3.html) +(Hashing support for `std::chrono` value classes) to the C++ working paper. + +LWG Poll 4: Apply the changes in [P2587R3](http://open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2587r3.html) +(`to_string` or not `to_string`) to the C++ working paper. + +LWG Poll 5: Apply the changes in [P2562R1](http://open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2562r1.pdf) +(`constexpr` Stable Sorting) to the C++ working paper. + +LWG Poll 6: Apply the changes in [P2545R4](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2545r4.pdf) +(Read-Copy Update (RCU)) to the C++ working paper. + +LWG Poll 7: Apply the changes in [P2530R3](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2530r3.pdf) +(Hazard Pointers for C++26) to the C++ working paper. + +LWG Poll 8: Apply the changes in [P2538R1](http://open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2538r1.html) +(ADL-proof `std::projected`) to the C++ working paper. + +LWG Poll 9: Apply the changes in [P2495R3](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2495r3.pdf) +(Interfacing stringstreams with `string_view`) to the C++ working paper. + +LWG Poll 10: Apply the changes in [P2510R3](http://open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2510r3.pdf) +(Formatting pointers) to the C++ working paper. + +LWG Poll 11: Apply the changes in [P2198R7](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2198r7.html) +(Freestanding Feature-Test Macros and Implementation-Defined Extensions) to the C++ working paper. + +LWG Poll 12: Apply the changes in [P2338R4](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2338r4.html) +(Freestanding Library: Character primitives and the C library) to the C++ working paper. + +LWG Poll 13: Apply the changes in [P2013R5](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2013r5.html) +(Freestanding Language: Optional `::operator new`) to the C++ working paper. + +LWG Poll 14: Apply the changes in [P0493R4](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p0493r4.pdf) +(Atomic maximum/minimum) to the C++ working paper. + +LWG Poll 15: Apply the changes in [P2363R5](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2363r5.html) +(Extending associative containers with the remaining heterogeneous overloads) to the C++ working paper. + +LWG Poll 16: Apply the changes in [P1901R2](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p1901r2.html) +(Enabling the Use of `weak_ptr` as Keys in Unordered Associative Containers) to the C++ working paper. + +LWG Poll 17: Apply the changes in [P1885R12](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p1885r12.pdf) +(Naming Text Encodings to Demystify Them) to the C++ working paper. + +LWG Poll 18: Apply the changes in [P0792R14](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p0792r14.html) +(`function_ref`: a type-erased callable reference) to the C++ working paper. + +LWG Poll 19: Apply the changes in [P2874R2](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2874r2.pdf) +(Mandating Annex D) to the C++ working paper. + +LWG Poll 20: Apply the changes in [P2757R3](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2757r3.html) +(Type checking format args) to the C++ working paper. + +LWG Poll 21: Apply the changes in [P2637R3](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2637r3.html) +(Member `visit`) to the C++ working paper. + +LWG Poll 22: Apply the changes in [P2641R4](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2641r4.html) +(Checking if a union alternative is active) to the C++ working paper. + +LWG Poll 23: Apply the changes in [P1759R6](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p1759r6.html) +(Native handles and file streams) to the C++ working paper. + +LWG Poll 24: Apply the changes in [P2697R1](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2697r1.pdf) +(Interfacing `bitset` with `string_view`) to the C++ working paper. + +LWG Poll 25: Apply the changes in [P1383R2](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p1383r2.pdf) +(More `constexpr` for `` and ``) to the C++ working paper. + +LWG Poll 26: Apply the changes in [P2734R0](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2734r0.pdf) +(Adding the new 2022 SI prefixes) to the C++ working paper. + +LWG Poll 27: Apply the changes in [P2548R6](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2548r6.pdf) +(`copyable_function`) to the C++ working paper. + +LWG Poll 28: Apply the changes in [P2714R1](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2714r1.html) +(Bind front and back to NTTP callables) to the C++ working paper. + +LWG Poll 29: Apply the changes in [P2630R4](http://open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2630r4.html) +(`submdspan`) to the C++ working paper. + +## Editorial changes + +### Noteworthy changes + +Some Unicode examples of the new formatting facilities had been missing from the +last few working drafts (but are present in the C++23 DIS) because they needed +some bespoke handling. This has now been integrated into the main branch, and +the examples now appear correctly in the working draft. (The examples are +generated with LuaTeX. As a side effect, the typeface used in existing diagrams +has been changed to match the one used for the main body text. We have also +explored switching the typesetting engine for the main document from eTeX to +LuaTeX. This is possible in principle, but results in slightly lower typographic +quality at the moment, so we are holding off on this and will revisit this +change in the future.) + +The title of the working draft has been changed to "Working Draft, Programming +Languages — C++", to match the official title of the standard more closely. + +### Minor editorial changes + +A log of editorial fixes made to the working draft since N4950 is below. This +list excludes changes that do not affect the body text or only affect whitespace +or typeface. For a complete list including such changes (or for the actual +deltas applied by these changes), consult the [draft sources on +github](https://github.com/cplusplus/draft/compare/n4950...n4958). + + commit abb81facf56f82a7487b3f64ae337ce2802c4bf3 + Author: Jens Maurer + Date: Fri May 12 09:38:16 2023 +0200 + + [intro.execution] Fix bad function call in example + + commit 42f21d84fb374b11d44c0b367bda649636128b6a + Author: Andrew Rogers + Date: Wed Apr 19 01:03:57 2023 +0100 + + [dcl.init.aggr] Add missing apostrophe + + commit 4514233a48954d0fd0669236cc986640e33feb04 + Author: lprv <100177227+lprv@users.noreply.github.com> + Date: Fri May 12 23:14:43 2023 +0200 + + [basic.compound] Fix cross-reference for 'incomplete type' (#6210) + + commit 4fac9f97a2c25d39a01f75cf198d0783bfa8deda + Author: Jonathan Wakely + Date: Tue May 16 17:01:51 2023 +0100 + + [strings], [unord.req.general], [stringbuf.members]: Fix xrefs to [container.requirements.general] + + All the references for "qualifies as an input iterator" and "qualifies + as an allocator" are supposed to be to [container.reqmts] p69 which + begins: + + > The behavior of certain container member functions and deduction + > guides depends on whether types qualify as input iterators or + > allocators. + + The reference in [string.require] for obtaining an allocator should be + to [container.reqmts] p64. + + The reference in [string.require] Note 2 should be to + [container.requirements.pre] p3. + + Fixes #6184 + + commit 1be4801ac1f90aca9a8f5804a48e8bcd082f5bb9 + Author: lprv <100177227+lprv@users.noreply.github.com> + Date: Thu Jun 1 20:57:05 2023 +0200 + + [lib] Refer to exposition-only function templates as templates, not functions (#6265) + + * [tuple.apply]/1, /4 + * [expected.object.assign]/1 + * [iterator.cust.swap]/2 + * [specialized.algorithms.general]/3 + + commit c0685a584ea51d3e47381478a750729da3202b37 + Author: Géry Ogam + Date: Tue Jun 13 18:21:59 2023 +0200 + + [basic.lval] Reword the misused term ‘classifications’ (#4913) + + commit ae4cba4dc8ee2437f39a451268ad6bc924076da0 + Author: Thomas Köppe + Date: Tue Jun 20 13:29:38 2023 +0100 + + [cover-wd] A more appropriate title, and better line spacing + + commit 7e7afe0965e4e16ff651167212ea05ed9c0ef788 + Author: Eisenwave + Date: Thu Jul 6 12:45:54 2023 +0200 + + [expr.mul] Add missing commas (#6366) + + commit 384d36a0d30e6a8050e23f7193db40fb56ff4f06 + Author: Jonathan Wakely + Date: Thu Jul 6 20:45:10 2023 +0100 + + [filebuf.virtuals] fix "if width if less than zero" typo + + commit 964015779245341d64d93bbd0d1e11f050b32e70 + Author: Hewill Kang <67143766+hewillk@users.noreply.github.com> + Date: Mon Jul 10 18:53:10 2023 +0800 + + [time.duration.cons] Fix duplicate definition in example (#6372) + + commit e6c2f8fb0d5ad6cda3e2d3da63bd5d5e434635b4 + Author: Thomas Köppe + Date: Tue Jul 18 23:16:59 2023 +0100 + + [diff.cpp23.expr] Fix environment ("example" should be "codeblock") + + commit 2109f579cc6749d19ddf9cf892e8aec4762ba344 + Author: Thomas Köppe + Date: Fri Jul 21 16:21:54 2023 +0100 + + [locale.general] Add cross-references to class synopsis + + commit c2e05a4080e8c79bcc9971054ca6fb6ae9b3e722 + Author: Thomas Köppe + Date: Fri Jul 21 17:05:10 2023 +0100 + + [functional.syn] Tweak cross-references in class synopsis + + commit 8334cc876d29595f0f2796a6de42acae937d8377 + Author: Thomas Köppe + Date: Fri Jul 21 23:29:54 2023 +0100 + + [functional.syn, func.wrap.move] Hyphenate "move-only wrapper" + + commit 7fb62d5f50bfbfc159df4ca0af932ee82d26bc41 + Author: Thomas Köppe + Date: Fri Jul 21 18:13:28 2023 +0100 + + [version.syn] Rename smart_pointer_owner_equality to smart_ptr_owner_equality + + For consistency: the use of "ptr" is already prevailing. + + commit 56a6b7fe068726ace9196366c968cc679653cc04 + Author: Hewill Kang <67143766+hewillk@users.noreply.github.com> + Date: Wed May 17 23:27:22 2023 +0800 + + Add missing colon for the Effects: Equivalent to return format + + commit a34d2e08bda9b1314ecec1b608745a88a678d664 + Author: vasama + Date: Wed Jun 7 11:01:02 2023 +0300 + + [expr.pre] Clarify note on pointer subtraction + + commit 96f695aea7589a62e5ebb55a18a40f985f7d89ce + Author: Thomas Köppe + Date: Tue Jun 13 09:18:01 2023 +0300 + + [basic.def.odr] Restructure requirements in p14-p15 + + commit ebba9f316ddd8c120608447b00ea32bf3926a18d + Author: Jonathan Wakely + Date: Sun Jul 23 02:29:17 2023 +0100 + + [func.wrap.func.general, func.wrap.move.class] Remove redundant declaration (#6273) + + We don't need to repeat the declarations of the incomplete primary + template, they are already present in the synopsis. + + commit e6bd946d953b76e908a8e853d93834572c125d59 + Author: Richard Smith + Date: Fri Jul 14 13:31:47 2023 -0700 + + [basic.scope.scope] Avoid hard-to-read except...unless construction. + + Factor out a name for the "unless" condition to avoid the double-negative. + + commit 3769c701daf9ae38f8db054670106abca7c03d32 + Author: Roger Orr + Date: Tue Jul 18 23:54:34 2023 +0100 + + [dcl.ambig.res] fix double declaration of 'y' in example + + commit 0bf51a3bc5c24b070265412c32e53a0060d73eef + Author: Christian Trott + Date: Sat Jul 22 19:33:41 2023 -0600 + + [mdspan.layout.stride.cons] Fix missed rename of template parameter (#6385) + + "LayoutStrideMapping" should say "StridedLayoutMapping". + + commit f8feaa6e5bc8e6d28e00c06a3de305f80f395913 + Author: Eelis van der Weegen + Date: Fri Jul 21 11:43:39 2023 +0200 + + [version.syn] Fix header references. + + commit 872bda08678d1aeecfc555f26920cec28a2ad497 + Author: lprv <100177227+lprv@users.noreply.github.com> + Date: Thu Jun 1 14:59:00 2023 +0000 + + [basic.stc.dynamic.allocation] Remove redundant 'address of' from a note + + commit 880531fad125c4b806300151ddcb961a7f44a181 + Author: Arthur O'Dwyer + Date: Sat Jul 22 21:49:38 2023 -0400 + + [flat.{,multi}{map,set}.cons]: zip_view should be views::zip (#6373) + + We don't expect to use CTAD on `ranges::zip_view(args...)`; + what we expect is `views::zip`. + + commit a417ade53722d944481baac575292874c1bcc79a + Author: Johel Ernesto Guerrero Peña + Date: Sat Jul 22 21:50:37 2023 -0400 + + [range.enumerate.overview] Add cross reference to [range.adaptor.object] (#6219) + + commit 7f100cc67b0bb263e2f438238e87555347ae45c0 + Author: Hewill Kang <67143766+hewillk@users.noreply.github.com> + Date: Sun Jul 23 17:50:27 2023 +0800 + + [input.output] Fix the "Effects: Equivalent to" format (#6402) + + commit 9334219bd95a85e86b20c8a712397f9f23f0f7a8 + Author: Jens Maurer + Date: Sun Jul 23 06:59:28 2023 +0200 + + [class.copy.assign] Remove note obsoleted by CWG2586 + + commit 503b4b261061bdd2481e1e4f1153481a0a75ecee + Author: Jens Maurer + Date: Sun Jul 23 08:29:10 2023 +0200 + + [dcl.fct.def.default] Highlight different references in defaulted assignments + + commit a567088b0ab8ca62f0ff5a7b4746337ac3f6df9b + Author: Thomas Köppe + Date: Mon Jul 24 12:45:57 2023 +0100 + + [assets] Move separate assets into "assets" subdirectory + + commit 7e2cc3ba6a30a693a96bbc37c4d8428d92ce1fa8 + Author: Thomas Köppe + Date: Fri Aug 19 17:03:37 2022 +0100 + + [assets] Unicode examples + + commit 589af92ce99b91444a3e6155cb64f8009918e885 + Author: Thomas Köppe + Date: Sun Aug 28 02:09:47 2022 +0100 + + [format.string.{std,escaped}, macros] Add missing examples + + commit f61a2c8a847e846ba1167c876b0fc1532ab433d7 + Author: Thomas Köppe + Date: Mon Jul 24 21:27:00 2023 +0100 + + [format.string.escape] Fix mis{sing,escaped} braces + + This was an oversight in the application of + https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2713r0.html + in e38ea31d46ca2964c4f9169f049e2f15e2cd5957. + + commit 3b2a8ee11725eb485df89dec40a7e0fc965debb2 + Author: Johel Ernesto Guerrero Peña + Date: Fri Jul 21 12:46:48 2023 -0400 + + [func.wrap.ref.class] change deduction guide to match its detailed specifications + + commit d5160c6ff6c09fc0c52b5b11676c03ff179f4554 + Author: Thomas Köppe + Date: Sun Jul 23 02:51:25 2023 +0100 + + [mdspan.submdspan.extents] Factor out common result expression + + commit 84cf8ef63a479a3fda05a219dd26ab4b8c6a8e32 + Author: Jakub Mazurkiewicz + Date: Tue Jul 25 01:06:49 2023 +0200 + + [mdspan.mdspan.cons] `OtherIndexType` is not a parameter pack; missing _v (#6263) + + commit a636f553369825bc37ac0d95c171a00c526af499 + Author: lprv <100177227+lprv@users.noreply.github.com> + Date: Mon Jul 24 16:16:14 2023 +0000 + + [intro.object] Fix cross-references for library implicit object creation + + commit d09a77e09a5210c50994b89d999f3cbdfcc9a436 + Author: Jonathan Wakely + Date: Wed May 17 18:51:00 2023 +0100 + + [re.results.general, string.cons] Fix references to container reqmts + + [re.results.general] should refer to [container.alloc.reqmts] for an + allocator-aware container, [strings.cons] should refer to sequence + container requirements. + + commit dd32b7eeb21e0ca8be7aae1996814a2ffda0ed83 + Author: Jonathan Wakely + Date: Thu May 18 12:54:12 2023 +0100 + + [container.gen.reqmts] Adjust subclause names and stable tags + + There are no more cross-references to [container.gen.reqmts] or + [container.requirements.general], so this doesn't affect anything else. + + commit a0e6740cda724c192ea14979e2fa92e9f38cf242 + Author: Janet Cobb + Date: Mon Jul 24 12:09:44 2023 -0400 + + [basic.fundamental] Clarify that table of minimum integral type widths applies only to standard integral types + + commit 3a2586ccb4112f32f08643f7fcafab0b6b7956e2 + Author: Joshua Berne + Date: Fri Jul 28 15:31:51 2023 -0400 + + [dcl.attr.grammar] Fix typo "appeartain" -> "appertain" (#6420) + + commit 00b4bb25e7b881cc53dca91dd44ef87c9696b19c + Author: Jan Schultke + Date: Sun Aug 13 22:35:57 2023 +0200 + + [over.ics.list] Fix missing std:: in example (#6453) + + commit cf7d5820d2ab8352d96462c647b735dc575cc1cb + Author: Alisdair Meredith + Date: Tue Aug 15 00:12:21 2023 +0200 + + [depr.static.constexpr] Cross-reference core clauses for deprecated feature (#6448) + + commit 1353359777de653346dd05ed117bba3627b6c7ca + Author: Jens Maurer + Date: Tue Jan 24 18:51:02 2023 +0100 + + [class.mem.general] Clarify class completeness + + commit 77d1b66193d5324b121979474d0e35645bbcfb1c + Author: A. Jiang + Date: Tue Aug 1 13:39:55 2023 +0800 + + [memory.syn] Remove redundant freestanding mark for members + + Making `allocator_arg_t` shown like `from_range_t` in [ranges.syn]. + + commit bf304328b603d96b9da5dc38dfeb04057c67cc53 + Author: A. Jiang + Date: Tue Aug 1 13:42:07 2023 +0800 + + [ranges.syn] Remove redundant freestanding mark for members + + commit d347b328e058bb4b357a2b7b4733c923fca6fd98 + Author: Jan Schultke + Date: Tue Aug 15 00:42:54 2023 +0200 + + [temp.over] itemize parts of long paragraph (#6443) + + commit e34a8e15e1de7eab0980af328765957c6118fc04 + Author: Jan Schultke + Date: Tue Aug 15 00:45:43 2023 +0200 + + [meta.unary.prop] itemize long sentence (#6436) diff --git a/papers/wd-index.md b/papers/wd-index.md index abcbe32842..df0daff8e8 100644 --- a/papers/wd-index.md +++ b/papers/wd-index.md @@ -45,3 +45,4 @@ * [N4928](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/n4928.pdf) 2022-11 C++ Working Draft * [N4944](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/n4944.pdf) 2023-02 C++ Working Draft * [N4950](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/n4950.pdf) 2023-05 C++ Working Draft + * [N4958](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/n4958.pdf) 2023-08 C++ Working Draft diff --git a/source/config.tex b/source/config.tex index 493b166c2f..8b24727467 100644 --- a/source/config.tex +++ b/source/config.tex @@ -1,7 +1,7 @@ %!TEX root = std.tex %%-------------------------------------------------- %% Version numbers -\newcommand{\docno}{Dxxxx} +\newcommand{\docno}{N4958} \newcommand{\prevdocno}{N4950} \newcommand{\cppver}{202302L}

Thanks to all those who have submitted editorial +issues +and to those who have provided pull requests with fixes, +and special thanks to Johel Ernesto Guerrero Peña for providing in-depth review +of many of the draft motion applications.