LCOV - code coverage report
Current view: top level - usr/include/c++/4.9/bits - stl_pair.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 3 19 15.8 %
Date: 2016-12-01 18:45:36 Functions: 2 26 7.7 %

          Line data    Source code
       1             : // Pair implementation -*- C++ -*-
       2             : 
       3             : // Copyright (C) 2001-2014 Free Software Foundation, Inc.
       4             : //
       5             : // This file is part of the GNU ISO C++ Library.  This library is free
       6             : // software; you can redistribute it and/or modify it under the
       7             : // terms of the GNU General Public License as published by the
       8             : // Free Software Foundation; either version 3, or (at your option)
       9             : // any later version.
      10             : 
      11             : // This library is distributed in the hope that it will be useful,
      12             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             : // GNU General Public License for more details.
      15             : 
      16             : // Under Section 7 of GPL version 3, you are granted additional
      17             : // permissions described in the GCC Runtime Library Exception, version
      18             : // 3.1, as published by the Free Software Foundation.
      19             : 
      20             : // You should have received a copy of the GNU General Public License and
      21             : // a copy of the GCC Runtime Library Exception along with this program;
      22             : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
      23             : // <http://www.gnu.org/licenses/>.
      24             : 
      25             : /*
      26             :  *
      27             :  * Copyright (c) 1994
      28             :  * Hewlett-Packard Company
      29             :  *
      30             :  * Permission to use, copy, modify, distribute and sell this software
      31             :  * and its documentation for any purpose is hereby granted without fee,
      32             :  * provided that the above copyright notice appear in all copies and
      33             :  * that both that copyright notice and this permission notice appear
      34             :  * in supporting documentation.  Hewlett-Packard Company makes no
      35             :  * representations about the suitability of this software for any
      36             :  * purpose.  It is provided "as is" without express or implied warranty.
      37             :  *
      38             :  *
      39             :  * Copyright (c) 1996,1997
      40             :  * Silicon Graphics Computer Systems, Inc.
      41             :  *
      42             :  * Permission to use, copy, modify, distribute and sell this software
      43             :  * and its documentation for any purpose is hereby granted without fee,
      44             :  * provided that the above copyright notice appear in all copies and
      45             :  * that both that copyright notice and this permission notice appear
      46             :  * in supporting documentation.  Silicon Graphics makes no
      47             :  * representations about the suitability of this software for any
      48             :  * purpose.  It is provided "as is" without express or implied warranty.
      49             :  */
      50             : 
      51             : /** @file bits/stl_pair.h
      52             :  *  This is an internal header file, included by other library headers.
      53             :  *  Do not attempt to use it directly. @headername{utility}
      54             :  */
      55             : 
      56             : #ifndef _STL_PAIR_H
      57             : #define _STL_PAIR_H 1
      58             : 
      59             : #include <bits/move.h> // for std::move / std::forward, and std::swap
      60             : 
      61             : #if __cplusplus >= 201103L
      62             : #include <type_traits> // for std::__decay_and_strip too
      63             : #endif
      64             : 
      65             : namespace std _GLIBCXX_VISIBILITY(default)
      66             : {
      67             : _GLIBCXX_BEGIN_NAMESPACE_VERSION
      68             : 
      69             :   /**
      70             :    *  @addtogroup utilities
      71             :    *  @{
      72             :    */
      73             : 
      74             : #if __cplusplus >= 201103L
      75             :   /// piecewise_construct_t
      76             :   struct piecewise_construct_t { };
      77             : 
      78             :   /// piecewise_construct
      79             :   constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
      80             : 
      81             :   // Forward declarations.
      82             :   template<typename...>
      83             :     class tuple;
      84             : 
      85             :   template<std::size_t...>
      86             :     struct _Index_tuple;
      87             : #endif
      88             : 
      89             :  /**
      90             :    *  @brief Struct holding two objects of arbitrary type.
      91             :    *
      92             :    *  @tparam _T1  Type of first object.
      93             :    *  @tparam _T2  Type of second object.
      94             :    */
      95             :   template<class _T1, class _T2>
      96          11 :     struct pair
      97             :     {
      98             :       typedef _T1 first_type;    /// @c first_type is the first bound type
      99             :       typedef _T2 second_type;   /// @c second_type is the second bound type
     100             : 
     101             :       _T1 first;                 /// @c first is a copy of the first object
     102             :       _T2 second;                /// @c second is a copy of the second object
     103             : 
     104             :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
     105             :       // 265.  std::pair::pair() effects overly restrictive
     106             :       /** The default constructor creates @c first and @c second using their
     107             :        *  respective default constructors.  */
     108           0 :       _GLIBCXX_CONSTEXPR pair()
     109           0 :       : first(), second() { }
     110             : 
     111             :       /** Two objects may be passed to a @c pair constructor to be copied.  */
     112           0 :       _GLIBCXX_CONSTEXPR pair(const _T1& __a, const _T2& __b)
     113           0 :       : first(__a), second(__b) { }
     114             : 
     115             :       /** There is also a templated copy ctor for the @c pair class itself.  */
     116             : #if __cplusplus < 201103L
     117             :       template<class _U1, class _U2>
     118             :         pair(const pair<_U1, _U2>& __p)
     119             :         : first(__p.first), second(__p.second) { }
     120             : #else
     121             :       template<class _U1, class _U2, class = typename
     122             :                enable_if<__and_<is_convertible<const _U1&, _T1>,
     123             :                                 is_convertible<const _U2&, _T2>>::value>::type>
     124             :         constexpr pair(const pair<_U1, _U2>& __p)
     125             :         : first(__p.first), second(__p.second) { }
     126             : 
     127           0 :       constexpr pair(const pair&) = default;
     128           0 :       constexpr pair(pair&&) = default;
     129             : 
     130             :       // DR 811.
     131             :       template<class _U1, class = typename
     132             :                enable_if<is_convertible<_U1, _T1>::value>::type>
     133           0 :         constexpr pair(_U1&& __x, const _T2& __y)
     134           0 :         : first(std::forward<_U1>(__x)), second(__y) { }
     135             : 
     136             :       template<class _U2, class = typename
     137             :                enable_if<is_convertible<_U2, _T2>::value>::type>
     138           0 :         constexpr pair(const _T1& __x, _U2&& __y)
     139           0 :         : first(__x), second(std::forward<_U2>(__y)) { }
     140             : 
     141             :       template<class _U1, class _U2, class = typename
     142             :                enable_if<__and_<is_convertible<_U1, _T1>,
     143             :                                 is_convertible<_U2, _T2>>::value>::type>
     144          11 :         constexpr pair(_U1&& __x, _U2&& __y)
     145          11 :         : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
     146             : 
     147             :       template<class _U1, class _U2, class = typename
     148             :                enable_if<__and_<is_convertible<_U1, _T1>,
     149             :                                 is_convertible<_U2, _T2>>::value>::type>
     150             :         constexpr pair(pair<_U1, _U2>&& __p)
     151             :         : first(std::forward<_U1>(__p.first)),
     152             :           second(std::forward<_U2>(__p.second)) { }
     153             : 
     154             :       template<typename... _Args1, typename... _Args2>
     155             :         pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
     156             : 
     157             :       pair&
     158             :       operator=(const pair& __p)
     159             :       {
     160             :         first = __p.first;
     161             :         second = __p.second;
     162             :         return *this;
     163             :       }
     164             : 
     165             :       pair&
     166           0 :       operator=(pair&& __p)
     167             :       noexcept(__and_<is_nothrow_move_assignable<_T1>,
     168             :                       is_nothrow_move_assignable<_T2>>::value)
     169             :       {
     170           0 :         first = std::forward<first_type>(__p.first);
     171           0 :         second = std::forward<second_type>(__p.second);
     172           0 :         return *this;
     173             :       }
     174             : 
     175             :       template<class _U1, class _U2>
     176             :         pair&
     177             :         operator=(const pair<_U1, _U2>& __p)
     178             :         {
     179             :           first = __p.first;
     180             :           second = __p.second;
     181             :           return *this;
     182             :         }
     183             : 
     184             :       template<class _U1, class _U2>
     185             :         pair&
     186             :         operator=(pair<_U1, _U2>&& __p)
     187             :         {
     188             :           first = std::forward<_U1>(__p.first);
     189             :           second = std::forward<_U2>(__p.second);
     190             :           return *this;
     191             :         }
     192             : 
     193             :       void
     194             :       swap(pair& __p)
     195             :       noexcept(noexcept(swap(first, __p.first))
     196             :                && noexcept(swap(second, __p.second)))
     197             :       {
     198             :         using std::swap;
     199             :         swap(first, __p.first);
     200             :         swap(second, __p.second);
     201             :       }
     202             : 
     203             :     private:
     204             :       template<typename... _Args1, std::size_t... _Indexes1,
     205             :                typename... _Args2, std::size_t... _Indexes2>
     206             :         pair(tuple<_Args1...>&, tuple<_Args2...>&,
     207             :              _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
     208             : #endif
     209             :     };
     210             : 
     211             :   /// Two pairs of the same type are equal iff their members are equal.
     212             :   template<class _T1, class _T2>
     213             :     inline _GLIBCXX_CONSTEXPR bool
     214             :     operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
     215             :     { return __x.first == __y.first && __x.second == __y.second; }
     216             : 
     217             :   /// <http://gcc.gnu.org/onlinedocs/libstdc++/manual/utilities.html>
     218             :   template<class _T1, class _T2>
     219             :     inline _GLIBCXX_CONSTEXPR bool
     220             :     operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
     221             :     { return __x.first < __y.first
     222             :              || (!(__y.first < __x.first) && __x.second < __y.second); }
     223             : 
     224             :   /// Uses @c operator== to find the result.
     225             :   template<class _T1, class _T2>
     226             :     inline _GLIBCXX_CONSTEXPR bool
     227             :     operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
     228             :     { return !(__x == __y); }
     229             : 
     230             :   /// Uses @c operator< to find the result.
     231             :   template<class _T1, class _T2>
     232             :     inline _GLIBCXX_CONSTEXPR bool
     233             :     operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
     234             :     { return __y < __x; }
     235             : 
     236             :   /// Uses @c operator< to find the result.
     237             :   template<class _T1, class _T2>
     238             :     inline _GLIBCXX_CONSTEXPR bool
     239             :     operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
     240             :     { return !(__y < __x); }
     241             : 
     242             :   /// Uses @c operator< to find the result.
     243             :   template<class _T1, class _T2>
     244             :     inline _GLIBCXX_CONSTEXPR bool
     245             :     operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
     246             :     { return !(__x < __y); }
     247             : 
     248             : #if __cplusplus >= 201103L
     249             :   /// See std::pair::swap().
     250             :   // Note:  no std::swap overloads in C++03 mode, this has performance
     251             :   //        implications, see, eg, libstdc++/38466.
     252             :   template<class _T1, class _T2>
     253             :     inline void
     254             :     swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
     255             :     noexcept(noexcept(__x.swap(__y)))
     256             :     { __x.swap(__y); }
     257             : #endif
     258             : 
     259             :   /**
     260             :    *  @brief A convenience wrapper for creating a pair from two objects.
     261             :    *  @param  __x  The first object.
     262             :    *  @param  __y  The second object.
     263             :    *  @return   A newly-constructed pair<> object of the appropriate type.
     264             :    *
     265             :    *  The standard requires that the objects be passed by reference-to-const,
     266             :    *  but LWG issue #181 says they should be passed by const value.  We follow
     267             :    *  the LWG by default.
     268             :    */
     269             :   // _GLIBCXX_RESOLVE_LIB_DEFECTS
     270             :   // 181.  make_pair() unintended behavior
     271             : #if __cplusplus >= 201103L
     272             :   // NB: DR 706.
     273             :   template<class _T1, class _T2>
     274             :     constexpr pair<typename __decay_and_strip<_T1>::__type,
     275             :                    typename __decay_and_strip<_T2>::__type>
     276           0 :     make_pair(_T1&& __x, _T2&& __y)
     277             :     {
     278             :       typedef typename __decay_and_strip<_T1>::__type __ds_type1;
     279             :       typedef typename __decay_and_strip<_T2>::__type __ds_type2;
     280             :       typedef pair<__ds_type1, __ds_type2>              __pair_type;
     281           0 :       return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
     282             :     }
     283             : #else
     284             :   template<class _T1, class _T2>
     285             :     inline pair<_T1, _T2>
     286             :     make_pair(_T1 __x, _T2 __y)
     287             :     { return pair<_T1, _T2>(__x, __y); }
     288             : #endif
     289             : 
     290             :   /// @}
     291             : 
     292             : _GLIBCXX_END_NAMESPACE_VERSION
     293             : } // namespace std
     294             : 
     295             : #endif /* _STL_PAIR_H */

Generated by: LCOV version 1.11