Imported Upstream version 14.45.0

[platform/upstream/libzypp.git] / zypp / Range.h

diff --git a/zypp/Range.h b/zypp/Range.h
index 3c9269e..41878e3 100644 (file)
--- a/zypp/Range.h
+++ b/zypp/Range.h
@@ -30,59 +30,63 @@ namespace zypp
   /**
    *
   */
-  template<class Tp, class TCompare = Compare<Tp> >
+  template<class _Tp, class _Compare = Compare<_Tp> >
     struct Range
     {
       /** */
       Rel op;
       /** */
-      Tp value;
+      _Tp value;
 
       /** Default ctor: \ref Rel::ANY. */
       Range()
       : op( Rel::ANY )
       {}
 
-      /** Ctor taking \a Tp (\ref Rel::EQ). */
-      Range( const Tp & value_r )
+      /** Ctor taking \a _Tp (\ref Rel::EQ). */
+      Range( const _Tp & value_r )
       : op( Rel::EQ )
       , value( value_r )
       {}
 
-      /** Ctor taking \ref Rel and \a Tp. */
-      Range( Rel op_r, const Tp & value_r )
+      /** Ctor taking \ref Rel and \a _Tp. */
+      Range( Rel op_r, const _Tp & value_r )
       : op( op_r )
       , value( value_r )
       {}
 
       /** Return whether two Ranges overlap. */
       bool overlaps( const Range & rhs ) const
-      { return range_detail::overlaps( op, rhs.op, TCompare()( value, rhs.value ) ); }
+      {
+        return range_detail::overlaps( op, rhs.op,
+                                       _Compare()( value, rhs.value ) );
+      }
     };
   ///////////////////////////////////////////////////////////////////
 
-  template<class Tp, class TCompare>
-    inline bool overlaps( const Range<Tp,TCompare> & lhs,
-                          const Range<Tp,TCompare> & rhs )
+  template<class _Tp, class _Compare>
+    inline bool overlaps( const Range<_Tp,_Compare> & lhs,
+                          const Range<_Tp,_Compare> & rhs )
     { return lhs.overlaps( rhs ); }
 
   ///////////////////////////////////////////////////////////////////
 
-  template<class Tp, class TCompare>
-    inline bool operator==( const Range<Tp,TCompare> & lhs,
-                            const Range<Tp,TCompare> & rhs )
+  template<class _Tp, class _Compare>
+    inline bool operator==( const Range<_Tp,_Compare> & lhs,
+                            const Range<_Tp,_Compare> & rhs )
     {
       return( lhs.op == rhs.op
               && (    lhs.op == Rel::ANY
                    || lhs.op == Rel::NONE
-                   || relCompare( Rel::EQ, lhs.value, rhs.value, TCompare() )
+                   || relCompare( Rel::EQ, lhs.value, rhs.value,
+                                  _Compare() )
                  )
             );
     }
 
-  template<class Tp, class TCompare>
-    inline bool operator!=( const Range<Tp,TCompare> & lhs,
-                            const Range<Tp,TCompare> & rhs )
+  template<class _Tp, class _Compare>
+    inline bool operator!=( const Range<_Tp,_Compare> & lhs,
+                            const Range<_Tp,_Compare> & rhs )
     { return ! ( lhs == rhs ); }
 
   /////////////////////////////////////////////////////////////////