Skip to content

R
riscv-gcc-1
Commit 224a45d0 by Phil Edwards
Options

stl_map.h, [...]: Reformat and complete doxygenation. 

2002-06-21  Phil Edwards  <pme@gcc.gnu.org>

	* include/bits/stl_map.h, include/bits/stl_multimap.h,
	include/bits/stl_queue.h, include/bits/stl_stack.h:  Reformat and
	complete doxygenation.
	* include/bits/boost_concept_check.h:  Minor comment.

From-SVN: r54897
parent 23361093
Showing with 171 additions and 68 deletions
libstdc++-v3/ChangeLog
2002-06-21 Phil Edwards <pme@gcc.gnu.org>
* include/bits/stl_map.h, include/bits/stl_multimap.h,
include/bits/stl_queue.h, include/bits/stl_stack.h: Reformat and
complete doxygenation.
* include/bits/boost_concept_check.h: Minor comment.
2002-06-21 Benjamin Kosnik <bkoz@redhat.com>
* include/c_compatibility: New.
......
libstdc++-v3/include/bits/boost_concept_check.h
......@@ -149,6 +149,8 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
__a = __b; // const required for argument to assignment
}
_Tp __a;
// possibly should be "Tp* a;" and then dereference "a" in constraint
// functions? present way would require a default ctor, i think...
};
template <class _Tp>
......
libstdc++-v3/include/bits/stl_queue.h
......@@ -75,10 +75,10 @@ template <typename _Tp, typename _Sequence = deque<_Tp> >
class queue;
template <typename _Tp, typename _Seq>
inline bool operator==(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&);
inline bool operator==(const queue<_Tp,_Seq>&, const queue<_Tp,_Seq>&);
template <typename _Tp, typename _Seq>
inline bool operator<(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&);
inline bool operator<(const queue<_Tp,_Seq>&, const queue<_Tp,_Seq>&);
/**
......@@ -291,8 +291,8 @@ template <typename _Tp, typename _Sequence>
* 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.
* which is a typedef for the second Sequence parameter, and @c push,
* @c pop, and @c top, which are standard %queue/FIFO operations.
*
* @note No equality/comparison operators are provided for %priority_queue.
*
......
libstdc++-v3/include/bits/stl_stack.h
// Stack 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,98 +63,192 @@
#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 stack;
template <class _Tp, class _Seq>
bool operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y);
template <typename _Tp, typename _Seq>
inline bool operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y);
template <class _Tp, class _Seq>
bool operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y);
template <typename _Tp, typename _Seq>
inline bool operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y);
template <class _Tp, class _Sequence>
class stack
/**
* @brief A standard container giving FILO 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-last-out %stack 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 back, @c push_back, and @c pop_front, such as
* std::list, std::vector, 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,
* @c pop, and @c top, which are standard %stack/FILO operations.
*/
template <typename _Tp, typename _Sequence>
class stack
{
// concept requirements
typedef typename _Sequence::value_type _Sequence_value_type;
__glibcpp_class_requires(_Tp, _SGIAssignableConcept)
__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 stack<_Tp1, _Seq1>&,
const stack<_Tp1, _Seq1>&);
template <class _Tp1, class _Seq1>
template <typename _Tp1, typename _Seq1>
friend bool operator< (const stack<_Tp1, _Seq1>&,
const stack<_Tp1, _Seq1>&);
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:
// See queue::c for notes on this name.
_Sequence c;
public:
stack() : c() {}
explicit stack(const _Sequence& __s) : c(__s) {}
bool empty() const { return c.empty(); }
size_type size() const { return c.size(); }
reference top() { return c.back(); }
const_reference top() const { return c.back(); }
void push(const value_type& __x) { c.push_back(__x); }
void pop() { c.pop_back(); }
// XXX removed old def ctor, added def arg to this one to match 14882
/**
* @brief Default constructor creates no elements.
*/
explicit
stack(const _Sequence& __c = _Sequence())
: c(__c) {}
/**
* Returns true if the %stack is empty.
*/
bool
empty() const { return c.empty(); }
/** Returns the number of elements in the %stack. */
size_type
size() const { return c.size(); }
/**
* Returns a read/write reference to the data at the first element of the
* %stack.
*/
reference
top() { return c.back(); }
/**
* Returns a read-only (constant) reference to the data at the first
* element of the %stack.
*/
const_reference
top() const { return c.back(); }
/**
* @brief Add data to the top of the %stack.
* @param x Data to be added.
*
* This is a typical %stack operation. The function creates an element at
* the top of the %stack 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 %stack operation. It shrinks the %stack 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_back(); }
};
template <class _Tp, class _Seq>
bool operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{
return __x.c == __y.c;
}
template <class _Tp, class _Seq>
bool operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{
return __x.c < __y.c;
}
template <class _Tp, class _Seq>
bool operator!=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{
return !(__x == __y);
}
template <class _Tp, class _Seq>
bool operator>(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{
return __y < __x;
}
template <class _Tp, class _Seq>
bool operator<=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{
return !(__y < __x);
}
template <class _Tp, class _Seq>
bool operator>=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{
return !(__x < __y);
}
/**
* @brief Stack equality comparison.
* @param x A %stack.
* @param y A %stack of the same type as @a x.
* @return True iff the size and elements of the stacks 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 stacks are considered equivalent
* if their sequences compare equal.
*/
template <typename _Tp, typename _Seq>
inline bool
operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{ return __x.c == __y.c; }
/**
* @brief Stack ordering relation.
* @param x A %stack.
* @param y A %stack 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 _Seq>
inline bool
operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{ return __x.c < __y.c; }
/// Based on operator==
template <typename _Tp, typename _Seq>
inline bool
operator!=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{ return !(__x == __y); }
/// Based on operator<
template <typename _Tp, typename _Seq>
inline bool
operator>(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{ return __y < __x; }
/// Based on operator<
template <typename _Tp, typename _Seq>
inline bool
operator<=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{ return !(__y < __x); }
/// Based on operator<
template <typename _Tp, typename _Seq>
inline bool
operator>=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{ return !(__x < __y); }
} // namespace std
#endif /* __GLIBCPP_INTERNAL_STACK_H */
// Local Variables:
// mode:C++
// End:
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment