Na}{

Path: ~//usr/include/c++/4.8.5/bits/

File Content: `stl_stack.h`

// Stack implementation -*- C++ -*-

// Copyright (C) 2001-2013 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
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/*
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Hewlett-Packard Company makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 *
 * Copyright (c) 1996,1997
 * Silicon Graphics Computer Systems, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Silicon Graphics makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 */

/** @file bits/stl_stack.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{stack}
 */

#ifndef _STL_STACK_H
#define _STL_STACK_H 1

#include <bits/concept_check.h>
#include <debug/debug.h>

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  /**
   *  @brief  A standard container giving FILO behavior.
   *
   *  @ingroup sequences
   *
   *  @tparam _Tp  Type of element.
   *  @tparam _Sequence  Type of underlying sequence, defaults to deque<_Tp>.
   *
   *  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 @a 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 = deque<_Tp> >
    class stack
    {
      // concept requirements
      typedef typename _Sequence::value_type _Sequence_value_type;
      __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
      __glibcxx_class_requires(_Sequence, _BackInsertionSequenceConcept)
      __glibcxx_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.
       */
#if __cplusplus < 201103L
      explicit
      stack(const _Sequence& __c = _Sequence())
      : c(__c) { }
#else
      explicit
      stack(const _Sequence& __c)
      : c(__c) { }

      explicit
      stack(_Sequence&& __c = _Sequence())
      : c(std::move(__c)) { }
#endif

      /**
       *  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()
      {
	__glibcxx_requires_nonempty();
	return c.back();
      }

      /**
       *  Returns a read-only (constant) reference to the data at the first
       *  element of the %stack.
       */
      const_reference
      top() const
      {
	__glibcxx_requires_nonempty();
	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); }

#if __cplusplus >= 201103L
      void
      push(value_type&& __x)
      { c.push_back(std::move(__x)); }

      template<typename... _Args>
        void
        emplace(_Args&&... __args)
	{ c.emplace_back(std::forward<_Args>(__args)...); }
#endif

      /**
       *  @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()
      {
	__glibcxx_requires_nonempty();
	c.pop_back();
      }

#if __cplusplus >= 201103L
      void
      swap(stack& __s)
      noexcept(noexcept(swap(c, __s.c)))
      {
	using std::swap;
	swap(c, __s.c);
      }
#endif
    };

  /**
   *  @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 lexicographically 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::lexicographical_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); }

#if __cplusplus >= 201103L
  template<typename _Tp, typename _Seq>
    inline void
    swap(stack<_Tp, _Seq>& __x, stack<_Tp, _Seq>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }

  template<typename _Tp, typename _Seq, typename _Alloc>
    struct uses_allocator<stack<_Tp, _Seq>, _Alloc>
    : public uses_allocator<_Seq, _Alloc>::type { };
#endif

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace

#endif /* _STL_STACK_H */

Edit Rename Chmod Delete

FILE FOLDER

Name	Size	Permission
algorithmfwd.h	21157 bytes	0644
alloc_traits.h	18084 bytes	0644
allocator.h	6245 bytes	0644
atomic_base.h	25593 bytes	0644
atomic_lockfree_defines.h	2253 bytes	0644
basic_ios.h	15115 bytes	0644
basic_ios.tcc	6032 bytes	0644
basic_string.h	112117 bytes	0644
basic_string.tcc	39353 bytes	0644
boost_concept_check.h	27048 bytes	0644
c++0x_warning.h	1505 bytes	0644
char_traits.h	17360 bytes	0644
codecvt.h	16617 bytes	0644
concept_check.h	3340 bytes	0644
cpp_type_traits.h	9789 bytes	0644
cxxabi_forced.h	1811 bytes	0644
deque.tcc	32672 bytes	0644
exception_defines.h	1643 bytes	0644
exception_ptr.h	5413 bytes	0644
forward_list.h	47842 bytes	0644
forward_list.tcc	15531 bytes	0644
fstream.tcc	28978 bytes	0644
functexcept.h	3116 bytes	0644
functional_hash.h	6195 bytes	0644
gslice.h	5518 bytes	0644
gslice_array.h	7769 bytes	0644
hash_bytes.h	2146 bytes	0644
hashtable.h	62513 bytes	0644
hashtable_policy.h	53987 bytes	0644
indirect_array.h	7861 bytes	0644
ios_base.h	28515 bytes	0644
istream.tcc	31093 bytes	0644
list.tcc	12494 bytes	0644
locale_classes.h	22985 bytes	0644
locale_classes.tcc	8381 bytes	0644
locale_facets.h	90971 bytes	0644
locale_facets.tcc	38935 bytes	0644
locale_facets_nonio.h	65035 bytes	0644
locale_facets_nonio.tcc	41830 bytes	0644
localefwd.h	5220 bytes	0644
mask_array.h	7587 bytes	0644
memoryfwd.h	2419 bytes	0644
move.h	5804 bytes	0644
nested_exception.h	4694 bytes	0644
ostream.tcc	12315 bytes	0644
ostream_insert.h	4002 bytes	0644
postypes.h	8208 bytes	0644
ptr_traits.h	5294 bytes	0644
random.h	177346 bytes	0644
random.tcc	109149 bytes	0644
range_access.h	3132 bytes	0644
regex.h	85498 bytes	0644
regex_compiler.h	28348 bytes	0644
regex_constants.h	11066 bytes	0644
regex_cursor.h	2761 bytes	0644
regex_error.h	4611 bytes	0644
regex_grep_matcher.h	4332 bytes	0644
regex_grep_matcher.tcc	5541 bytes	0644
regex_nfa.h	10910 bytes	0644
regex_nfa.tcc	4965 bytes	0644
shared_ptr.h	19423 bytes	0644
shared_ptr_base.h	41622 bytes	0644
slice_array.h	9340 bytes	0644
sstream.tcc	9490 bytes	0644
stl_algo.h	217649 bytes	0644
stl_algobase.h	42400 bytes	0644
stl_bvector.h	29675 bytes	0644
stl_construct.h	5170 bytes	0644
stl_deque.h	68001 bytes	0644
stl_function.h	22585 bytes	0644
stl_heap.h	20472 bytes	0644
stl_iterator.h	36625 bytes	0644
stl_iterator_base_funcs.h	6961 bytes	0644
stl_iterator_base_types.h	8388 bytes	0644
stl_list.h	54094 bytes	0644
stl_map.h	37660 bytes	0644
stl_multimap.h	34751 bytes	0644
stl_multiset.h	29055 bytes	0644
stl_numeric.h	13820 bytes	0644
stl_pair.h	9865 bytes	0644
stl_queue.h	18652 bytes	0644
stl_raw_storage_iter.h	3455 bytes	0644
stl_relops.h	4599 bytes	0644
stl_set.h	29295 bytes	0644
stl_stack.h	9877 bytes	0644
stl_tempbuf.h	8344 bytes	0644
stl_tree.h	54848 bytes	0644
stl_uninitialized.h	20433 bytes	0644
stl_vector.h	49810 bytes	0644
stream_iterator.h	6597 bytes	0644
streambuf.tcc	4929 bytes	0644
streambuf_iterator.h	12624 bytes	0644
stringfwd.h	2426 bytes	0644
unique_ptr.h	17601 bytes	0644
unordered_map.h	48902 bytes	0644
unordered_set.h	44292 bytes	0644
uses_allocator.h	3577 bytes	0644
valarray_after.h	22655 bytes	0644
valarray_array.h	21743 bytes	0644
valarray_array.tcc	7254 bytes	0644
valarray_before.h	18513 bytes	0644
vector.tcc	26164 bytes	0644

File Content: stl_stack.h

File Content: `stl_stack.h`