1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #ifndef SORTABLE_HELPERS_H
10 #define SORTABLE_HELPERS_H
11 
12 #include <type_traits>
13 
14 #include "test_macros.h"
15 
16 struct TrivialSortable {
17     int value;
TrivialSortableTrivialSortable18     TEST_CONSTEXPR TrivialSortable() : value(0) {}
TrivialSortableTrivialSortable19     TEST_CONSTEXPR TrivialSortable(int v) : value(v) {}
20     friend TEST_CONSTEXPR bool operator<(const TrivialSortable& a, const TrivialSortable& b) {
21         return a.value / 10 < b.value / 10;
22     }
lessTrivialSortable23     static TEST_CONSTEXPR bool less(const TrivialSortable& a, const TrivialSortable& b) {
24         return a.value < b.value;
25     }
26 };
27 
28 struct NonTrivialSortable {
29     int value;
NonTrivialSortableNonTrivialSortable30     TEST_CONSTEXPR NonTrivialSortable() : value(0) {}
NonTrivialSortableNonTrivialSortable31     TEST_CONSTEXPR NonTrivialSortable(int v) : value(v) {}
NonTrivialSortableNonTrivialSortable32     TEST_CONSTEXPR NonTrivialSortable(const NonTrivialSortable& rhs) : value(rhs.value) {}
33     TEST_CONSTEXPR_CXX14 NonTrivialSortable& operator=(const NonTrivialSortable& rhs) { value = rhs.value; return *this; }
34     friend TEST_CONSTEXPR bool operator<(const NonTrivialSortable& a, const NonTrivialSortable& b) {
35         return a.value / 10 < b.value / 10;
36     }
lessNonTrivialSortable37     static TEST_CONSTEXPR bool less(const NonTrivialSortable& a, const NonTrivialSortable& b) {
38         return a.value < b.value;
39     }
40 };
41 
42 
43 struct TrivialSortableWithComp {
44     int value;
TrivialSortableWithCompTrivialSortableWithComp45     TEST_CONSTEXPR TrivialSortableWithComp() : value(0) {}
TrivialSortableWithCompTrivialSortableWithComp46     TEST_CONSTEXPR TrivialSortableWithComp(int v) : value(v) {}
47     struct Comparator {
operatorTrivialSortableWithComp::Comparator48         TEST_CONSTEXPR bool operator()(const TrivialSortableWithComp& a, const TrivialSortableWithComp& b) const {
49             return a.value / 10 < b.value / 10;
50         }
51     };
lessTrivialSortableWithComp52     static TEST_CONSTEXPR bool less(const TrivialSortableWithComp& a, const TrivialSortableWithComp& b) {
53         return a.value < b.value;
54     }
55 };
56 
57 struct NonTrivialSortableWithComp {
58     int value;
NonTrivialSortableWithCompNonTrivialSortableWithComp59     TEST_CONSTEXPR NonTrivialSortableWithComp() : value(0) {}
NonTrivialSortableWithCompNonTrivialSortableWithComp60     TEST_CONSTEXPR NonTrivialSortableWithComp(int v) : value(v) {}
NonTrivialSortableWithCompNonTrivialSortableWithComp61     TEST_CONSTEXPR NonTrivialSortableWithComp(const NonTrivialSortableWithComp& rhs) : value(rhs.value) {}
62     TEST_CONSTEXPR_CXX14 NonTrivialSortableWithComp& operator=(const NonTrivialSortableWithComp& rhs) { value = rhs.value; return *this; }
63     struct Comparator {
operatorNonTrivialSortableWithComp::Comparator64         TEST_CONSTEXPR bool operator()(const NonTrivialSortableWithComp& a, const NonTrivialSortableWithComp& b) const {
65             return a.value / 10 < b.value / 10;
66         }
67     };
lessNonTrivialSortableWithComp68     static TEST_CONSTEXPR bool less(const NonTrivialSortableWithComp& a, const NonTrivialSortableWithComp& b) {
69         return a.value < b.value;
70     }
71 };
72 
73 static_assert(std::is_trivially_copyable<TrivialSortable>::value, "");
74 static_assert(std::is_trivially_copyable<TrivialSortableWithComp>::value, "");
75 static_assert(!std::is_trivially_copyable<NonTrivialSortable>::value, "");
76 static_assert(!std::is_trivially_copyable<NonTrivialSortableWithComp>::value, "");
77 
78 #endif  // SORTABLE_HELPERS_H
79