Re: [PATCH] Fix libstdc++/6503

[Paolo Carlini <pcarlini at unitus dot it>]

Paolo Carlini wrote:

> 2002-05-18  Paolo Carlini  <pcarlini@unitus.it>
>
>        PR libstdc++/6503
>        * include/bits/stl_deque.h (_Deque_iterator::operator==,
>        operator!=, operator<, operator>, operator>=, operator<=):
>        Make non-member functions, to allow comparing const and
>        non-const iterators in any order.
>        * testsuite/23_containers/deque_operators.cc: New testfile. 

Sorry, I sent a slightly outdated version of the patch.

The following is what I have finally tested, the new non-member 
functions strictly matching the existing structure of the operators.

Ciao, Paolo.

///////////////

diff -urN libstdc++-v3-orig/include/bits/stl_deque.h 
libstdc++-v3/include/bits/stl_deque.h
--- libstdc++-v3-orig/include/bits/stl_deque.h    2002-04-18 
04:55:50.000000000 +0200
+++ libstdc++-v3/include/bits/stl_deque.h    2002-05-18 
14:19:38.000000000 +0200
@@ -194,16 +194,6 @@
 
   reference operator[](difference_type __n) const { return *(*this + 
__n); }
 
-  bool operator==(const _Self& __x) const { return _M_cur == __x._M_cur; }
-  bool operator!=(const _Self& __x) const { return !(*this == __x); }
-  bool operator<(const _Self& __x) const {
-    return (_M_node == __x._M_node) ?
-      (_M_cur < __x._M_cur) : (_M_node < __x._M_node);
-  }
-  bool operator>(const _Self& __x) const  { return __x < *this; }
-  bool operator<=(const _Self& __x) const { return !(__x < *this); }
-  bool operator>=(const _Self& __x) const { return !(*this < __x); }
-
   /** @if maint
    *  Prepares to traverse new_node.  Sets everything except _M_cur, which
    *  should therefore be set by the caller immediately afterwards, 
based on
@@ -217,6 +207,107 @@
   }
 };
 
+// Note: we also provide overloads whose operands are of the same type in
+// order to avoid ambiguos overload resolution when std::rel_ops operators
+// are in scope (for additional details, see libstdc++/3628)
+template <class _Tp, class _Ref, class _Ptr>
+inline bool
+operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+{
+  return __x._M_cur == __y._M_cur;
+}
+
+template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
+inline bool
+operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+{
+  return __x._M_cur == __y._M_cur;
+}
+
+template <class _Tp, class _Ref, class _Ptr>
+inline bool
+operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+{
+  return !(__x == __y);
+}
+
+template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
+inline bool
+operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+{
+  return !(__x == __y);
+}
+
+template <class _Tp, class _Ref, class _Ptr>
+inline bool
+operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+{
+  return (__x._M_node == __y._M_node) ?
+    (__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node);
+}
+
+template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
+inline bool
+operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+{
+  return (__x._M_node == __y._M_node) ?
+    (__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node);
+}
+
+template <class _Tp, class _Ref, class _Ptr>
+inline bool
+operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+{
+  return __y < __x;
+}
+
+template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
+inline bool
+operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+{
+  return __y < __x;
+}
+
+template <class _Tp, class _Ref, class _Ptr>
+inline bool
+operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+{
+  return !(__y < __x);
+}
+
+template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
+inline bool
+operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+{
+  return !(__y < __x);
+}
+
+template <class _Tp, class _Ref, class _Ptr>
+inline bool
+operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+{
+  return !(__x < __y);
+}
+
+template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
+inline bool
+operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+{
+  return !(__x < __y);
+}
+
 template <class _Tp, class _Ref, class _Ptr>
 inline _Deque_iterator<_Tp, _Ref, _Ptr>
 operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x)
diff -urN libstdc++-v3-orig/testsuite/23_containers/deque_operators.cc 
libstdc++-v3/testsuite/23_containers/deque_operators.cc
--- libstdc++-v3-orig/testsuite/23_containers/deque_operators.cc    
1970-01-01 01:00:00.000000000 +0100
+++ libstdc++-v3/testsuite/23_containers/deque_operators.cc    
2002-05-18 13:42:20.000000000 +0200
@@ -0,0 +1,63 @@
+// 2002-05-18  Paolo Carlini  <pcarlini@unitus.it>
+
+// Copyright (C) 2002 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 2, 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// 23.2.1 deque operators
+
+#include <deque>
+#include <testsuite_hooks.h>
+
+// libstdc++/6503
+void test01()
+{
+  bool test = true;
+
+  std::deque<int> d(2);      
+  typedef std::deque<int>::iterator iter;        
+  typedef std::deque<int>::const_iterator constiter;
+
+  iter beg = d.begin();              
+  iter end = d.end();
+  constiter constbeg = d.begin();              
+  constiter constend = d.end();
+      
+  VERIFY( beg == constbeg );
+  VERIFY( constend == end );
+
+  VERIFY( beg != constend );
+  VERIFY( constend != beg );
+
+  VERIFY( beg < constend );
+  VERIFY( constbeg < end );
+
+  VERIFY( end > constbeg );
+  VERIFY( constend > beg );
+
+  VERIFY( end >= constend );
+  VERIFY( constbeg >= beg );
+
+  VERIFY( beg <= constbeg );
+  VERIFY( constend <= end );
+}
+
+int main()
+{
+  test01();
+  return 0;
+}