LCOV - code coverage report
Current view: top level - usr/include/c++/6/bits - stl_pair.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 14 19 73.7 %
Date: 2018-11-14 16:53:58 Functions: 10 26 38.5 %

          Line data    Source code
       1             : // Pair implementation -*- C++ -*-
       2             : 
       3             : // Copyright (C) 2001-2016 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 { explicit piecewise_construct_t() = default; };
      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             : 
      88             :   // Concept utility functions, reused in conditionally-explicit
      89             :   // constructors.
      90             :   // See PR 70437, don't look at is_constructible or
      91             :   // is_convertible if the types are the same to
      92             :   // avoid querying those properties for incomplete types.
      93             :   template <bool, typename _T1, typename _T2>
      94             :     struct _PCC
      95             :     {
      96             :       template <typename _U1, typename _U2>
      97             :       static constexpr bool _ConstructiblePair()
      98             :       {
      99             :         return __and_<is_constructible<_T1, const _U1&>,
     100             :                       is_constructible<_T2, const _U2&>>::value;
     101             :       }
     102             : 
     103             :       template <typename _U1, typename _U2>
     104             :       static constexpr bool _ImplicitlyConvertiblePair()
     105             :       {
     106             :         return __and_<is_convertible<const _U1&, _T1>,
     107             :                       is_convertible<const _U2&, _T2>>::value;
     108             :       }
     109             : 
     110             :       template <typename _U1, typename _U2>
     111             :       static constexpr bool _MoveConstructiblePair()
     112             :       {
     113             :         return __and_<is_constructible<_T1, _U1&&>,
     114             :                       is_constructible<_T2, _U2&&>>::value;
     115             :       }
     116             : 
     117             :       template <typename _U1, typename _U2>
     118             :       static constexpr bool _ImplicitlyMoveConvertiblePair()
     119             :       {
     120             :         return __and_<is_convertible<_U1&&, _T1>,
     121             :                       is_convertible<_U2&&, _T2>>::value;
     122             :       }
     123             : 
     124             :       template <bool __implicit, typename _U1, typename _U2>
     125             :       static constexpr bool _CopyMovePair()
     126             :       {
     127             :         using __do_converts = __and_<is_convertible<const _U1&, _T1>,
     128             :                                   is_convertible<_U2&&, _T2>>;
     129             :         using __converts = typename conditional<__implicit,
     130             :                                        __do_converts,
     131             :                                        __not_<__do_converts>>::type;
     132             :         return __and_<is_constructible<_T1, const _U1&>,
     133             :                       is_constructible<_T2, _U2&&>,
     134             :                       __converts
     135             :                       >::value;
     136             :       }
     137             : 
     138             :       template <bool __implicit, typename _U1, typename _U2>
     139             :       static constexpr bool _MoveCopyPair()
     140             :       {
     141             :         using __do_converts = __and_<is_convertible<_U1&&, _T1>,
     142             :                                   is_convertible<const _U2&, _T2>>;
     143             :         using __converts = typename conditional<__implicit,
     144             :                                        __do_converts,
     145             :                                        __not_<__do_converts>>::type;
     146             :         return __and_<is_constructible<_T1, _U1&&>,
     147             :                       is_constructible<_T2, const _U2&&>,
     148             :                       __converts
     149             :                       >::value;
     150             :       }
     151             :   };
     152             : 
     153             :   template <typename _T1, typename _T2>
     154             :     struct _PCC<false, _T1, _T2>
     155             :     {
     156             :       template <typename _U1, typename _U2>
     157             :       static constexpr bool _ConstructiblePair()
     158             :       {
     159             :         return false;
     160             :       }
     161             : 
     162             :       template <typename _U1, typename _U2>
     163             :       static constexpr bool _ImplicitlyConvertiblePair()
     164             :       {
     165             :         return false;
     166             :       }
     167             : 
     168             :       template <typename _U1, typename _U2>
     169             :       static constexpr bool _MoveConstructiblePair()
     170             :       {
     171             :         return false;
     172             :       }
     173             : 
     174             :       template <typename _U1, typename _U2>
     175             :       static constexpr bool _ImplicitlyMoveConvertiblePair()
     176             :       {
     177             :         return false;
     178             :       }
     179             :   };
     180             : 
     181             :   struct __wrap_nonesuch : std::__nonesuch {
     182             :     explicit __wrap_nonesuch(const __nonesuch&) = delete;
     183             :   };
     184             :   
     185             : #endif
     186             : 
     187             :  /**
     188             :    *  @brief Struct holding two objects of arbitrary type.
     189             :    *
     190             :    *  @tparam _T1  Type of first object.
     191             :    *  @tparam _T2  Type of second object.
     192             :    */
     193             :   template<typename _T1, typename _T2>
     194          15 :     struct pair
     195             :     {
     196             :       typedef _T1 first_type;    /// @c first_type is the first bound type
     197             :       typedef _T2 second_type;   /// @c second_type is the second bound type
     198             : 
     199             :       _T1 first;                 /// @c first is a copy of the first object
     200             :       _T2 second;                /// @c second is a copy of the second object
     201             : 
     202             :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
     203             :       // 265.  std::pair::pair() effects overly restrictive
     204             :       /** The default constructor creates @c first and @c second using their
     205             :        *  respective default constructors.  */
     206             : #if __cplusplus >= 201103L
     207             :       template <typename _U1 = _T1,
     208             :                 typename _U2 = _T2,
     209             :                 typename enable_if<__and_<
     210             :                                      __is_implicitly_default_constructible<_U1>,
     211             :                                      __is_implicitly_default_constructible<_U2>>
     212             :                                    ::value, bool>::type = true>
     213             : #endif
     214           1 :       _GLIBCXX_CONSTEXPR pair()
     215           1 :       : first(), second() { }
     216             : 
     217             : #if __cplusplus >= 201103L
     218             :       template <typename _U1 = _T1,
     219             :                 typename _U2 = _T2,
     220             :                 typename enable_if<__and_<
     221             :                        is_default_constructible<_U1>,
     222             :                        is_default_constructible<_U2>,
     223             :                        __not_<
     224             :                          __and_<__is_implicitly_default_constructible<_U1>,
     225             :                                 __is_implicitly_default_constructible<_U2>>>>
     226             :                                    ::value, bool>::type = false>
     227             :       explicit constexpr pair()
     228             :       : first(), second() { }
     229             : #endif
     230             : 
     231             :       /** Two objects may be passed to a @c pair constructor to be copied.  */
     232             : #if __cplusplus < 201103L
     233             :       pair(const _T1& __a, const _T2& __b)
     234             :       : first(__a), second(__b) { }
     235             : #else
     236             :       // Shortcut for constraining the templates that don't take pairs.
     237             :       using _PCCP = _PCC<true, _T1, _T2>;
     238             : 
     239             :       template<typename _U1 = _T1, typename _U2=_T2, typename
     240             :                enable_if<_PCCP::template
     241             :                            _ConstructiblePair<_U1, _U2>()
     242             :                          && _PCCP::template
     243             :                            _ImplicitlyConvertiblePair<_U1, _U2>(),
     244             :                          bool>::type=true>
     245           1 :       constexpr pair(const _T1& __a, const _T2& __b)
     246           1 :       : first(__a), second(__b) { }
     247             : 
     248             :        template<typename _U1 = _T1, typename _U2=_T2, typename
     249             :                 enable_if<_PCCP::template
     250             :                             _ConstructiblePair<_U1, _U2>()
     251             :                           && !_PCCP::template
     252             :                             _ImplicitlyConvertiblePair<_U1, _U2>(),
     253             :                          bool>::type=false>
     254             :       explicit constexpr pair(const _T1& __a, const _T2& __b)
     255             :       : first(__a), second(__b) { }
     256             : #endif
     257             : 
     258             :       /** There is also a templated copy ctor for the @c pair class itself.  */
     259             : #if __cplusplus < 201103L
     260             :       template<typename _U1, typename _U2>
     261             :         pair(const pair<_U1, _U2>& __p)
     262             :         : first(__p.first), second(__p.second) { }
     263             : #else
     264             :       // Shortcut for constraining the templates that take pairs.
     265             :       template <typename _U1, typename _U2>
     266             :         using _PCCFP = _PCC<!is_same<_T1, _U1>::value
     267             :                             || !is_same<_T2, _U2>::value,
     268             :                             _T1, _T2>;
     269             : 
     270             :       template<typename _U1, typename _U2, typename
     271             :                enable_if<_PCCFP<_U1, _U2>::template
     272             :                            _ConstructiblePair<_U1, _U2>()
     273             :                          && _PCCFP<_U1, _U2>::template
     274             :                            _ImplicitlyConvertiblePair<_U1, _U2>(),
     275             :                           bool>::type=true>
     276             :         constexpr pair(const pair<_U1, _U2>& __p)
     277             :         : first(__p.first), second(__p.second) { }
     278             : 
     279             :       template<typename _U1, typename _U2, typename
     280             :                enable_if<_PCCFP<_U1, _U2>::template
     281             :                            _ConstructiblePair<_U1, _U2>()
     282             :                          && !_PCCFP<_U1, _U2>::template
     283             :                            _ImplicitlyConvertiblePair<_U1, _U2>(),
     284             :                          bool>::type=false>
     285             :         explicit constexpr pair(const pair<_U1, _U2>& __p)
     286             :         : first(__p.first), second(__p.second) { }
     287             : 
     288           1 :       constexpr pair(const pair&) = default;
     289           0 :       constexpr pair(pair&&) = default;
     290             : 
     291             :       // DR 811.
     292             :       template<typename _U1, typename
     293             :                enable_if<_PCCP::template
     294             :                            _MoveCopyPair<true, _U1, _T2>(),
     295             :                          bool>::type=true>
     296           0 :        constexpr pair(_U1&& __x, const _T2& __y)
     297           0 :        : first(std::forward<_U1>(__x)), second(__y) { }
     298             : 
     299             :       template<typename _U1, typename
     300             :                enable_if<_PCCP::template
     301             :                            _MoveCopyPair<false, _U1, _T2>(),
     302             :                          bool>::type=false>
     303             :        explicit constexpr pair(_U1&& __x, const _T2& __y)
     304             :        : first(std::forward<_U1>(__x)), second(__y) { }
     305             : 
     306             :       template<typename _U2, typename
     307             :                enable_if<_PCCP::template
     308             :                            _CopyMovePair<true, _T1, _U2>(),
     309             :                          bool>::type=true>
     310           0 :        constexpr pair(const _T1& __x, _U2&& __y)
     311           0 :        : first(__x), second(std::forward<_U2>(__y)) { }
     312             : 
     313             :       template<typename _U2, typename
     314             :                enable_if<_PCCP::template
     315             :                            _CopyMovePair<false, _T1, _U2>(),
     316             :                          bool>::type=false>
     317             :        explicit pair(const _T1& __x, _U2&& __y)
     318             :        : first(__x), second(std::forward<_U2>(__y)) { }
     319             : 
     320             :       template<typename _U1, typename _U2, typename
     321             :                enable_if<_PCCP::template
     322             :                            _MoveConstructiblePair<_U1, _U2>()
     323             :                           && _PCCP::template
     324             :                            _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
     325             :                          bool>::type=true>
     326          12 :         constexpr pair(_U1&& __x, _U2&& __y)
     327          12 :         : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
     328             : 
     329             :       template<typename _U1, typename _U2, typename
     330             :                enable_if<_PCCP::template
     331             :                            _MoveConstructiblePair<_U1, _U2>()
     332             :                           && !_PCCP::template
     333             :                            _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
     334             :                          bool>::type=false>
     335             :         explicit constexpr pair(_U1&& __x, _U2&& __y)
     336             :         : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
     337             : 
     338             : 
     339             :       template<typename _U1, typename _U2, typename
     340             :                enable_if<_PCCFP<_U1, _U2>::template
     341             :                            _MoveConstructiblePair<_U1, _U2>()
     342             :                           && _PCCFP<_U1, _U2>::template
     343             :                            _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
     344             :                          bool>::type=true>
     345             :         constexpr pair(pair<_U1, _U2>&& __p)
     346             :         : first(std::forward<_U1>(__p.first)),
     347             :           second(std::forward<_U2>(__p.second)) { }
     348             : 
     349             :       template<typename _U1, typename _U2, typename
     350             :                enable_if<_PCCFP<_U1, _U2>::template
     351             :                            _MoveConstructiblePair<_U1, _U2>()
     352             :                           && !_PCCFP<_U1, _U2>::template
     353             :                            _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
     354             :                          bool>::type=false>
     355             :         explicit constexpr pair(pair<_U1, _U2>&& __p)
     356             :         : first(std::forward<_U1>(__p.first)),
     357             :           second(std::forward<_U2>(__p.second)) { }
     358             : 
     359             :       template<typename... _Args1, typename... _Args2>
     360             :         pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
     361             : 
     362             :       pair&
     363             :       operator=(typename conditional<
     364             :                 __and_<is_copy_assignable<_T1>,
     365             :                        is_copy_assignable<_T2>>::value,
     366             :                 const pair&, const __wrap_nonesuch&>::type __p)
     367             :       {
     368             :         first = __p.first;
     369             :         second = __p.second;
     370             :         return *this;
     371             :       }
     372             : 
     373             :       pair&
     374             :       operator=(typename conditional<
     375             :                 __not_<__and_<is_copy_assignable<_T1>,
     376             :                               is_copy_assignable<_T2>>>::value,
     377             :                 const pair&, const __wrap_nonesuch&>::type __p) = delete;
     378             : 
     379             :       pair&
     380           1 :       operator=(typename conditional<
     381             :                 __and_<is_move_assignable<_T1>,
     382             :                        is_move_assignable<_T2>>::value,
     383             :                 pair&&, __wrap_nonesuch&&>::type __p)
     384             :       noexcept(__and_<is_nothrow_move_assignable<_T1>,
     385             :                       is_nothrow_move_assignable<_T2>>::value)
     386             :       {
     387           1 :         first = std::forward<first_type>(__p.first);
     388           1 :         second = std::forward<second_type>(__p.second);
     389           1 :         return *this;
     390             :       }
     391             : 
     392             :       template<typename _U1, typename _U2>
     393             :       typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
     394             :                                 is_assignable<_T2&, const _U2&>>::value,
     395             :                          pair&>::type
     396             :         operator=(const pair<_U1, _U2>& __p)
     397             :         {
     398             :           first = __p.first;
     399             :           second = __p.second;
     400             :           return *this;
     401             :         }
     402             : 
     403             :       template<typename _U1, typename _U2>
     404             :       typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
     405             :                                 is_assignable<_T2&, _U2&&>>::value,
     406             :                          pair&>::type
     407             :         operator=(pair<_U1, _U2>&& __p)
     408             :         {
     409             :           first = std::forward<_U1>(__p.first);
     410             :           second = std::forward<_U2>(__p.second);
     411             :           return *this;
     412             :         }
     413             : 
     414             :       void
     415             :       swap(pair& __p)
     416             :       noexcept(__is_nothrow_swappable<_T1>::value
     417             :                && __is_nothrow_swappable<_T2>::value)
     418             :       {
     419             :         using std::swap;
     420             :         swap(first, __p.first);
     421             :         swap(second, __p.second);
     422             :       }
     423             : 
     424             :     private:
     425             :       template<typename... _Args1, std::size_t... _Indexes1,
     426             :                typename... _Args2, std::size_t... _Indexes2>
     427             :         pair(tuple<_Args1...>&, tuple<_Args2...>&,
     428             :              _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
     429             : #endif
     430             :     };
     431             : 
     432             :   /// Two pairs of the same type are equal iff their members are equal.
     433             :   template<typename _T1, typename _T2>
     434             :     inline _GLIBCXX_CONSTEXPR bool
     435             :     operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
     436             :     { return __x.first == __y.first && __x.second == __y.second; }
     437             : 
     438             :   /// <http://gcc.gnu.org/onlinedocs/libstdc++/manual/utilities.html>
     439             :   template<typename _T1, typename _T2>
     440             :     inline _GLIBCXX_CONSTEXPR bool
     441             :     operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
     442             :     { return __x.first < __y.first
     443             :              || (!(__y.first < __x.first) && __x.second < __y.second); }
     444             : 
     445             :   /// Uses @c operator== to find the result.
     446             :   template<typename _T1, typename _T2>
     447             :     inline _GLIBCXX_CONSTEXPR bool
     448             :     operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
     449             :     { return !(__x == __y); }
     450             : 
     451             :   /// Uses @c operator< to find the result.
     452             :   template<typename _T1, typename _T2>
     453             :     inline _GLIBCXX_CONSTEXPR bool
     454             :     operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
     455             :     { return __y < __x; }
     456             : 
     457             :   /// Uses @c operator< to find the result.
     458             :   template<typename _T1, typename _T2>
     459             :     inline _GLIBCXX_CONSTEXPR bool
     460             :     operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
     461             :     { return !(__y < __x); }
     462             : 
     463             :   /// Uses @c operator< to find the result.
     464             :   template<typename _T1, typename _T2>
     465             :     inline _GLIBCXX_CONSTEXPR bool
     466             :     operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
     467             :     { return !(__x < __y); }
     468             : 
     469             : #if __cplusplus >= 201103L
     470             :   /// See std::pair::swap().
     471             :   // Note:  no std::swap overloads in C++03 mode, this has performance
     472             :   //        implications, see, eg, libstdc++/38466.
     473             :   template<typename _T1, typename _T2>
     474             :     inline void
     475             :     swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
     476             :     noexcept(noexcept(__x.swap(__y)))
     477             :     { __x.swap(__y); }
     478             : #endif
     479             : 
     480             :   /**
     481             :    *  @brief A convenience wrapper for creating a pair from two objects.
     482             :    *  @param  __x  The first object.
     483             :    *  @param  __y  The second object.
     484             :    *  @return   A newly-constructed pair<> object of the appropriate type.
     485             :    *
     486             :    *  The standard requires that the objects be passed by reference-to-const,
     487             :    *  but LWG issue #181 says they should be passed by const value.  We follow
     488             :    *  the LWG by default.
     489             :    */
     490             :   // _GLIBCXX_RESOLVE_LIB_DEFECTS
     491             :   // 181.  make_pair() unintended behavior
     492             : #if __cplusplus >= 201103L
     493             :   // NB: DR 706.
     494             :   template<typename _T1, typename _T2>
     495             :     constexpr pair<typename __decay_and_strip<_T1>::__type,
     496             :                    typename __decay_and_strip<_T2>::__type>
     497           2 :     make_pair(_T1&& __x, _T2&& __y)
     498             :     {
     499             :       typedef typename __decay_and_strip<_T1>::__type __ds_type1;
     500             :       typedef typename __decay_and_strip<_T2>::__type __ds_type2;
     501             :       typedef pair<__ds_type1, __ds_type2>              __pair_type;
     502           2 :       return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
     503             :     }
     504             : #else
     505             :   template<typename _T1, typename _T2>
     506             :     inline pair<_T1, _T2>
     507             :     make_pair(_T1 __x, _T2 __y)
     508             :     { return pair<_T1, _T2>(__x, __y); }
     509             : #endif
     510             : 
     511             :   /// @}
     512             : 
     513             : _GLIBCXX_END_NAMESPACE_VERSION
     514             : } // namespace std
     515             : 
     516             : #endif /* _STL_PAIR_H */

Generated by: LCOV version 1.13