Gcc 3.3.1-pre 2003-07-11 C++ support bits.

1 files changed, 181 insertions, 91 deletions

diff --git a/contrib/libstdc++/include/bits/stl_stack.h b/contrib/libstdc++/include/bits/stl_stack.h
index 0a80b10..7f2496c 100644
--- a/contrib/libstdc++/include/bits/stl_stack.h
+++ b/contrib/libstdc++/include/bits/stl_stack.h
@@ -1,6 +1,6 @@
 // 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
@@ -65,96 +65,186 @@
 
 namespace std
 {
-
-// Forward declarations of operators == and <, needed for friend declaration.
-
-template <class _Tp, 
-          class _Sequence = deque<_Tp> >
-class stack;
-
-template <class _Tp, class _Seq>
-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 <class _Tp, class _Sequence>
-class stack
-{
-  // concept requirements
-  __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);
-
-  template <class _Tp1, class _Seq1>
-  friend bool operator== (const stack<_Tp1, _Seq1>&,
-                          const stack<_Tp1, _Seq1>&);
-  template <class _Tp1, class _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::reference       reference;
-  typedef typename _Sequence::const_reference const_reference;
-protected:
-  _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(); }
-};
-
-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);
-}
-
+  // Forward declarations of operators == and <, needed for friend declaration.
+  
+  template <typename _Tp, typename _Sequence = deque<_Tp> >
+  class stack;
+  
+  template <typename _Tp, typename _Seq>
+  inline 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);
+  
+  
+  /**
+   *  @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)
+    __glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept)
+  
+    template <typename _Tp1, typename _Seq1>
+    friend bool operator== (const stack<_Tp1, _Seq1>&,
+                            const stack<_Tp1, _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::reference                 reference;
+    typedef typename _Sequence::const_reference           const_reference;
+    typedef typename _Sequence::size_type                 size_type;
+    typedef          _Sequence                            container_type;
+  
+  protected:
+    //  See queue::c for notes on this name.
+    _Sequence c;
+  
+  public:
+    // 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(); }
+  };
+  
+  
+  /**
+   *  @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: