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