ndk/sources/cxx-stl/stlport/stlport/stl/_pair.h

   1 /*
   2  *
   3  * Copyright (c) 1994
   4  * Hewlett-Packard Company
   5  *
   6  * Copyright (c) 1996,1997
   7  * Silicon Graphics Computer Systems, Inc.
   8  *
   9  * Copyright (c) 1997
  10  * Moscow Center for SPARC Technology
  11  *
  12  * Copyright (c) 1999
  13  * Boris Fomitchev
  14  *
  15  * This material is provided "as is", with absolutely no warranty expressed
  16  * or implied. Any use is at your own risk.
  17  *
  18  * Permission to use or copy this software for any purpose is hereby granted
  19  * without fee, provided the above notices are retained on all copies.
  20  * Permission to modify the code and to distribute modified code is granted,
  21  * provided the above notices are retained, and a notice that the code was
  22  * modified is included with the above copyright notice.
  23  *
  24  */
  25
  26
  27 /* NOTE: This is an internal header file, included by other STL headers.
  28  *   You should not attempt to use it directly.
  29  */
  30
  31 #ifndef _STLP_INTERNAL_PAIR_H
  32 #define _STLP_INTERNAL_PAIR_H
  33
  34 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
  35 #  ifndef _STLP_TYPE_TRAITS_H
  36 #    include <stl/type_traits.h>
  37 #  endif
  38
  39 #  if !defined (_STLP_MOVE_CONSTRUCT_FWK_H) && !defined (_STLP_NO_MOVE_SEMANTIC)
  40 #    include <stl/_move_construct_fwk.h>
  41 #  endif
  42 #endif
  43
  44 _STLP_BEGIN_NAMESPACE
  45
  46 #if defined (ANDROID)
  47 /* Android has stl_pair.h, prevent using it by defining the header guard. */
  48 #  define __SGI_STL_INTERNAL_PAIR_H
  49 #endif
  50 template <class _T1, class _T2>
  51 struct pair {
  52   typedef _T1 first_type;
  53   typedef _T2 second_type;
  54
  55   _T1 first;
  56   _T2 second;
  57 #if defined (_STLP_CONST_CONSTRUCTOR_BUG)
  58   pair() {}
  59 #else
  60   pair() : first(_T1()), second(_T2()) {}
  61 #endif
  62   pair(const _T1& __a, const _T2& __b) : first(__a), second(__b) {}
  63
  64 #if defined (_STLP_MEMBER_TEMPLATES)
  65   template <class _U1, class _U2>
  66   pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {}
  67
  68   pair(const pair<_T1,_T2>& __o) : first(__o.first), second(__o.second) {}
  69 #endif
  70
  71 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC)
  72   pair(__move_source<pair<_T1, _T2> > src) : first(_STLP_PRIV _AsMoveSource(src.get().first)),
  73                                              second(_STLP_PRIV _AsMoveSource(src.get().second))
  74   {}
  75 #endif
  76
  77   __TRIVIAL_DESTRUCTOR(pair)
  78 };
  79
  80 template <class _T1, class _T2>
  81 inline bool _STLP_CALL operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
  82 { return __x.first == __y.first && __x.second == __y.second; }
  83
  84 template <class _T1, class _T2>
  85 inline bool _STLP_CALL operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) {
  86   return __x.first < __y.first ||
  87          (!(__y.first < __x.first) && __x.second < __y.second);
  88 }
  89
  90 #if defined (_STLP_USE_SEPARATE_RELOPS_NAMESPACE)
  91 template <class _T1, class _T2>
  92 inline bool _STLP_CALL operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
  93 { return !(__x == __y); }
  94
  95 template <class _T1, class _T2>
  96 inline bool _STLP_CALL operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
  97 { return __y < __x; }
  98
  99 template <class _T1, class _T2>
 100 inline bool _STLP_CALL operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
 101 { return !(__y < __x); }
 102
 103 template <class _T1, class _T2>
 104 inline bool _STLP_CALL operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
 105 { return !(__x < __y); }
 106 #endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
 107
 108 #if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) && !defined (_STLP_NO_EXTENSIONS)
 109 template <class _T1, class _T2, int _Sz>
 110 inline pair<_T1, _T2 const*> make_pair(_T1 const& __x,
 111                                        _T2 const (&__y)[_Sz])
 112 { return pair<_T1, _T2 const*>(__x, static_cast<_T2 const*>(__y)); }
 113
 114 template <class _T1, class _T2, int _Sz>
 115 inline pair<_T1 const*, _T2> make_pair(_T1 const (&__x)[_Sz],
 116                                        _T2 const& __y)
 117 { return pair<_T1 const*, _T2>(static_cast<_T1 const*>(__x), __y); }
 118
 119 template <class _T1, class _T2, int _Sz1, int _Sz2>
 120 inline pair<_T1 const*, _T2 const*> make_pair(_T1 const (&__x)[_Sz1],
 121                                               _T2 const (&__y)[_Sz2]) {
 122   return pair<_T1 const*, _T2 const*>(static_cast<_T1 const*>(__x),
 123                                       static_cast<_T2 const*>(__y));
 124 }
 125 #endif
 126
 127 template <class _T1, class _T2>
 128 inline pair<_T1, _T2> _STLP_CALL make_pair(_T1 __x, _T2 __y)
 129 { return pair<_T1, _T2>(__x, __y); }
 130
 131 _STLP_END_NAMESPACE
 132
 133 #if defined (_STLP_USE_NAMESPACES) || !defined (_STLP_USE_SEPARATE_RELOPS_NAMESPACE)
 134 _STLP_BEGIN_RELOPS_NAMESPACE
 135
 136 template <class _Tp>
 137 inline bool _STLP_CALL operator!=(const _Tp& __x, const _Tp& __y)
 138 { return !(__x == __y); }
 139
 140 template <class _Tp>
 141 inline bool _STLP_CALL operator>(const _Tp& __x, const _Tp& __y)
 142 { return __y < __x; }
 143
 144 template <class _Tp>
 145 inline bool _STLP_CALL operator<=(const _Tp& __x, const _Tp& __y)
 146 { return !(__y < __x); }
 147
 148 template <class _Tp>
 149 inline bool _STLP_CALL  operator>=(const _Tp& __x, const _Tp& __y)
 150 { return !(__x < __y); }
 151
 152 _STLP_END_RELOPS_NAMESPACE
 153 #endif
 154
 155 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
 156 _STLP_BEGIN_NAMESPACE
 157
 158 template <class _T1, class _T2>
 159 struct __type_traits<pair<_T1, _T2> > {
 160   typedef __type_traits<_T1> _T1Traits;
 161   typedef __type_traits<_T2> _T2Traits;
 162   typedef typename _Land2<typename _T1Traits::has_trivial_default_constructor,
 163                           typename _T2Traits::has_trivial_default_constructor>::_Ret has_trivial_default_constructor;
 164   typedef typename _Land2<typename _T1Traits::has_trivial_copy_constructor,
 165                           typename _T2Traits::has_trivial_copy_constructor>::_Ret has_trivial_copy_constructor;
 166   typedef typename _Land2<typename _T1Traits::has_trivial_assignment_operator,
 167                           typename _T2Traits::has_trivial_assignment_operator>::_Ret has_trivial_assignment_operator;
 168   typedef typename _Land2<typename _T1Traits::has_trivial_destructor,
 169                           typename _T2Traits::has_trivial_destructor>::_Ret has_trivial_destructor;
 170   typedef __false_type is_POD_type;
 171 };
 172
 173 #  if !defined (_STLP_NO_MOVE_SEMANTIC)
 174 template <class _T1, class _T2>
 175 struct __move_traits<pair<_T1, _T2> >
 176   : _STLP_PRIV __move_traits_help1<_T1, _T2> {};
 177 #  endif
 178
 179 _STLP_END_NAMESPACE
 180 #endif
 181
 182 #endif /* _STLP_INTERNAL_PAIR_H */
 183
 184 // Local Variables:
 185 // mode:C++
 186 // End: