aggregation.h

/******************************************************************************
 *
 *  SPDX-FileCopyrightText: 2008 Szymon Tomasz Stefanek <[email protected]>
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *
 *******************************************************************************/

#ifndef MESSAGELIST_CORE_AGGREGATION_H
#define MESSAGELIST_CORE_AGGREGATION_H

class QDataStream;

#include <QVector>
#include <QPair>
#include <QString>

#include "core/optionset.h"

namespace MessageList {
namespace Core {
class Aggregation : public OptionSet
{
public:

    enum Grouping {
        NoGrouping,                          
        GroupByDate,                         
        GroupByDateRange,                    
        GroupBySenderOrReceiver,             
        GroupBySender,                       
        GroupByReceiver                      
        // Never add enum entries in the middle: always add them at the end (numeric values are stored in configuration)
        // TODO: Group by message status: "Important messages", "Urgent messages", "To reply", "To do" etc...
        // TODO: Group by message unread status: "Unread messages", "Read messages" (maybe "New" ?)
    };

    enum GroupExpandPolicy {
        NeverExpandGroups,                   
        ExpandRecentGroups,                  
        AlwaysExpandGroups                   
        // Never add enum entries in the middle: always add them at the end (numeric values are stored in configuration)
    };

    enum Threading {
        NoThreading,                         
        PerfectOnly,                         
        PerfectAndReferences,                
        PerfectReferencesAndSubject          
        // Never add enum entries in the middle: always add them at the end (numeric values are stored in configuration)
    };

    enum ThreadLeader {
        TopmostMessage,                      
        MostRecentMessage                    
        // Never add enum entries in the middle: always add them at the end (numeric values are stored in configuration)
    };

    enum ThreadExpandPolicy {
        NeverExpandThreads,                                
        ExpandThreadsWithNewMessages,                      
        ExpandThreadsWithUnreadMessages,                   
        AlwaysExpandThreads,                               
        ExpandThreadsWithUnreadOrImportantMessages         
        // Never add enum entries in the middle: always add them at the end (numeric values are stored in configuration)
    };

    enum FillViewStrategy {
        FavorInteractivity,                  
        FavorSpeed,                          
        BatchNoInteractivity                 
        // Warning: Never add enum entries in the middle: always add them at the end (numeric values are stored in configuration)
    };

private:
    Grouping mGrouping;
    GroupExpandPolicy mGroupExpandPolicy;
    Threading mThreading;
    ThreadLeader mThreadLeader;
    ThreadExpandPolicy mThreadExpandPolicy;
    FillViewStrategy mFillViewStrategy;

public:
    explicit Aggregation();
    explicit Aggregation(const Aggregation &opt);
    explicit Aggregation(
        const QString &name, const QString &description, Grouping grouping, GroupExpandPolicy groupExpandPolicy, Threading threading, ThreadLeader threadLeader, ThreadExpandPolicy threadExpandPolicy, FillViewStrategy fillViewStrategy, bool readOnly);
    static Q_REQUIRED_RESULT bool compareName(Aggregation *agg1, Aggregation *agg2)
    {
        return agg1->name() < agg2->name();
    }

public:
    Q_REQUIRED_RESULT Grouping grouping() const;

    void setGrouping(Grouping g)
    {
        mGrouping = g;
    }

    static QVector< QPair< QString, int > > enumerateGroupingOptions();

    Q_REQUIRED_RESULT GroupExpandPolicy groupExpandPolicy() const
    {
        return mGroupExpandPolicy;
    }

    void setGroupExpandPolicy(GroupExpandPolicy groupExpandPolicy)
    {
        mGroupExpandPolicy = groupExpandPolicy;
    }

    static QVector< QPair< QString, int > > enumerateGroupExpandPolicyOptions(Grouping g);

    Q_REQUIRED_RESULT Threading threading() const
    {
        return mThreading;
    }

    void setThreading(Threading t)
    {
        mThreading = t;
    }

    static QVector< QPair< QString, int > > enumerateThreadingOptions();

    Q_REQUIRED_RESULT ThreadLeader threadLeader() const
    {
        return mThreadLeader;
    }

    void setThreadLeader(ThreadLeader tl)
    {
        mThreadLeader = tl;
    }

    static QVector< QPair< QString, int > > enumerateThreadLeaderOptions(Grouping g, Threading t);

    ThreadExpandPolicy threadExpandPolicy() const
    {
        return mThreadExpandPolicy;
    }

    void setThreadExpandPolicy(ThreadExpandPolicy threadExpandPolicy)
    {
        mThreadExpandPolicy = threadExpandPolicy;
    }

    static QVector< QPair< QString, int > > enumerateThreadExpandPolicyOptions(Threading t);

    Q_REQUIRED_RESULT FillViewStrategy fillViewStrategy() const
    {
        return mFillViewStrategy;
    }

    void setFillViewStrategy(FillViewStrategy fillViewStrategy)
    {
        mFillViewStrategy = fillViewStrategy;
    }

    static QVector< QPair< QString, int > > enumerateFillViewStrategyOptions();

    void save(QDataStream &stream) const override;

    bool load(QDataStream &stream) override;
};
} // namespace Core
} // namespace MessageList

#endif