File indexing completed on 2024-12-22 05:13:36

 /*
     SPDX-FileCopyrightText: 2015 Ivan Cukic <ivan.cukic(at)kde.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #ifndef UTILS_MEMBER_MATCHER_H
 #define UTILS_MEMBER_MATCHER_H
 
 namespace kamd
 {
 namespace utils
 {
 namespace member_matcher
 {
 struct placeholder {
 } _;
 
 namespace detail
 { //_
 enum ComparisonOperation {
     Less,
     LessOrEqual,
     Equal,
     GreaterOrEqual,
     Greater,
 };
 
 // Member comparison object
 // Call operator returns true if:
 //     collection item <comparison> specified item
 // where <comparison> can be <, >, ==, >=, <=
 template<typename Member, typename Value>
 struct member_comparator { //_
 
     member_comparator(ComparisonOperation comparison, Member member, Value value)
         : m_comparator(comparison)
         , m_member(member)
         , m_value(value)
     {
     }
 
     const ComparisonOperation m_comparator;
     const Member m_member;
     const Value m_value;
 
     // When passing only a item to compare with,
     // it means that we already have the value for comparison.
     // For example (member(M) > 5)(2)
     template<typename T>
     inline bool operator()(const T &collItem) const
     {
         return operator()(collItem, m_value);
     }
 
     // When passing the placeholder aka 'ignore' as a value,
     // it means that we already have the value for comparison.
     // For example (member(M) > 5)(collItem, _)
     template<typename T>
     inline bool operator()(const T &collItem, const placeholder &) const
     {
         return operator()(collItem, m_value);
     }
 
     // Like the previous one, but with reversed argument order
     template<typename T>
     inline bool operator()(const placeholder &, const T &collItem) const
     {
         return compare(m_value, (collItem.*m_member)());
     }
 
     // Comparing two values
     // For example (member(M) > _)(item, 5)
     template<typename T, typename V>
     inline bool operator()(const T &collItem, const V &value) const
     {
         // TODO: Make this work if the arguments are reversed,
         //       or even if both arhuments need to be checked
         //       for the specified member
         return compare((collItem.*m_member)(), value);
     }
 
 private:
     template<typename Left, typename Right>
     inline bool compare(const Left &left, const Right &right) const
     {
         return m_comparator == Less          ? left < right
             : m_comparator == LessOrEqual    ? left <= right
             : m_comparator == Equal          ? left == right
             : m_comparator == GreaterOrEqual ? left >= right
             : m_comparator == Greater        ? left > right
                                              : false;
     }
 
 }; //^
 
 // Chaining multiple comparators to achieve lexicographical
 // comparison of multiple members in order.
 // This would me so much nicer with variadic templates... f**ing MSVC.
 template<typename First, typename Second>
 struct member_comparator_chain {
     member_comparator_chain(First first, Second second)
         : first(first)
         , second(second)
     {
     }
 
     // Implement if needed...
     // template <typename T>
     // inline bool operator()(const T &item) const
     // {
     //     return first(item) || second(item);
     // }
 
     template<typename T, typename V>
     inline bool operator()(const T &item, const V &value) const
     {
         return first(item, value) || (!first(value, item) && second(item, value));
     }
 
     First first;
     Second second;
 };
 
 template<typename First, typename Second>
 inline member_comparator_chain<First, Second> operator&&(First first, Second second)
 {
     return member_comparator_chain<First, Second>(first, second);
 }
 
 // Provides syntax sugar for building member comparators
 template<typename Member>
 struct member_matcher { //_
     member_matcher(Member m)
         : m_member(m)
     {
     }
 
 #define IMPLEMENT_COMPARISON_OPERATOR(OPERATOR, NAME)                                                                                                          \
     template<typename Value>                                                                                                                                   \
     inline member_comparator<Member, Value> operator OPERATOR(const Value &value) const                                                                        \
     {                                                                                                                                                          \
         return member_comparator<Member, Value>(NAME, m_member, value);                                                                                        \
     }
 
     IMPLEMENT_COMPARISON_OPERATOR(<, Less)
     IMPLEMENT_COMPARISON_OPERATOR(<=, LessOrEqual)
     IMPLEMENT_COMPARISON_OPERATOR(==, Equal)
     IMPLEMENT_COMPARISON_OPERATOR(>=, GreaterOrEqual)
     IMPLEMENT_COMPARISON_OPERATOR(>, Greater)
 
 #undef IMPLEMENT_COMPARISON_OPERATOR
 
     Member m_member;
 }; //^
 
 } //^ namespace detail
 
 template<typename Member>
 detail::member_matcher<Member> member(Member m)
 {
     return detail::member_matcher<Member>(m);
 }
 } // namespace member
 
 } // namespace utils
 } // namespace kamd
 
 #endif // UTILS_MEMBER_MATCHER_H