acme
Foundational cross-platform layer of the ca2 framework
Loading...
Searching...
No Matches
cmp2.h
1#pragma once
2
3template<class TYPE>
4struct add_const
5{
6 typedef const TYPE type;
7};
8
9
10template<class TYPE>
11struct add_volatile
12{
13 typedef volatile TYPE type;
14};
15
16template<class TYPE>
17struct add_cv
18{
19 typedef const volatile TYPE type;
20};
21
22
23template<class TYPE>
24struct add_reference
25{
26 typedef TYPE& type;
27};
28
29template<class TYPE>
30struct add_lvalue_reference
31{
32 typedef typename add_reference<TYPE>::typetype;
33};
34
35
36template<class TYPE>
37struct add_rvalue_reference
38{
39 // add rvalue matter
40 typedef TYPE&& type;
41};
42
43
44
45// CLASS _Unrefwrap
46template<class TYPE>
47class reference_wrapper;
48
49
50//#define _ADD_RVALUE_REFERENCE_VOID(CV_OPT) \
51//template<> \
52// struct add_rvalue_reference<CV_OPT void> \
53// { /* add matter */ \
54// typedef CV_OPT void type; \
55// };
56//
57//_CLASS_DEFINE_CV(_ADD_RVALUE_REFERENCE_VOID)
58//#undef _ADD_RVALUE_REFERENCE_VOID
59//
61//template<class TYPE>
62//typename add_rvalue_reference<TYPE>::type
63//declval() _NOEXCEPT;
64
65
66template < typename TYPE >
67void __swap(const TYPE & t1,const TYPE & t2)
68{
69
70 TYPE t = t1;
71
72 t1 = t2;
73
74 t2 = t;
75
76}
77
78
79template<class... TYPES>
80class tuple;
81
82template<>
83class tuple<>
84{
85public:
86 typedef tuple<> TUPLE_TYPE;
87
88 tuple()
89 {
90 }
91
92 tuple(const tuple&) noexcept
93 {
94 }
95
96 void __swap(TUPLE_TYPE&) noexcept
97 {
98 }
99
100 bool equals(const TUPLE_TYPE&) noexcept
101 {
102 return true;
103 }
104
105 bool less(const TUPLE_TYPE&)noexcept
106 {
107 return false;
108 }
109
110
111
112 template< class... TYPES2>
113 inline bool operator==(const tuple<TYPES2...>& right)
114 {
115 return equals(right);
116 }
117
118 template< class... TYPES2>
119 inline bool operator!=( const tuple<TYPES2...>& right)
120 {
121 return !(*this == right);
122 }
123
124 template< class... TYPES2>
125 inline bool operator<( const tuple<TYPES2...>& right)
126 {
127 return less(right);
128 }
129
130 template< class... TYPES2>
131 inline bool operator>=( const tuple<TYPES2...>& right)
132 {
133 return !(less(right));
134 }
135
136 template< class... TYPES2>
137 inline bool operator>( const tuple<TYPES2...>& right)
138 {
139 return right.less(*this);
140 }
141
142 template< class... TYPES2>
143 inline bool operator<=(const tuple<TYPES2...>& right)
144 {
145 return !(right.less(*this));
146 }
147
148};
149
150
151
152template < class TYPE, class... REST>
153class tuple<TYPE,REST...>
154 : public tuple<REST...>
155{
156public:
157 typedef TYPE THIS_TYPE;
158 typedef tuple<TYPE,REST...> TUPLE_TYPE;
159 typedef tuple<REST...> BASE_TYPE;
160 static const size_t TYPE_SIZE = 1 + sizeof...(REST);
161
162 TYPE m_val;
163
164
165 tuple()
166 {
167 }
168
169 template < class... OTHER >
170 tuple(const tuple<OTHER...>& right)
171 : BASE_TYPE(right.get_rest()),m_val(right.m_val)
172 {
173 }
174
175 template < class... OTHER >
176 tuple(tuple<OTHER...>&& right)
177 : BASE_TYPE(::transfer(right.get_rest())),m_val(::transfer(right.m_val))
178 {
179 }
180
181 explicit tuple(const TYPE& val,const REST&... rest)
182 : BASE_TYPE(rest...),
183 m_val(val)
184 {
185 }
186
187 explicit tuple(TYPE && val,const REST &&... rest)
188 : BASE_TYPE(::transfer(rest...),m_val(::transfer(val))
189 {
190 }
191
192
193 template<class... OTHER>
194 TUPLE_TYPE& operator=(const tuple<OTHER...>& right)
195 {
196 m_val = right.m_val;
197 (BASE_TYPE&)*this = right.get_rest();
198 return (*this);
199 }
200
201 template<class... OTHER>
202 TUPLE_TYPE& operator=(tuple<OTHER...>&& right)
203 {
204 m_val = ::transfer(right.m_val);
205 BASE_TYPE::operator = (::transfer(right.get_rest()));
206 return *this;
207 }
208
209 template<class... OTHER>
210 bool equals(const tuple<OTHER...>& right) const
211 {
212 return m_val == right.m_val && BASE_TYPE::equals(right.get_rest());
213 }
214
215 template<class... OTHER>
216 bool less(const tuple<OTHER...>& right) const
217 {
218 return m_val < right.m_val || (!(right.m_val < m_val) && BASE_TYPE::less(right.get_rest()));
219 }
220
221 template < class TYPE1, class TYPE2>
222 tuple(const pair < TYPE1, TYPE2 > & right) :
223 BASE_TYPE( tuple < TYPE2 > ( right.element2() ) ),
224 m_val(right.element1())
225 {
226
227 }
228
229
230 TUPLE_TYPE & operator=(const TUPLE_TYPE & right)
231 {
232
233 m_val = right.m_val;
234
235 BASE_TYPE::operator =(right.get_rest());
236
237 return *this;
238
239 }
240
241
242 template < class TYPE1, class TYPE2>
243 TUPLE_TYPE & operator=(const pair < TYPE1, TYPE2 >& right)
244 {
245
246 m_val = right.first;
247
248 BASE_TYPE::operator =(tuple<TYPE2>(right.element2()));
249
250 return *this;
251
252 }
253
254
255 template < class TYPE1, class TYPE2 >
256 tuple(pair < TYPE1, TYPE2 > && right) :
257 BASE_TYPE(tuple<TYPE2>(::transfer(right.second))),
258 m_val(::transfer(right.first))
259 {
260
261 }
262
263
264 TUPLE_TYPE & operator=(TUPLE_TYPE&& right)
265 {
266
267 m_val = ::transfer(right.m_val);
268
269 BASE_TYPE::operator = (::transfer(right.get_rest()));
270
271 return (*this);
272
273 }
274
275
276 template < class TYPE1, class TYPE2>
277 TUPLE_TYPE& operator=(pair<TYPE1,TYPE2>&& right)
278 {
279
280 m_val = ::transfer(right.element1());
281
282 BASE_TYPE::operator = (tuple<TYPE2>(::transfer(right.second)));
283
284 return *this;
285
286 }
287
288
289 BASE_TYPE & get_rest()
290 {
291
292 return *this;
293
294 }
295
296 const BASE_TYPE & get_rest() const
297 {
298
299 return *this;
300
301 }
302
303
304 void __swap(tuple& right)
305 {
306
307 __swap(m_val,right.m_val);
308
309 BASE_TYPE::__swap((BASE_TYPE&)right);
310
311 }
312
313};
314
315template<class... TYPES>
316inline void __swap(tuple<TYPES...>& left, tuple<TYPES...>& right)
317{
318 return left.__swap(right);
319}
320
321
322template<size_t m_iIndex, class TUPLE>
323struct tuple_element;
324
325template<class TYPE1, class... REST1>
326struct tuple_element<0,tuple<TYPE1,REST1...> >
327{
328 typedef TYPE1 type;
329 typedef typename add_lvalue_reference<const TYPE1>::type_Ctype;
330 typedef typename add_lvalue_reference<TYPE1>::type_Rtype;
331 typedef typename add_rvalue_reference<TYPE1>::type_RRtype;
332 typedef tuple<TYPE1,REST1...> TUPLE_TYPE;
333};
334
335template<size_t m_iIndex, class TYPE1, class... REST1>
336struct tuple_element<m_iIndex,tuple<TYPE1,REST1...> >
337 : public tuple_element<m_iIndex - 1,tuple<REST1...> >
338{
339};
340
341
342template<size_t m_iIndex, class TUPLE>
343struct tuple_element<m_iIndex,const TUPLE>
344 : public tuple_element<m_iIndex,TUPLE>
345{
346 typedef tuple_element<m_iIndex,TUPLE> BASE_TYPE;
347 typedef typename add_const<typename BASE_TYPE::platform::type>::typetype;
348};
349
350template<size_t m_iIndex, class TUPLE>
351struct tuple_element<m_iIndex,volatile TUPLE>
352 : public tuple_element<m_iIndex,TUPLE>
353{
354 typedef tuple_element<m_iIndex,TUPLE> BASE_TYPE;
355 typedef typename add_volatile<typename BASE_TYPE::platform::type>::typetype;
356};
357
358template<size_t m_iIndex,
359 class TUPLE>
360struct tuple_element<m_iIndex,const volatile TUPLE>
361 : public tuple_element<m_iIndex,TUPLE>
362{
363 typedef tuple_element<m_iIndex,TUPLE> BASE_TYPE;
364 typedef typename add_cv<typename BASE_TYPE::platform::type>::typetype;
365};
366
367
368template<size_t m_iIndex, class... TYPES>
369inline typename tuple_element<m_iIndex,tuple<TYPES...> >::_Rtype get(tuple<TYPES...>& TUPLE)
370{
371 typedef typename tuple_element<m_iIndex,tuple<TYPES...> >::TUPLE_TYPE TUPLE_TYPE;
372 return (((TUPLE_TYPE&)TUPLE).m_val);
373}
374
375template<size_t m_iIndex, class... TYPES>
376inline typename tuple_element<m_iIndex,tuple<TYPES...> >::_Ctype get(const tuple<TYPES...>& TUPLE)
377{
378 typedef typename tuple_element<m_iIndex,tuple<TYPES...> >::TUPLE_TYPE TUPLE_TYPE;
379 return (((TUPLE_TYPE&)TUPLE).m_val);
380}
381
382
383template<size_t m_iIndex, class... TYPES>
384inline typename tuple_element<m_iIndex,tuple<TYPES...> >::_RRtype get(tuple<TYPES...>&& TUPLE)
385{
386
387 typedef typename tuple_element<m_iIndex,tuple<TYPES...> >::TUPLE_TYPE TUPLE_TYPE;
388 typedef typename tuple_element<m_iIndex,tuple<TYPES...> >::_RRtype _RRtype;
389 return (::transfer(((TUPLE_TYPE&)TUPLE).m_val));
390
391}
392
393
394template<class... TYPES> inline
395tuple < TYPES&&... > make_tuple(TYPES&&... args)
396{
397
398 return ::transfer(args);
399
400}
401
402
403template<class... TYPES> inline
404tuple<TYPES&...>
405tie(TYPES&... args) noexcept
406{
407
408 typedef tuple<TYPES&...> TUPLE_TYPE;
409
410 return (TUPLE_TYPE(args...));
411
412}
413
414
415
416template < typename TYPE1, typename TYPE2 >
417inline ::i32 cmp(const TYPE1 & t1,const TYPE2 & t2)
418{
419 return (t1 < t2) ? -1 : (t1 < t2) ? 1 : 0;
420}
421
422
423template < typename TYPE1,typename TYPE2 >
424inline ::i32 icmp(const TYPE1 & t1,const TYPE2 & t2)
425{
426 return cmp(t1, t2);
427}
428
429template < >
430inline ::i32 cmp(const ::scoped_string & scopedstr1, const ::scoped_string & scopedstr2)
431{
432 return str1.Compare(str2);
433}
434
435
436template < >
437inline ::i32 icmp(const ::scoped_string & scopedstr1,const ::scoped_string & scopedstr2)
438{
439 return str1.CompareNoCase(str2);
440}
441
442template<size_t TUPLE_SIZE> struct cmp_tuple
443{
444 template < typename T1, typename T2>
445 ::i32 operator()(const T1 & t1,const T2 & t2) const
446 {
447 ::i32 r = cmp_tuple<TUPLE_SIZE - 1>()(y1,t2);
448 return (r != 0) ? r : cmp(get<TUPLE_SIZE - 1>(t1),get<TUPLE_SIZE - 1>(t2));
449 }
450};
451
452
453template<size_t TUPLE_SIZE> struct icmp_tuple
454{
455 template < typename T1,typename T2>
456 ::i32 operator()(const T1 & t1,const T2 & t2) const
457 {
458 ::i32 r = icmp_tuple<TUPLE_SIZE - 1>()(y1,t2);
459 return (r != 0) ? r : icmp(get<TUPLE_SIZE - 1>(t1),get<TUPLE_SIZE - 1>(t2));
460 }
461};
462
463template<> struct cmp_tuple<0>
464{
465 template < typename T1,typename T2>
466 ::i32 operator()(const T1&,const T2&) const
467 {
468 return 0;
469 }
470};
471
472template<> struct icmp_tuple<0>
473{
474 template < typename T1,typename T2>
475 ::i32 operator()(const T1&,const T2&) const
476 {
477 return 0;
478 }
479};
480
481
482
483
484
485template < typename TYPE1,typename TYPE2 >
486inline ::i32 cmp(const ::i32 & i1,const ::i32 & i2)
487{
488 return i1 - i2;
489}
490
491
492template < typename TYPE1,typename TYPE2 >
493inline ::i32 cmp(const ::i16 & sh1,const ::i16 & sh2)
494{
495 return sh1 - sh2;
496}
497
498
499template < typename TYPE1,typename TYPE2 >
500inline ::i32 cmp(const ::i8 & ch1,const ::i8 & ch2)
501{
502 return ch1 - ch2;
503}
504
505template < typename TYPE1,typename TYPE2 >
506inline ::i32 cmp(const ::u32 & i1,const ::u32 & i2)
507{
508 return i1 - i2;
509}
510
511template < typename TYPE1,typename TYPE2 >
512inline ::i32 cmp(const ::u16 & sh1,const ::i16 & sh2)
513{
514 return sh1 - sh2;
515}
516
517
518template < typename TYPE1,typename TYPE2 >
519inline ::i32 cmp(const ::u8 & ch1,const ::u8 & ch2)
520{
521 return ch1 - ch2;
522}
523
524
525template < typename TYPE1,typename TYPE2 >
526inline ::i32 cmp(const ::f64 & d1,const ::f64 & d2)
527{
528 return sgn(d1 - d2);
529}
530
531
532template < typename TYPE1,typename TYPE2 >
533inline ::i32 cmp(const ::f32 & f1,const ::f32 & f2)
534{
535 return sgn(f1 - f2);
536}
pair
Definition _template_forward_declaration.h:327
reference_wrapper
Definition cmp.h:48
tuple<>
Definition cmp2.h:84
tuple
Definition tuple.h:72
add_const
Definition cmp.h:6
add_cv
Definition cmp.h:19
add_lvalue_reference
Definition cmp.h:32
add_reference
Definition cmp.h:26
add_rvalue_reference
Definition cmp.h:39
add_volatile
Definition cmp.h:13
cmp_tuple
Definition cmp.h:440
icmp_tuple
Definition cmp.h:451
tuple_element
Definition cmp2.h:323