mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-02-24 10:09:31 +08:00
Code Issues Packages Projects Releases Wiki Activity

TODO: Update.

Browse Source 
2002-06-16  Phil Edwards  <pme@gcc.gnu.org>

	* docs/doxygen/TODO:  Update.
	* docs/doxygen/tables.html:  Uncomment magical middle column.
	* docs/doxygen/user.cfg.in:  Kludge to ignore function-like macros.
	* include/bits/stl_queue.h:  Doxygenate and reformat.
	* include/bits/ios_base.h, include/std/std_streambuf.h:  Add comment
	for deprecated names required by the standard.

From-SVN: r54666
This commit is contained in:
Phil Edwards 2002-06-16 11:29:53 +00:00
parent 77bb9994b8
commit 4df6abc6b3
7 changed files with 351 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,12 @@
2002-06-16 Phil Edwards <pme@gcc.gnu.org>
* docs/doxygen/TODO: Update.
* docs/doxygen/tables.html: Uncomment magical middle column.
* docs/doxygen/user.cfg.in: Kludge to ignore function-like macros.
* include/bits/stl_queue.h: Doxygenate and reformat.
* include/bits/ios_base.h, include/std/std_streambuf.h: Add comment
for deprecated names required by the standard.
2002-06-14 J.T. Conklin <jtc@acorntoolworks.com>
* configure.in (target_alias): Fix.

3
libstdc++-v3/docs/doxygen/TODO
View File

@ -25,7 +25,8 @@ c20 Note A
c21 Untouched, Note B
c22 Untouched
c23 See doxygroups.cc and Note B. Notes on what invalidates
iterators need to be added.
iterators need to be added. std::list-specific memfns need
to be filled out.
c24 stl_iterator.h (__normal_iterator, other small TODO bits)
stream iterators
c25 stl_algo.h (lots of stuff)

37
libstdc++-v3/docs/doxygen/tables.html
View File

@ -39,14 +39,15 @@ rendering is ugly. (Update: mozilla 0.9.9 looks MUCH better.)</p>
<a name="65"><p>
<table cellpadding="3" cellspacing="5" align="center" rules="rows" border="3"
cols="4" title="Table 65">
cols="5" title="Table 65">
<caption><h2>Table 65 --- Container Requirements</h2></caption>
<tr><th colspan="4">
<tr><th colspan="5">
Anything calling itself a container must meet these minimum requirements.
</th></tr>
<tr>
<td><strong>expression</strong></td>
<td><strong>result type</strong></td>
<td><strong>operational semantics</strong></td>
<td><strong>notes, pre-/post-conditions, assertions</strong></td>
<td><strong>complexity</strong></td>
</tr>
@ -54,6 +55,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>X::value_type</td>
<td>T</td>
<td>&nbsp;</td>
<td>T is Assignable</td>
<td>compile time</td>
</tr>
@ -62,6 +64,7 @@ Anything calling itself a container must meet these minimum requirements.
<td>X::reference</td>
<td>lvalue of T</td>
<td>&nbsp;</td>
<td>&nbsp;</td>
<td>compile time</td>
</tr>
@ -69,12 +72,14 @@ Anything calling itself a container must meet these minimum requirements.
<td>X::const_reference</td>
<td>const lvalue of T</td>
<td>&nbsp;</td>
<td>&nbsp;</td>
<td>compile time</td>
</tr>
<tr>
<td>X::iterator</td>
<td>iterator type pointing to T</td>
<td>&nbsp;</td>
<td>Any iterator category except output iterator.
Convertible to X::const_iterator.</td>
<td>compile time</td>
@ -83,6 +88,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>X::const_iterator</td>
<td>iterator type pointing to const T</td>
<td>&nbsp;</td>
<td>Any iterator category except output iterator.</td>
<td>compile time</td>
</tr>
@ -90,6 +96,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>X::difference_type</td>
<td>signed integral type</td>
<td>&nbsp;</td>
<td>identical to the difference type of X::iterator and X::const_iterator</td>
<td>compile time</td>
</tr>
@ -97,6 +104,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>X::size_type</td>
<td>unsigned integral type</td>
<td>&nbsp;</td>
<td>size_type can represent any non-negative value of difference_type</td>
<td>compile time</td>
</tr>
@ -104,6 +112,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>X u;</td>
<td>&nbsp;</td>
<td>&nbsp;</td>
<td>post: u.size() == 0</td>
<td>constant</td>
</tr>
@ -111,6 +120,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>X();</td>
<td>&nbsp;</td>
<td>&nbsp;</td>
<td>X().size == 0</td>
<td>constant</td>
</tr>
@ -118,6 +128,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>X(a);</td>
<td>&nbsp;</td>
<td>&nbsp;</td>
<td>a == X(a)</td>
<td>linear</td>
</tr>
@ -125,6 +136,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>X u(a);<br />X u = a;</td>
<td>&nbsp;</td>
<td>&nbsp;</td>
<td>post: u == a. Equivalent to: X u; u = a;</td>
<td>linear</td>
</tr>
@ -132,6 +144,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>(&amp;a)-&gt;~X();</td>
<td>void</td>
<td>&nbsp;</td>
<td>dtor is applied to every element of a; all the memory is deallocated</td>
<td>linear</td>
</tr>
@ -140,6 +153,7 @@ Anything calling itself a container must meet these minimum requirements.
<td>a.begin()</td>
<td>iterator; const_iterator for constant a</td>
<td>&nbsp;</td>
<td>&nbsp;</td>
<td>constant</td>
</tr>
@ -147,12 +161,14 @@ Anything calling itself a container must meet these minimum requirements.
<td>a.end()</td>
<td>iterator; const_iterator for constant a</td>
<td>&nbsp;</td>
<td>&nbsp;</td>
<td>constant</td>
</tr>
<tr>
<td>a == b</td>
<td>convertible to bool</td>
<td>&nbsp;</td>
<td>== is an equivalence relation. a.size()==b.size() &amp;&amp;
equal(a.begin(),a.end(),b.begin())</td>
<td>linear</td>
@ -161,6 +177,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>a != b</td>
<td>convertible to bool</td>
<td>&nbsp;</td>
<td>equivalent to !(a==b)</td>
<td>linear</td>
</tr>
@ -168,6 +185,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>a.swap(b)</td>
<td>void</td>
<td>&nbsp;</td>
<td>swap(a,b)</td>
<td>may or may not have constant complexity</td>
</tr>
@ -175,6 +193,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>r = a</td>
<td>X&amp;</td>
<td>&nbsp;</td>
<td>r == a</td>
<td>linear</td>
</tr>
@ -184,7 +203,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>a.size()</td>
<td>size_type</td>
<!--<td>a.end() - a.begin()</td>-->
<td>a.end() - a.begin()</td>
<td>&nbsp;</td>
<td>may or may not have constant complexity</td>
</tr>
@ -192,7 +211,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>a.max_size()</td>
<td>size_type</td>
<!--<td>size() of the largest possible container</td>-->
<td>size() of the largest possible container</td>
<td>&nbsp;</td>
<td>may or may not have constant complexity</td>
</tr>
@ -200,7 +219,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>a.empty()</td>
<td>convertible to bool</td>
<!--<td>a.size() == 0</td>-->
<td>a.size() == 0</td>
<td>&nbsp;</td>
<td>constant</td>
</tr>
@ -208,7 +227,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>a &lt; b</td>
<td>convertible to bool</td>
<!--<td>lexographical_compare(a.begin,a.end(),b.begin(),b.end())</td>-->
<td>lexographical_compare( a.begin, a.end(), b.begin(), b.end())</td>
<td>pre: &lt; is defined for T and is a total ordering relation</td>
<td>linear</td>
</tr>
@ -216,7 +235,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>a &gt; b</td>
<td>convertible to bool</td>
<!--<td>b &lt; a</td>-->
<td>b &lt; a</td>
<td>&nbsp;</td>
<td>linear</td>
</tr>
@ -224,7 +243,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>a &lt;= b</td>
<td>convertible to bool</td>
<!--<td>!(a &gt; b)</td>-->
<td>!(a &gt; b)</td>
<td>&nbsp;</td>
<td>linear</td>
</tr>
@ -232,7 +251,7 @@ Anything calling itself a container must meet these minimum requirements.
<tr>
<td>a &gt;= b</td>
<td>convertible to bool</td>
<!--<td>!(a &lt; b)</td>-->
<td>!(a &lt; b)</td>
<td>&nbsp;</td>
<td>linear</td>
</tr>

17
libstdc++-v3/docs/doxygen/user.cfg.in
View File

@ -669,13 +669,13 @@ ENABLE_PREPROCESSING = YES
# compilation will be performed. Macro expansion can be done in a controlled
# way by setting EXPAND_ONLY_PREDEF to YES.
MACRO_EXPANSION = NO
MACRO_EXPANSION = YES
# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
# then the macro expansion is limited to the macros specified with the
# PREDEFINED and EXPAND_AS_PREDEFINED tags.
EXPAND_ONLY_PREDEF = NO
EXPAND_ONLY_PREDEF = YES
# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
# in the INCLUDE_PATH (see below) will be search if a #include is found.
@ -701,10 +701,19 @@ INCLUDE_FILE_PATTERNS =
# or name=definition (no spaces). If the definition and the = are
# omitted =1 is assumed.
PREDEFINED = _GLIBCPP_DEPRECATED
### The deprecated functions are clearly marked as such in the code, but
### the DEPRECATED macro must be defined for that code to be seen by doxygen.
### The class_requires macros are kludges because SKIP_FUNCTION_MACROS is
### completely broken, and the presence of the macros confuses the parser.
PREDEFINED = _GLIBCPP_DEPRECATED \
__glibcpp_class_requires="//" \
__glibcpp_class_requires2="//" \
__glibcpp_class_requires3="//" \
__glibcpp_class_requires4="//"
# If the MACRO_EXPANSION and EXPAND_PREDEF_ONLY tags are set to YES then
# this tag can be used to specify a list of macro names that should be expanded.
# this tag can be used to specify a list of macro names that should be expanded.
# The macro definition that is found in the sources will be used.
# Use the PREDEFINED tag if you want to use a different macro definition.

1
libstdc++-v3/include/bits/ios_base.h
View File

@ -217,6 +217,7 @@ namespace std
static const seekdir end = seekdir(SEEK_END);
#ifdef _GLIBCPP_DEPRECATED
// Annex D.6
typedef int io_state;
typedef int open_mode;
typedef int seek_dir;

401
libstdc++-v3/include/bits/stl_queue.h
View File

@ -1,6 +1,6 @@
// Queue implementation -*- C++ -*-
// Copyright (C) 2001 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
@ -63,182 +63,373 @@
#include <bits/concept_check.h>
// Since this entire file is within namespace std, there's no reason to
// waste two spaces along the left column. Thus the leading indentation is
// slightly violated from here on.
namespace std
{
// Forward declarations of operators < and ==, needed for friend declaration.
template <class _Tp,
class _Sequence = deque<_Tp> >
template <typename _Tp, typename _Sequence = deque<_Tp> >
class queue;
template <class _Tp, class _Seq>
template <typename _Tp, typename _Seq>
inline bool operator==(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&);
template <class _Tp, class _Seq>
template <typename _Tp, typename _Seq>
inline bool operator<(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&);
template <class _Tp, class _Sequence>
class queue
/**
* @brief A standard container giving FIFO behavior.
*
* @ingroup Containers
* @ingroup Sequences
*
* Meets many of the requirements of a <a href="tables.html#65">container</a>,
* but does not define anything to do with iterators. Very few of the
* other standard container interfaces are defined.
*
* This is not a true container, but an @e adaptor. It holds another
* container, and provides a wrapper interface to that container. The
* wrapper is what enforces strict first-in-first-out %queue behavior.
*
* The second template parameter defines the type of the underlying
* sequence/container. It defaults to std::deque, but it can be any type
* that supports @c front, @c back, @c push_back, and @c pop_front,
* such as std::list or an appropriate user-defined type.
*
* Members not found in "normal" containers are @c container_type,
* which is a typedef for the second Sequence parameter, and @c push and
* @c pop, which are standard %queue/FIFO operations.
*/
template <typename _Tp, typename _Sequence>
class queue
{
// concept requirements
typedef typename _Sequence::value_type _Sequence_value_type;
__glibcpp_class_requires(_Tp, _SGIAssignableConcept)
__glibcpp_class_requires(_Sequence, _FrontInsertionSequenceConcept)
__glibcpp_class_requires(_Sequence, _BackInsertionSequenceConcept)
typedef typename _Sequence::value_type _Sequence_value_type;
__glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept);
__glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept)
template <class _Tp1, class _Seq1>
template <typename _Tp1, typename _Seq1>
friend bool operator== (const queue<_Tp1, _Seq1>&,
const queue<_Tp1, _Seq1>&);
template <class _Tp1, class _Seq1>
template <typename _Tp1, typename _Seq1>
friend bool operator< (const queue<_Tp1, _Seq1>&,
const queue<_Tp1, _Seq1>&);
public:
typedef typename _Sequence::value_type value_type;
typedef typename _Sequence::size_type size_type;
typedef _Sequence container_type;
typedef typename _Sequence::reference reference;
typedef typename _Sequence::const_reference const_reference;
public:
typedef typename _Sequence::value_type value_type;
typedef typename _Sequence::reference reference;
typedef typename _Sequence::const_reference const_reference;
typedef typename _Sequence::size_type size_type;
typedef _Sequence container_type;
protected:
/**
* 'c' is the underlying container. Maintainers wondering why this isn't
* uglified as per style guidelines should note that this name is
* specified in the standard, [23.2.3.1]. (Why? Presumably for the same
* reason that it's protected instead of private: to allow derivation.
* But none of the other containers allow for derivation. Odd.)
*/
_Sequence c;
public:
explicit queue(const _Sequence& __c = _Sequence()) : c(__c) {}
bool empty() const { return c.empty(); }
size_type size() const { return c.size(); }
reference front() { return c.front(); }
const_reference front() const { return c.front(); }
reference back() { return c.back(); }
const_reference back() const { return c.back(); }
void push(const value_type& __x) { c.push_back(__x); }
void pop() { c.pop_front(); }
public:
/**
* @brief Default constructor creates no elements.
*/
explicit
queue(const _Sequence& __c = _Sequence())
: c(__c) {}
/**
* Returns true if the %queue is empty.
*/
bool
empty() const { return c.empty(); }
/** Returns the number of elements in the %queue. */
size_type
size() const { return c.size(); }
/**
* Returns a read/write reference to the data at the first element of the
* %queue.
*/
reference
front() { return c.front(); }
/**
* Returns a read-only (constant) reference to the data at the first
* element of the %queue.
*/
const_reference
front() const { return c.front(); }
/**
* Returns a read/write reference to the data at the last element of the
* %queue.
*/
reference
back() { return c.back(); }
/**
* Returns a read-only (constant) reference to the data at the last
* element of the %queue.
*/
const_reference
back() const { return c.back(); }
/**
* @brief Add data to the end of the %queue.
* @param x Data to be added.
*
* This is a typical %queue operation. The function creates an element at
* the end of the %queue and assigns the given data to it.
* The time complexity of the operation depends on the underlying
* sequence.
*/
void
push(const value_type& __x) { c.push_back(__x); }
/**
* @brief Removes first element.
*
* This is a typical %queue operation. It shrinks the %queue by one.
* The time complexity of the operation depends on the underlying
* sequence.
*
* Note that no data is returned, and if the first element's data is
* needed, it should be retrieved before pop() is called.
*/
void
pop() { c.pop_front(); }
};
template <class _Tp, class _Sequence>
bool
operator==(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{
return __x.c == __y.c;
}
template <class _Tp, class _Sequence>
bool
operator<(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{
return __x.c < __y.c;
}
/**
* @brief Queue equality comparison.
* @param x A %queue.
* @param y A %queue of the same type as @a x.
* @return True iff the size and elements of the queues are equal.
*
* This is an equivalence relation. Complexity and semantics depend on the
* underlying sequence type, but the expected rules are: this relation is
* linear in the size of the sequences, and queues are considered equivalent
* if their sequences compare equal.
*/
template <typename _Tp, typename _Sequence>
inline bool
operator==(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{ return __x.c == __y.c; }
template <class _Tp, class _Sequence>
bool
operator!=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{
return !(__x == __y);
}
/**
* @brief Queue ordering relation.
* @param x A %queue.
* @param y A %queue of the same type as @a x.
* @return True iff @a x is lexographically less than @a y.
*
* This is an total ordering relation. Complexity and semantics depend on the
* underlying sequence type, but the expected rules are: this relation is
* linear in the size of the sequences, the elements must be comparable
* with @c <, and std::lexographical_compare() is usually used to make the
* determination.
*/
template <typename _Tp, typename _Sequence>
inline bool
operator<(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{ return __x.c < __y.c; }
template <class _Tp, class _Sequence>
bool
operator>(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{
return __y < __x;
}
/// Based on operator==
template <typename _Tp, typename _Sequence>
inline bool
operator!=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{ return !(__x == __y); }
template <class _Tp, class _Sequence>
bool
operator<=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{
return !(__y < __x);
}
/// Based on operator<
template <typename _Tp, typename _Sequence>
inline bool
operator>(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{ return __y < __x; }
template <class _Tp, class _Sequence>
bool
operator>=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{
return !(__x < __y);
}
/// Based on operator<
template <typename _Tp, typename _Sequence>
inline bool
operator<=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{ return !(__y < __x); }
template <class _Tp,
class _Sequence = vector<_Tp>,
class _Compare = less<typename _Sequence::value_type> >
class priority_queue
/// Based on operator<
template <typename _Tp, typename _Sequence>
inline bool
operator>=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{ return !(__x < __y); }
/**
* @brief A standard container automatically sorting its contents.
*
* @ingroup Containers
* @ingroup Sequences
*
* This is not a true container, but an @e adaptor. It holds another
* container, and provides a wrapper interface to that container. The
* wrapper is what enforces sorting and first-in-first-out %queue behavior.
* Very few of the standard container/sequence interface requirements are
* met (e.g., iterators).
*
* The second template parameter defines the type of the underlying
* sequence/container. It defaults to std::vector, but it can be any type
* that supports @c front(), @c push_back, @c pop_back, and random-access
* iterators, such as std::deque or an appropriate user-defined type.
*
* The third template parameter supplies the means of making priority
* comparisons. It defaults to @c less<value_type> but can be anything
* defining a strict weak ordering.
*
* Members not found in "normal" containers are @c container_type,
* which is a typedef for the second Sequence parameter, and @c push and
* @c pop, which are standard %queue/FIFO operations.
*
* @note No equality/comparison operators are provided for %priority_queue.
*
* @note Sorting of the elements takes place as they are added to, and
* removed from, the %priority_queue using the %priority_queue's
* member functions. If you access the elements by other means, and
* change their data such that the sorting order would be different,
* the %priority_queue will not re-sort the elements for you. (How
* could it know to do so?)
*/
template <typename _Tp, typename _Sequence = vector<_Tp>,
typename _Compare = less<typename _Sequence::value_type> >
class priority_queue
{
// concept requirements
typedef typename _Sequence::value_type _Sequence_value_type;
__glibcpp_class_requires(_Tp, _SGIAssignableConcept)
__glibcpp_class_requires(_Sequence, _SequenceConcept)
__glibcpp_class_requires(_Sequence, _RandomAccessContainerConcept)
typedef typename _Sequence::value_type _Sequence_value_type;
__glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept);
__glibcpp_class_requires4(_Compare, bool, _Tp, _Tp, _BinaryFunctionConcept);
__glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept)
__glibcpp_class_requires4(_Compare, bool, _Tp, _Tp, _BinaryFunctionConcept)
public:
typedef typename _Sequence::value_type value_type;
typedef typename _Sequence::size_type size_type;
typedef _Sequence container_type;
typedef typename _Sequence::value_type value_type;
typedef typename _Sequence::reference reference;
typedef typename _Sequence::const_reference const_reference;
typedef typename _Sequence::size_type size_type;
typedef _Sequence container_type;
typedef typename _Sequence::reference reference;
typedef typename _Sequence::const_reference const_reference;
protected:
_Sequence c;
_Compare comp;
// See queue::c for notes on these names.
_Sequence c;
_Compare comp;
public:
explicit priority_queue(const _Compare& __x = _Compare(),
const _Sequence& __s = _Sequence())
: c(__s), comp(__x)
{ make_heap(c.begin(), c.end(), comp); }
/**
* @brief Default constructor creates no elements.
*/
explicit
priority_queue(const _Compare& __x = _Compare(),
const _Sequence& __s = _Sequence())
: c(__s), comp(__x)
{ make_heap(c.begin(), c.end(), comp); }
template <class _InputIterator>
priority_queue(_InputIterator __first, _InputIterator __last,
const _Compare& __x = _Compare(),
const _Sequence& __s = _Sequence())
: c(__s), comp(__x)
{
c.insert(c.end(), __first, __last);
make_heap(c.begin(), c.end(), comp);
}
/**
* @brief Builds a %queue from a range.
* @param first An input iterator.
* @param last An input iterator.
* @param x A comparison functor describing a strict weak ordering.
* @param s An initial sequence with which to start.
*
* Begins by copying @a s, inserting a copy of the elements from
* @a [first,last) into the copy of @a s, then ordering the copy
* according to @a x.
*
* For more information on function objects, see the documentation on
* @link s20_3_1_base functor base classes@endlink.
*/
template <typename _InputIterator>
priority_queue(_InputIterator __first, _InputIterator __last,
const _Compare& __x = _Compare(),
const _Sequence& __s = _Sequence())
: c(__s), comp(__x)
{
c.insert(c.end(), __first, __last);
make_heap(c.begin(), c.end(), comp);
}
bool empty() const { return c.empty(); }
size_type size() const { return c.size(); }
const_reference top() const { return c.front(); }
/**
* Returns true if the %queue is empty.
*/
bool
empty() const { return c.empty(); }
/** Returns the number of elements in the %queue. */
size_type
size() const { return c.size(); }
/**
* Returns a read-only (constant) reference to the data at the first
* element of the %queue.
*/
const_reference
top() const { return c.front(); }
/**
* @brief Add data to the %queue.
* @param x Data to be added.
*
* This is a typical %queue operation.
* The time complexity of the operation depends on the underlying
* sequence.
*/
void
push(const value_type& __x)
{
try
{
c.push_back(__x);
push_heap(c.begin(), c.end(), comp);
c.push_back(__x);
push_heap(c.begin(), c.end(), comp);
}
catch(...)
{
c.clear();
__throw_exception_again;
c.clear();
__throw_exception_again;
}
}
/**
* @brief Removes first element.
*
* This is a typical %queue operation. It shrinks the %queue by one.
* The time complexity of the operation depends on the underlying
* sequence.
*
* Note that no data is returned, and if the first element's data is
* needed, it should be retrieved before pop() is called.
*/
void
pop()
{
try
{
pop_heap(c.begin(), c.end(), comp);
c.pop_back();
pop_heap(c.begin(), c.end(), comp);
c.pop_back();
}
catch(...)
{
c.clear();
__throw_exception_again;
c.clear();
__throw_exception_again;
}
}
};
// no equality is provided
// No equality/comparison operators are provided for priority_queue.
} // namespace std
#endif /* __GLIBCPP_INTERNAL_QUEUE_H */
// Local Variables:
// mode:C++
// End:

2
libstdc++-v3/include/std/std_streambuf.h
View File

@ -464,6 +464,8 @@ namespace std
{ return traits_type::eof(); }
#ifdef _GLIBCPP_DEPRECATED
// http://gcc.gnu.org/ml/libstdc++/2002-05/msg00168.html
// Annex D.6
public:
void
stossc()