LCOV - code coverage report
Current view: top level - c++/5/bits - stl_pair.h (source / functions) Hit Total Coverage
Test: lcov-run.info Lines: 0 2 0.0 %
Date: 2019-02-15 00:00:25 Functions: 0 0 -
Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // Pair implementation -*- C++ -*-
       2                 :            : 
       3                 :            : // Copyright (C) 2001-2015 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                 :            :     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                 :            :       _GLIBCXX_CONSTEXPR pair()
     109                 :            :       : first(), second() { }
     110                 :            : 
     111                 :            :       /** Two objects may be passed to a @c pair constructor to be copied.  */
     112                 :            :       _GLIBCXX_CONSTEXPR pair(const _T1& __a, const _T2& __b)
     113                 :            :       : 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                 :            :       constexpr pair(const pair&) = default;
     128                 :            :       constexpr pair(pair&&) = default;
     129                 :            : 
     130                 :            :       // DR 811.
     131                 :            :       template<class _U1, class = typename
     132                 :            :                enable_if<is_convertible<_U1, _T1>::value>::type>
     133                 :            :         constexpr pair(_U1&& __x, const _T2& __y)
     134                 :            :         : first(std::forward<_U1>(__x)), second(__y) { }
     135                 :            : 
     136                 :            :       template<class _U2, class = typename
     137                 :            :                enable_if<is_convertible<_U2, _T2>::value>::type>
     138                 :            :         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                 :            :         constexpr pair(_U1&& __x, _U2&& __y)
     145                 :          0 :         : 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                 :            :       operator=(pair&& __p)
     167                 :            :       noexcept(__and_<is_nothrow_move_assignable<_T1>,
     168                 :            :                       is_nothrow_move_assignable<_T2>>::value)
     169                 :            :       {
     170                 :            :         first = std::forward<first_type>(__p.first);
     171                 :            :         second = std::forward<second_type>(__p.second);
     172                 :            :         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                 :            :     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                 :            :       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.12