The C and C++ Include Header Files

/usr/include/c++/11/bits/predefined_ops.h


$ cat -n /usr/include/c++/11/bits/predefined_ops.h

     1	// Default predicates for internal use -*- C++ -*-
     2	
     3	// Copyright (C) 2013-2021 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	/** @file predefined_ops.h
    26	 *  This is an internal header file, included by other library headers.
    27	 *  You should not attempt to use it directly. @headername{algorithm}
    28	 */
    29	
    30	#ifndef _GLIBCXX_PREDEFINED_OPS_H
    31	#define _GLIBCXX_PREDEFINED_OPS_H	1
    32	
    33	#include <bits/move.h>
    34	
    35	namespace __gnu_cxx
    36	{
    37	namespace __ops
    38	{
    39	  struct _Iter_less_iter
    40	  {
    41	    template<typename _Iterator1, typename _Iterator2>
    42	      _GLIBCXX14_CONSTEXPR
    43	      bool
    44	      operator()(_Iterator1 __it1, _Iterator2 __it2) const
    45	      { return *__it1 < *__it2; }
    46	  };
    47	
    48	  _GLIBCXX14_CONSTEXPR
    49	  inline _Iter_less_iter
    50	  __iter_less_iter()
    51	  { return _Iter_less_iter(); }
    52	
    53	  struct _Iter_less_val
    54	  {
    55	#if __cplusplus >= 201103L
    56	    constexpr _Iter_less_val() = default;
    57	#else
    58	    _Iter_less_val() { }
    59	#endif
    60	
    61	    _GLIBCXX20_CONSTEXPR
    62	    explicit
    63	    _Iter_less_val(_Iter_less_iter) { }
    64	
    65	    template<typename _Iterator, typename _Value>
    66	      _GLIBCXX20_CONSTEXPR
    67	      bool
    68	      operator()(_Iterator __it, _Value& __val) const
    69	      { return *__it < __val; }
    70	  };
    71	
    72	  _GLIBCXX20_CONSTEXPR
    73	  inline _Iter_less_val
    74	  __iter_less_val()
    75	  { return _Iter_less_val(); }
    76	
    77	  _GLIBCXX20_CONSTEXPR
    78	  inline _Iter_less_val
    79	  __iter_comp_val(_Iter_less_iter)
    80	  { return _Iter_less_val(); }
    81	
    82	  struct _Val_less_iter
    83	  {
    84	#if __cplusplus >= 201103L
    85	    constexpr _Val_less_iter() = default;
    86	#else
    87	    _Val_less_iter() { }
    88	#endif
    89	
    90	    _GLIBCXX20_CONSTEXPR
    91	    explicit
    92	    _Val_less_iter(_Iter_less_iter) { }
    93	
    94	    template<typename _Value, typename _Iterator>
    95	      _GLIBCXX20_CONSTEXPR
    96	      bool
    97	      operator()(_Value& __val, _Iterator __it) const
    98	      { return __val < *__it; }
    99	  };
   100	
   101	  _GLIBCXX20_CONSTEXPR
   102	  inline _Val_less_iter
   103	  __val_less_iter()
   104	  { return _Val_less_iter(); }
   105	
   106	  _GLIBCXX20_CONSTEXPR
   107	  inline _Val_less_iter
   108	  __val_comp_iter(_Iter_less_iter)
   109	  { return _Val_less_iter(); }
   110	
   111	  struct _Iter_equal_to_iter
   112	  {
   113	    template<typename _Iterator1, typename _Iterator2>
   114	      _GLIBCXX20_CONSTEXPR
   115	      bool
   116	      operator()(_Iterator1 __it1, _Iterator2 __it2) const
   117	      { return *__it1 == *__it2; }
   118	  };
   119	
   120	  _GLIBCXX20_CONSTEXPR
   121	  inline _Iter_equal_to_iter
   122	  __iter_equal_to_iter()
   123	  { return _Iter_equal_to_iter(); }
   124	
   125	  struct _Iter_equal_to_val
   126	  {
   127	    template<typename _Iterator, typename _Value>
   128	      _GLIBCXX20_CONSTEXPR
   129	      bool
   130	      operator()(_Iterator __it, _Value& __val) const
   131	      { return *__it == __val; }
   132	  };
   133	
   134	  _GLIBCXX20_CONSTEXPR
   135	  inline _Iter_equal_to_val
   136	  __iter_equal_to_val()
   137	  { return _Iter_equal_to_val(); }
   138	
   139	  _GLIBCXX20_CONSTEXPR
   140	  inline _Iter_equal_to_val
   141	  __iter_comp_val(_Iter_equal_to_iter)
   142	  { return _Iter_equal_to_val(); }
   143	
   144	  template<typename _Compare>
   145	    struct _Iter_comp_iter
   146	    {
   147	      _Compare _M_comp;
   148	
   149	      explicit _GLIBCXX14_CONSTEXPR
   150	      _Iter_comp_iter(_Compare __comp)
   151		: _M_comp(_GLIBCXX_MOVE(__comp))
   152	      { }
   153	
   154	      template<typename _Iterator1, typename _Iterator2>
   155	        _GLIBCXX14_CONSTEXPR
   156	        bool
   157	        operator()(_Iterator1 __it1, _Iterator2 __it2)
   158	        { return bool(_M_comp(*__it1, *__it2)); }
   159	    };
   160	
   161	  template<typename _Compare>
   162	    _GLIBCXX14_CONSTEXPR
   163	    inline _Iter_comp_iter<_Compare>
   164	    __iter_comp_iter(_Compare __comp)
   165	    { return _Iter_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); }
   166	
   167	  template<typename _Compare>
   168	    struct _Iter_comp_val
   169	    {
   170	      _Compare _M_comp;
   171	
   172	      _GLIBCXX20_CONSTEXPR
   173	      explicit
   174	      _Iter_comp_val(_Compare __comp)
   175		: _M_comp(_GLIBCXX_MOVE(__comp))
   176	      { }
   177	
   178	      _GLIBCXX20_CONSTEXPR
   179	      explicit
   180	      _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp)
   181		: _M_comp(__comp._M_comp)
   182	      { }
   183	
   184	#if __cplusplus >= 201103L
   185	      _GLIBCXX20_CONSTEXPR
   186	      explicit
   187	      _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)
   188		: _M_comp(std::move(__comp._M_comp))
   189	      { }
   190	#endif
   191	
   192	      template<typename _Iterator, typename _Value>
   193		_GLIBCXX20_CONSTEXPR
   194		bool
   195		operator()(_Iterator __it, _Value& __val)
   196		{ return bool(_M_comp(*__it, __val)); }
   197	    };
   198	
   199	  template<typename _Compare>
   200	    _GLIBCXX20_CONSTEXPR
   201	    inline _Iter_comp_val<_Compare>
   202	    __iter_comp_val(_Compare __comp)
   203	    { return _Iter_comp_val<_Compare>(_GLIBCXX_MOVE(__comp)); }
   204	
   205	  template<typename _Compare>
   206	    _GLIBCXX20_CONSTEXPR
   207	    inline _Iter_comp_val<_Compare>
   208	    __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
   209	    { return _Iter_comp_val<_Compare>(_GLIBCXX_MOVE(__comp)); }
   210	
   211	  template<typename _Compare>
   212	    struct _Val_comp_iter
   213	    {
   214	      _Compare _M_comp;
   215	
   216	      _GLIBCXX20_CONSTEXPR
   217	      explicit
   218	      _Val_comp_iter(_Compare __comp)
   219		: _M_comp(_GLIBCXX_MOVE(__comp))
   220	      { }
   221	
   222	      _GLIBCXX20_CONSTEXPR
   223	      explicit
   224	      _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp)
   225		: _M_comp(__comp._M_comp)
   226	      { }
   227	
   228	#if __cplusplus >= 201103L
   229	      _GLIBCXX20_CONSTEXPR
   230	      explicit
   231	      _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)
   232		: _M_comp(std::move(__comp._M_comp))
   233	      { }
   234	#endif
   235	
   236	      template<typename _Value, typename _Iterator>
   237		_GLIBCXX20_CONSTEXPR
   238		bool
   239		operator()(_Value& __val, _Iterator __it)
   240		{ return bool(_M_comp(__val, *__it)); }
   241	    };
   242	
   243	  template<typename _Compare>
   244	    _GLIBCXX20_CONSTEXPR
   245	    inline _Val_comp_iter<_Compare>
   246	    __val_comp_iter(_Compare __comp)
   247	    { return _Val_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); }
   248	
   249	  template<typename _Compare>
   250	    _GLIBCXX20_CONSTEXPR
   251	    inline _Val_comp_iter<_Compare>
   252	    __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
   253	    { return _Val_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); }
   254	
   255	  template<typename _Value>
   256	    struct _Iter_equals_val
   257	    {
   258	      _Value& _M_value;
   259	
   260	      _GLIBCXX20_CONSTEXPR
   261	      explicit
   262	      _Iter_equals_val(_Value& __value)
   263		: _M_value(__value)
   264	      { }
   265	
   266	      template<typename _Iterator>
   267		_GLIBCXX20_CONSTEXPR
   268		bool
   269		operator()(_Iterator __it)
   270		{ return *__it == _M_value; }
   271	    };
   272	
   273	  template<typename _Value>
   274	    _GLIBCXX20_CONSTEXPR
   275	    inline _Iter_equals_val<_Value>
   276	    __iter_equals_val(_Value& __val)
   277	    { return _Iter_equals_val<_Value>(__val); }
   278	
   279	  template<typename _Iterator1>
   280	    struct _Iter_equals_iter
   281	    {
   282	      _Iterator1 _M_it1;
   283	
   284	      _GLIBCXX20_CONSTEXPR
   285	      explicit
   286	      _Iter_equals_iter(_Iterator1 __it1)
   287		: _M_it1(__it1)
   288	      { }
   289	
   290	      template<typename _Iterator2>
   291		_GLIBCXX20_CONSTEXPR
   292		bool
   293		operator()(_Iterator2 __it2)
   294		{ return *__it2 == *_M_it1; }
   295	    };
   296	
   297	  template<typename _Iterator>
   298	    _GLIBCXX20_CONSTEXPR
   299	    inline _Iter_equals_iter<_Iterator>
   300	    __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
   301	    { return _Iter_equals_iter<_Iterator>(__it); }
   302	
   303	  template<typename _Predicate>
   304	    struct _Iter_pred
   305	    {
   306	      _Predicate _M_pred;
   307	
   308	      _GLIBCXX20_CONSTEXPR
   309	      explicit
   310	      _Iter_pred(_Predicate __pred)
   311		: _M_pred(_GLIBCXX_MOVE(__pred))
   312	      { }
   313	
   314	      template<typename _Iterator>
   315		_GLIBCXX20_CONSTEXPR
   316		bool
   317		operator()(_Iterator __it)
   318		{ return bool(_M_pred(*__it)); }
   319	    };
   320	
   321	  template<typename _Predicate>
   322	    _GLIBCXX20_CONSTEXPR
   323	    inline _Iter_pred<_Predicate>
   324	    __pred_iter(_Predicate __pred)
   325	    { return _Iter_pred<_Predicate>(_GLIBCXX_MOVE(__pred)); }
   326	
   327	  template<typename _Compare, typename _Value>
   328	    struct _Iter_comp_to_val
   329	    {
   330	      _Compare _M_comp;
   331	      _Value& _M_value;
   332	
   333	      _GLIBCXX20_CONSTEXPR
   334	      _Iter_comp_to_val(_Compare __comp, _Value& __value)
   335		: _M_comp(_GLIBCXX_MOVE(__comp)), _M_value(__value)
   336	      { }
   337	
   338	      template<typename _Iterator>
   339		_GLIBCXX20_CONSTEXPR
   340		bool
   341		operator()(_Iterator __it)
   342		{ return bool(_M_comp(*__it, _M_value)); }
   343	    };
   344	
   345	  template<typename _Compare, typename _Value>
   346	    _Iter_comp_to_val<_Compare, _Value>
   347	    _GLIBCXX20_CONSTEXPR
   348	    __iter_comp_val(_Compare __comp, _Value &__val)
   349	    {
   350	      return _Iter_comp_to_val<_Compare, _Value>(_GLIBCXX_MOVE(__comp), __val);
   351	    }
   352	
   353	  template<typename _Compare, typename _Iterator1>
   354	    struct _Iter_comp_to_iter
   355	    {
   356	      _Compare _M_comp;
   357	      _Iterator1 _M_it1;
   358	
   359	      _GLIBCXX20_CONSTEXPR
   360	      _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
   361		: _M_comp(_GLIBCXX_MOVE(__comp)), _M_it1(__it1)
   362	      { }
   363	
   364	      template<typename _Iterator2>
   365		_GLIBCXX20_CONSTEXPR
   366		bool
   367		operator()(_Iterator2 __it2)
   368		{ return bool(_M_comp(*__it2, *_M_it1)); }
   369	    };
   370	
   371	  template<typename _Compare, typename _Iterator>
   372	    _GLIBCXX20_CONSTEXPR
   373	    inline _Iter_comp_to_iter<_Compare, _Iterator>
   374	    __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
   375	    {
   376	      return _Iter_comp_to_iter<_Compare, _Iterator>(
   377		  _GLIBCXX_MOVE(__comp._M_comp), __it);
   378	    }
   379	
   380	  template<typename _Predicate>
   381	    struct _Iter_negate
   382	    {
   383	      _Predicate _M_pred;
   384	
   385	      _GLIBCXX20_CONSTEXPR
   386	      explicit
   387	      _Iter_negate(_Predicate __pred)
   388		: _M_pred(_GLIBCXX_MOVE(__pred))
   389	      { }
   390	
   391	      template<typename _Iterator>
   392		_GLIBCXX20_CONSTEXPR
   393		bool
   394		operator()(_Iterator __it)
   395		{ return !bool(_M_pred(*__it)); }
   396	    };
   397	
   398	  template<typename _Predicate>
   399	    _GLIBCXX20_CONSTEXPR
   400	    inline _Iter_negate<_Predicate>
   401	    __negate(_Iter_pred<_Predicate> __pred)
   402	    { return _Iter_negate<_Predicate>(_GLIBCXX_MOVE(__pred._M_pred)); }
   403	
   404	} // namespace __ops
   405	} // namespace __gnu_cxx
   406	
   407	#endif