libstdc++-v3/include/bits/predefined_ops.h

   1 // Default predicates for internal use -*- C++ -*-
   2
   3 // Copyright (C) 2013 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.
  28  */
  29
  30 #ifndef _GLIBCXX_PREDEFINED_OPS_H
  31 #define _GLIBCXX_PREDEFINED_OPS_H       1
  32
  33 namespace __gnu_cxx
  34 {
  35 namespace __ops
  36 {
  37   struct _Iter_less_iter
  38   {
  39     template<typename _Iterator1, typename _Iterator2>
  40       bool
  41       operator()(_Iterator1 __it1, _Iterator2 __it2) const
  42       { return *__it1 < *__it2; }
  43   };
  44
  45   inline _Iter_less_iter
  46   __iter_less_iter()
  47   { return _Iter_less_iter(); }
  48
  49   struct _Iter_less_val
  50   {
  51     template<typename _Iterator, typename _Value>
  52       bool
  53       operator()(_Iterator __it, _Value& __val) const
  54       { return *__it < __val; }
  55     };
  56
  57   inline _Iter_less_val
  58   __iter_less_val()
  59   { return _Iter_less_val(); }
  60
  61   inline _Iter_less_val
  62   __iter_comp_val(_Iter_less_iter)
  63   { return _Iter_less_val(); }
  64
  65   struct _Val_less_iter
  66   {
  67     template<typename _Value, typename _Iterator>
  68       bool
  69       operator()(_Value& __val, _Iterator __it) const
  70       { return __val < *__it; }
  71     };
  72
  73   inline _Val_less_iter
  74   __val_less_iter()
  75   { return _Val_less_iter(); }
  76
  77   inline _Val_less_iter
  78   __val_comp_iter(_Iter_less_iter)
  79   { return _Val_less_iter(); }
  80
  81   struct _Iter_equal_to_iter
  82   {
  83     template<typename _Iterator1, typename _Iterator2>
  84       bool
  85       operator()(_Iterator1 __it1, _Iterator2 __it2) const
  86       { return *__it1 == *__it2; }
  87     };
  88
  89   inline _Iter_equal_to_iter
  90   __iter_equal_to_iter()
  91   { return _Iter_equal_to_iter(); }
  92
  93   struct _Iter_equal_to_val
  94   {
  95     template<typename _Iterator, typename _Value>
  96       bool
  97       operator()(_Iterator __it, _Value& __val) const
  98       { return *__it == __val; }
  99     };
 100
 101   inline _Iter_equal_to_val
 102   __iter_equal_to_val()
 103   { return _Iter_equal_to_val(); }
 104
 105   inline _Iter_equal_to_val
 106   __iter_comp_val(_Iter_equal_to_iter)
 107   { return _Iter_equal_to_val(); }
 108
 109   template<typename _Compare>
 110     struct _Iter_comp_iter
 111     {
 112       _Compare _M_comp;
 113
 114       _Iter_comp_iter(_Compare __comp)
 115         : _M_comp(__comp)
 116       { }
 117
 118       template<typename _Iterator1, typename _Iterator2>
 119         bool
 120         operator()(_Iterator1 __it1, _Iterator2 __it2)
 121         { return bool(_M_comp(*__it1, *__it2)); }
 122     };
 123
 124   template<typename _Compare>
 125     inline _Iter_comp_iter<_Compare>
 126     __iter_comp_iter(_Compare __comp)
 127     { return _Iter_comp_iter<_Compare>(__comp); }
 128
 129   template<typename _Compare>
 130     struct _Iter_comp_val
 131     {
 132       _Compare _M_comp;
 133
 134       _Iter_comp_val(_Compare __comp)
 135         : _M_comp(__comp)
 136       { }
 137
 138       template<typename _Iterator, typename _Value>
 139         bool
 140         operator()(_Iterator __it, _Value& __val)
 141         { return bool(_M_comp(*__it, __val)); }
 142     };
 143
 144   template<typename _Compare>
 145    inline _Iter_comp_val<_Compare>
 146     __iter_comp_val(_Compare __comp)
 147     { return _Iter_comp_val<_Compare>(__comp); }
 148
 149   template<typename _Compare>
 150     inline _Iter_comp_val<_Compare>
 151     __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
 152     { return _Iter_comp_val<_Compare>(__comp._M_comp); }
 153
 154   template<typename _Compare>
 155     struct _Val_comp_iter
 156     {
 157       _Compare _M_comp;
 158
 159       _Val_comp_iter(_Compare __comp)
 160         : _M_comp(__comp)
 161       { }
 162
 163       template<typename _Value, typename _Iterator>
 164         bool
 165         operator()(_Value& __val, _Iterator __it)
 166         { return bool(_M_comp(__val, *__it)); }
 167     };
 168
 169   template<typename _Compare>
 170     inline _Val_comp_iter<_Compare>
 171     __val_comp_iter(_Compare __comp)
 172     { return _Val_comp_iter<_Compare>(__comp); }
 173
 174   template<typename _Compare>
 175     inline _Val_comp_iter<_Compare>
 176     __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
 177     { return _Val_comp_iter<_Compare>(__comp._M_comp); }
 178
 179   template<typename _Value>
 180     struct _Iter_equals_val
 181     {
 182       _Value& _M_value;
 183
 184       _Iter_equals_val(_Value& __value)
 185         : _M_value(__value)
 186       { }
 187
 188       template<typename _Iterator>
 189         bool
 190         operator()(_Iterator __it)
 191         { return *__it == _M_value; }
 192     };
 193
 194   template<typename _Value>
 195     inline _Iter_equals_val<_Value>
 196     __iter_equals_val(_Value& __val)
 197     { return _Iter_equals_val<_Value>(__val); }
 198
 199   template<typename _Iterator1>
 200     struct _Iter_equals_iter
 201     {
 202       typename std::iterator_traits<_Iterator1>::reference _M_ref;
 203
 204       _Iter_equals_iter(_Iterator1 __it1)
 205         : _M_ref(*__it1)
 206       { }
 207
 208       template<typename _Iterator2>
 209         bool
 210         operator()(_Iterator2 __it2)
 211         { return *__it2 == _M_ref; }
 212     };
 213
 214   template<typename _Iterator>
 215     inline _Iter_equals_iter<_Iterator>
 216     __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
 217     { return _Iter_equals_iter<_Iterator>(__it); }
 218
 219   template<typename _Predicate>
 220     struct _Iter_pred
 221     {
 222       _Predicate _M_pred;
 223
 224       _Iter_pred(_Predicate __pred)
 225         : _M_pred(__pred)
 226       { }
 227
 228       template<typename _Iterator>
 229         bool
 230         operator()(_Iterator __it)
 231         { return bool(_M_pred(*__it)); }
 232     };
 233
 234   template<typename _Predicate>
 235     inline _Iter_pred<_Predicate>
 236     __pred_iter(_Predicate __pred)
 237     { return _Iter_pred<_Predicate>(__pred); }
 238
 239   template<typename _Compare, typename _Value>
 240     struct _Iter_comp_to_val
 241     {
 242       _Compare _M_comp;
 243       _Value& _M_value;
 244
 245       _Iter_comp_to_val(_Compare __comp, _Value& __value)
 246         : _M_comp(__comp), _M_value(__value)
 247       { }
 248
 249       template<typename _Iterator>
 250         bool
 251         operator()(_Iterator __it)
 252         { return bool(_M_comp(*__it, _M_value)); }
 253     };
 254
 255   template<typename _Compare, typename _Value>
 256     _Iter_comp_to_val<_Compare, _Value>
 257     __iter_comp_val(_Compare __comp, _Value &__val)
 258     { return _Iter_comp_to_val<_Compare, _Value>(__comp, __val); }
 259
 260   template<typename _Compare, typename _Iterator1>
 261     struct _Iter_comp_to_iter
 262     {
 263       _Compare _M_comp;
 264       typename std::iterator_traits<_Iterator1>::reference _M_ref;
 265
 266       _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
 267         : _M_comp(__comp), _M_ref(*__it1)
 268       { }
 269
 270       template<typename _Iterator2>
 271         bool
 272         operator()(_Iterator2 __it2)
 273         { return bool(_M_comp(*__it2, _M_ref)); }
 274     };
 275
 276   template<typename _Compare, typename _Iterator>
 277     inline _Iter_comp_to_iter<_Compare, _Iterator>
 278     __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
 279     { return _Iter_comp_to_iter<_Compare, _Iterator>(__comp._M_comp, __it); }
 280
 281   template<typename _Predicate>
 282     struct _Iter_negate
 283     {
 284       _Predicate _M_pred;
 285
 286       _Iter_negate(_Predicate __pred)
 287         : _M_pred(__pred)
 288       { }
 289
 290       template<typename _Iterator>
 291         bool
 292         operator()(_Iterator __it)
 293         { return !bool(_M_pred(*__it)); }
 294     };
 295
 296   template<typename _Predicate>
 297     inline _Iter_negate<_Predicate>
 298     __negate(_Iter_pred<_Predicate> __pred)
 299     { return _Iter_negate<_Predicate>(__pred._M_pred); }
 300
 301 } // namespace __ops
 302 } // namespace __gnu_cxx
 303
 304 #endif