File indexing completed on 2025-02-16 05:06:23

 /*
     SPDX-FileCopyrightText: 2015 Ivan Cukic <ivan.cukic(at)kde.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #ifndef QUICKCHECK_DATABASE_COMMON_H
 #define QUICKCHECK_DATABASE_COMMON_H
 
 struct PrimaryKeyOrdering {
     template<typename T>
     bool operator()(const T &left, const T &right) const
     {
         return left.primaryKey() < right.primaryKey();
     }
 };
 
 #define TABLE(Table) std::set<Table::Item, PrimaryKeyOrdering>
 
 #define DECL_COLUMN(ColumnType, ColumnName)                                                                                                                    \
     inline Column<Item, ColumnType> ColumnName()                                                                                                               \
     {                                                                                                                                                          \
         return Column<Item, ColumnType>(&Item::ColumnName);                                                                                                    \
     }
 
 template<typename Type, typename ColumnType>
 class Column
 {
     typedef Column<Type, ColumnType> ThisType;
 
 public:
     Column(const ColumnType Type::*memberptr)
         : memberptr(memberptr)
     {
     }
 
     //_ Column comparator functor
     template<typename Comp1, typename Comp2>
     class CompositeComparator
     {
     public:
         CompositeComparator(Comp1 comp1, Comp2 comp2)
             : comp1(comp1)
             , comp2(comp2)
         {
         }
 
         inline bool operator()(const Type &left, const Type &right) const
         {
             return comp1(left, right) ? true : comp1(right, left) ? false : comp2(left, right);
         }
 
     private:
         const Comp1 comp1;
         const Comp2 comp2;
     };
 
     class Comparator
     {
     public:
         Comparator(const ColumnType Type::*memberptr, bool invert)
             : memberptr(memberptr)
             , invert(invert)
         {
         }
 
         inline bool operator()(const Type &left, const Type &right) const
         {
             return (invert) ? right.*memberptr < left.*memberptr //
                             : left.*memberptr < right.*memberptr;
         }
 
         template<typename Comp2>
         CompositeComparator<Comparator, Comp2> operator|(const Comp2 &comp2)
         {
             return CompositeComparator<Comparator, Comp2>(*this, comp2);
         }
 
     private:
         const ColumnType Type::*memberptr;
         const bool invert;
     };
     //^
 
     inline Comparator asc() const
     {
         return Comparator(memberptr, false);
     }
 
     inline Comparator desc() const
     {
         return Comparator(memberptr, true);
     }
 
     //_ Column filtering functor
     enum ComparisonOperation {
         Less,
         LessOrEqual,
         Equal,
         GreaterOrEqual,
         Greater,
     };
 
     template<typename T>
     class Filterer
     {
     public:
         Filterer(const ColumnType Type::*memberptr, ComparisonOperation comparison, const T &value)
             : memberptr(memberptr)
             , comparison(comparison)
             , value(value)
         {
         }
 
         inline bool operator()(const Type &item) const
         {
             return comparison == Less          ? item.*memberptr < value
                 : comparison == LessOrEqual    ? item.*memberptr <= value
                 : comparison == Equal          ? item.*memberptr == value
                 : comparison == GreaterOrEqual ? item.*memberptr >= value
                 : comparison == Greater        ? item.*memberptr > value
                                                : false;
         }
 
     private:
         const ColumnType Type::*memberptr;
         const ComparisonOperation comparison;
         const T value;
     };
 
 #define IMPLEMENT_COMPARISON_OPERATOR(OPERATOR, NAME)                                                                                                          \
     template<typename T>                                                                                                                                       \
     inline Filterer<T> operator OPERATOR(const T &value) const                                                                                                 \
     {                                                                                                                                                          \
         return Filterer<T>(memberptr, NAME, 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
 
     // Column stuff
 
 private:
     const ColumnType Type::*memberptr;
 };
 
 template<typename Range, typename ColumnMemberPointer, typename MergeFunction>
 inline auto groupBy(const Range &range, const ColumnMemberPointer &memberptr, const MergeFunction &merge) -> std::vector<typename Range::value_type>
 {
     std::vector<typename Range::value_type> result;
 
     for (const auto &item : range) {
         if (result.size() == 0 || result.back().*memberptr != item.*memberptr) {
             result.push_back(item);
         } else {
             merge(result.back(), item);
         }
     }
 
     return result;
 }
 
 #endif // QUICKCHECK_DATABASE_COMMON_H
 
 // vim: set foldmethod=marker: