<h2>Editing File: /usr/include/c++/8/utility</h2><form method='post'><textarea name='content' class='file-edit'>// &lt;utility&gt; -*- C++ -*-

// Copyright (C) 2001-2018 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
// &lt;http://www.gnu.org/licenses/&gt;.

/*
 *
 * 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 &quot;as is&quot; 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 &quot;as is&quot; without express or implied warranty.
 */

/** @file include/utility
 *  This is a Standard C++ Library header.
 */

#ifndef _GLIBCXX_UTILITY
#define _GLIBCXX_UTILITY 1

#pragma GCC system_header

/**
 * @defgroup utilities Utilities
 *
 * Components deemed generally useful. Includes pair, tuple,
 * forward/move helpers, ratio, function object, metaprogramming and
 * type traits, time, date, and memory functions.
 */

#include &lt;bits/c++config.h&gt;
#include &lt;bits/stl_relops.h&gt;
#include &lt;bits/stl_pair.h&gt;

#if __cplusplus &gt;= 201103L

#include &lt;type_traits&gt;
#include &lt;bits/move.h&gt;
#include &lt;initializer_list&gt;

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  /// Finds the size of a given tuple type.
  template&lt;typename _Tp&gt;
    struct tuple_size;

  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 2313. tuple_size should always derive from integral_constant&lt;size_t, N&gt;
  // 2770. tuple_size&lt;const T&gt; specialization is not SFINAE compatible

  template&lt;typename _Tp,
	   typename _Up = typename remove_cv&lt;_Tp&gt;::type,
	   typename = typename enable_if&lt;is_same&lt;_Tp, _Up&gt;::value&gt;::type,
	   size_t = tuple_size&lt;_Tp&gt;::value&gt;
    using __enable_if_has_tuple_size = _Tp;

  template&lt;typename _Tp&gt;
    struct tuple_size&lt;const __enable_if_has_tuple_size&lt;_Tp&gt;&gt;
    : public tuple_size&lt;_Tp&gt; { };

  template&lt;typename _Tp&gt;
    struct tuple_size&lt;volatile __enable_if_has_tuple_size&lt;_Tp&gt;&gt;
    : public tuple_size&lt;_Tp&gt; { };

  template&lt;typename _Tp&gt;
    struct tuple_size&lt;const volatile __enable_if_has_tuple_size&lt;_Tp&gt;&gt;
    : public tuple_size&lt;_Tp&gt; { };

  /// Gives the type of the ith element of a given tuple type.
  template&lt;std::size_t __i, typename _Tp&gt;
    struct tuple_element;

  // Duplicate of C++14's tuple_element_t for internal use in C++11 mode
  template&lt;std::size_t __i, typename _Tp&gt;
    using __tuple_element_t = typename tuple_element&lt;__i, _Tp&gt;::type;

  template&lt;std::size_t __i, typename _Tp&gt;
    struct tuple_element&lt;__i, const _Tp&gt;
    {
      typedef typename add_const&lt;__tuple_element_t&lt;__i, _Tp&gt;&gt;::type type;
    };

  template&lt;std::size_t __i, typename _Tp&gt;
    struct tuple_element&lt;__i, volatile _Tp&gt;
    {
      typedef typename add_volatile&lt;__tuple_element_t&lt;__i, _Tp&gt;&gt;::type type;
    };

  template&lt;std::size_t __i, typename _Tp&gt;
    struct tuple_element&lt;__i, const volatile _Tp&gt;
    {
      typedef typename add_cv&lt;__tuple_element_t&lt;__i, _Tp&gt;&gt;::type type;
    };

#if __cplusplus &gt; 201103L
#define __cpp_lib_tuple_element_t 201402

  template&lt;std::size_t __i, typename _Tp&gt;
    using tuple_element_t = typename tuple_element&lt;__i, _Tp&gt;::type;
#endif

  // Various functions which give std::pair a tuple-like interface.

  /// Partial specialization for std::pair
  template&lt;typename _T1, typename _T2&gt;
    struct __is_tuple_like_impl&lt;std::pair&lt;_T1, _T2&gt;&gt; : true_type
    { };

  /// Partial specialization for std::pair
  template&lt;class _Tp1, class _Tp2&gt;
    struct tuple_size&lt;std::pair&lt;_Tp1, _Tp2&gt;&gt;
    : public integral_constant&lt;std::size_t, 2&gt; { };

  /// Partial specialization for std::pair
  template&lt;class _Tp1, class _Tp2&gt;
    struct tuple_element&lt;0, std::pair&lt;_Tp1, _Tp2&gt;&gt;
    { typedef _Tp1 type; };

  /// Partial specialization for std::pair
  template&lt;class _Tp1, class _Tp2&gt;
    struct tuple_element&lt;1, std::pair&lt;_Tp1, _Tp2&gt;&gt;
    { typedef _Tp2 type; };

  template&lt;std::size_t _Int&gt;
    struct __pair_get;

  template&lt;&gt;
    struct __pair_get&lt;0&gt;
    {
      template&lt;typename _Tp1, typename _Tp2&gt;
        static constexpr _Tp1&amp;
        __get(std::pair&lt;_Tp1, _Tp2&gt;&amp; __pair) noexcept
        { return __pair.first; }

      template&lt;typename _Tp1, typename _Tp2&gt;
        static constexpr _Tp1&amp;&amp;
        __move_get(std::pair&lt;_Tp1, _Tp2&gt;&amp;&amp; __pair) noexcept
        { return std::forward&lt;_Tp1&gt;(__pair.first); }

      template&lt;typename _Tp1, typename _Tp2&gt;
        static constexpr const _Tp1&amp;
        __const_get(const std::pair&lt;_Tp1, _Tp2&gt;&amp; __pair) noexcept
        { return __pair.first; }

      template&lt;typename _Tp1, typename _Tp2&gt;
        static constexpr const _Tp1&amp;&amp;
        __const_move_get(const std::pair&lt;_Tp1, _Tp2&gt;&amp;&amp; __pair) noexcept
        { return std::forward&lt;const _Tp1&gt;(__pair.first); }
    };

  template&lt;&gt;
    struct __pair_get&lt;1&gt;
    {
      template&lt;typename _Tp1, typename _Tp2&gt;
        static constexpr _Tp2&amp;
        __get(std::pair&lt;_Tp1, _Tp2&gt;&amp; __pair) noexcept
        { return __pair.second; }

      template&lt;typename _Tp1, typename _Tp2&gt;
        static constexpr _Tp2&amp;&amp;
        __move_get(std::pair&lt;_Tp1, _Tp2&gt;&amp;&amp; __pair) noexcept
        { return std::forward&lt;_Tp2&gt;(__pair.second); }

      template&lt;typename _Tp1, typename _Tp2&gt;
        static constexpr const _Tp2&amp;
        __const_get(const std::pair&lt;_Tp1, _Tp2&gt;&amp; __pair) noexcept
        { return __pair.second; }

      template&lt;typename _Tp1, typename _Tp2&gt;
        static constexpr const _Tp2&amp;&amp;
        __const_move_get(const std::pair&lt;_Tp1, _Tp2&gt;&amp;&amp; __pair) noexcept
        { return std::forward&lt;const _Tp2&gt;(__pair.second); }
    };

  template&lt;std::size_t _Int, class _Tp1, class _Tp2&gt;
    constexpr typename tuple_element&lt;_Int, std::pair&lt;_Tp1, _Tp2&gt;&gt;::type&amp;
    get(std::pair&lt;_Tp1, _Tp2&gt;&amp; __in) noexcept
    { return __pair_get&lt;_Int&gt;::__get(__in); }

  template&lt;std::size_t _Int, class _Tp1, class _Tp2&gt;
    constexpr typename tuple_element&lt;_Int, std::pair&lt;_Tp1, _Tp2&gt;&gt;::type&amp;&amp;
    get(std::pair&lt;_Tp1, _Tp2&gt;&amp;&amp; __in) noexcept
    { return __pair_get&lt;_Int&gt;::__move_get(std::move(__in)); }

  template&lt;std::size_t _Int, class _Tp1, class _Tp2&gt;
    constexpr const typename tuple_element&lt;_Int, std::pair&lt;_Tp1, _Tp2&gt;&gt;::type&amp;
    get(const std::pair&lt;_Tp1, _Tp2&gt;&amp; __in) noexcept
    { return __pair_get&lt;_Int&gt;::__const_get(__in); }

  template&lt;std::size_t _Int, class _Tp1, class _Tp2&gt;
    constexpr const typename tuple_element&lt;_Int, std::pair&lt;_Tp1, _Tp2&gt;&gt;::type&amp;&amp;
    get(const std::pair&lt;_Tp1, _Tp2&gt;&amp;&amp; __in) noexcept
    { return __pair_get&lt;_Int&gt;::__const_move_get(std::move(__in)); }

#if __cplusplus &gt; 201103L

#define __cpp_lib_tuples_by_type 201304

  template &lt;typename _Tp, typename _Up&gt;
    constexpr _Tp&amp;
    get(pair&lt;_Tp, _Up&gt;&amp; __p) noexcept
    { return __p.first; }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr const _Tp&amp;
    get(const pair&lt;_Tp, _Up&gt;&amp; __p) noexcept
    { return __p.first; }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr _Tp&amp;&amp;
    get(pair&lt;_Tp, _Up&gt;&amp;&amp; __p) noexcept
    { return std::move(__p.first); }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr const _Tp&amp;&amp;
    get(const pair&lt;_Tp, _Up&gt;&amp;&amp; __p) noexcept
    { return std::move(__p.first); }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr _Tp&amp;
    get(pair&lt;_Up, _Tp&gt;&amp; __p) noexcept
    { return __p.second; }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr const _Tp&amp;
    get(const pair&lt;_Up, _Tp&gt;&amp; __p) noexcept
    { return __p.second; }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr _Tp&amp;&amp;
    get(pair&lt;_Up, _Tp&gt;&amp;&amp; __p) noexcept
    { return std::move(__p.second); }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr const _Tp&amp;&amp;
    get(const pair&lt;_Up, _Tp&gt;&amp;&amp; __p) noexcept
    { return std::move(__p.second); }

#define __cpp_lib_exchange_function 201304

  /// Assign @p __new_val to @p __obj and return its previous value.
  template &lt;typename _Tp, typename _Up = _Tp&gt;
    inline _Tp
    exchange(_Tp&amp; __obj, _Up&amp;&amp; __new_val)
    { return std::__exchange(__obj, std::forward&lt;_Up&gt;(__new_val)); }
#endif

  // Stores a tuple of indices.  Used by tuple and pair, and by bind() to
  // extract the elements in a tuple.
  template&lt;size_t... _Indexes&gt; struct _Index_tuple { };

#ifdef __has_builtin
# if __has_builtin(__make_integer_seq)
#  define _GLIBCXX_USE_MAKE_INTEGER_SEQ 1
# endif
#endif

  // Builds an _Index_tuple&lt;0, 1, 2, ..., _Num-1&gt;.
  template&lt;size_t _Num&gt;
    struct _Build_index_tuple
    {
#if _GLIBCXX_USE_MAKE_INTEGER_SEQ
      template&lt;typename, size_t... _Indices&gt;
        using _IdxTuple = _Index_tuple&lt;_Indices...&gt;;

      using __type = __make_integer_seq&lt;_IdxTuple, size_t, _Num&gt;;
#else
      using __type = _Index_tuple&lt;__integer_pack(_Num)...&gt;;
#endif
    };

#if __cplusplus &gt; 201103L

#define __cpp_lib_integer_sequence 201304

  /// Class template integer_sequence
  template&lt;typename _Tp, _Tp... _Idx&gt;
    struct integer_sequence
    {
      typedef _Tp value_type;
      static constexpr size_t size() noexcept { return sizeof...(_Idx); }
    };

  /// Alias template make_integer_sequence
  template&lt;typename _Tp, _Tp _Num&gt;
    using make_integer_sequence
#if _GLIBCXX_USE_MAKE_INTEGER_SEQ
      = __make_integer_seq&lt;integer_sequence, _Tp, _Num&gt;;
#else
      = integer_sequence&lt;_Tp, __integer_pack(_Num)...&gt;;
#endif

#undef _GLIBCXX_USE_MAKE_INTEGER_SEQ

  /// Alias template index_sequence
  template&lt;size_t... _Idx&gt;
    using index_sequence = integer_sequence&lt;size_t, _Idx...&gt;;

  /// Alias template make_index_sequence
  template&lt;size_t _Num&gt;
    using make_index_sequence = make_integer_sequence&lt;size_t, _Num&gt;;

  /// Alias template index_sequence_for
  template&lt;typename... _Types&gt;
    using index_sequence_for = make_index_sequence&lt;sizeof...(_Types)&gt;;
#endif

#if __cplusplus &gt; 201402L

  struct in_place_t {
    explicit in_place_t() = default;
  };

  inline constexpr in_place_t in_place{};

  template&lt;typename _Tp&gt; struct in_place_type_t
  {
    explicit in_place_type_t() = default;
  };

  template&lt;typename _Tp&gt;
    inline constexpr in_place_type_t&lt;_Tp&gt; in_place_type{};

  template&lt;size_t _Idx&gt; struct in_place_index_t
  {
    explicit in_place_index_t() = default;
  };

  template&lt;size_t _Idx&gt;
    inline constexpr in_place_index_t&lt;_Idx&gt; in_place_index{};

  template&lt;typename&gt;
    struct __is_in_place_type_impl : false_type
    { };

  template&lt;typename _Tp&gt;
    struct __is_in_place_type_impl&lt;in_place_type_t&lt;_Tp&gt;&gt; : true_type
    { };

  template&lt;typename _Tp&gt;
    struct __is_in_place_type
      : public __is_in_place_type_impl&lt;_Tp&gt;
    { };

#define  __cpp_lib_as_const 201510
  template&lt;typename _Tp&gt;
    constexpr add_const_t&lt;_Tp&gt;&amp; as_const(_Tp&amp; __t) noexcept { return __t; }

  template&lt;typename _Tp&gt;
    void as_const(const _Tp&amp;&amp;) = delete;

#endif // C++17

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace

#endif

#endif /* _GLIBCXX_UTILITY */
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Finclude%2Fc%2B%2B%2F8'>Back to Directory</a>