Skip to content
Snippets Groups Projects
Select Git revision
  • master default protected
  • beta/202506161038
  • stable/20250613.0
  • nightly/20250613.0
  • beta/202506101658
  • stable/20250610.0
  • nightly/20250610.0
  • beta/202506091027
  • beta/202506061543
  • nightly/20250605.0
  • beta/202506051039
  • beta/202506051002
  • beta/202506041611
  • beta/202506041335
  • beta/202505231812
  • stable/20250523.0
  • nightly/20250523.0
  • nightly/20250515.0
  • nightly/20250510.0
  • nightly/20250509.1
  • nightly/20250509.0
21 results

typedefs.h

Blame
    • Sébastien Blin's avatar
      d5349490
      conversation: follow daemon changes for sending status · d5349490
      Sébastien Blin authored
      cf jami-docs/developer/delivery-status
      + Basically this patch uses the new SwarmMessage.status to show
      current interaction status.
      + setRead only updates the status if the interaction is newer (else,
      because signal are not guaranteed to be ordered, this can cause the
      lastDisplayed_ to be incorrect).
      + Some old code is removed and unused signal
      + MessageReceived updates status if needed
      
      GitLab: #1487
      Change-Id: I4d4d5dce8dc12ab638e89e3f8431810b29a72087
      d5349490
      History
      conversation: follow daemon changes for sending status
      Sébastien Blin authored
      cf jami-docs/developer/delivery-status
      + Basically this patch uses the new SwarmMessage.status to show
      current interaction status.
      + setRead only updates the status if the interaction is newer (else,
      because signal are not guaranteed to be ordered, this can cause the
      lastDisplayed_ to be incorrect).
      + Some old code is removed and unused signal
      + MessageReceived updates status if needed
      
      GitLab: #1487
      Change-Id: I4d4d5dce8dc12ab638e89e3f8431810b29a72087
    Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    typedefs.h 7.31 KiB
    /****************************************************************************
     *    Copyright (C) 2009-2024 Savoir-faire Linux Inc.                       *
     *   Author : Jérémy Quentin <jeremy.quentin@savoirfairelinux.com>          *
     *            Emmanuel Lepage Vallee <emmanuel.lepage@savoirfairelinux.com> *
     *                                                                          *
     *   This library is free software; you can redistribute it and/or          *
     *   modify it under the terms of the GNU Lesser General Public             *
     *   License as published by the Free Software Foundation; either           *
     *   version 2.1 of the License, or (at your option) any later version.     *
     *                                                                          *
     *   This library is distributed in the hope that it will be useful,        *
     *   but WITHOUT ANY WARRANTY; without even the implied warranty of         *
     *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU      *
     *   Lesser General Public License for more details.                        *
     *                                                                          *
     *   You should have received a copy of the GNU General Public License      *
     *   along with this program.  If not, see <http://www.gnu.org/licenses/>.  *
     ***************************************************************************/
    #pragma once
    
    // Qt
    #include <QtCore/QMetaType>
    #include <QtCore/QMap>
    #include <QtCore/QVector>
    #include <QtCore/QString>
    #include <QtCore/QDebug>
    #include <QtCore/QDateTime>
    
    #include <QtCore/QLoggingCategory>
    
    Q_DECLARE_LOGGING_CATEGORY(libclientLog)
    #define LC_DBG  qCDebug(libclientLog)
    #define LC_INFO qCInfo(libclientLog)
    #define LC_WARN qCWarning(libclientLog)
    #define LC_ERR  qCCritical(libclientLog)
    #define LC_FATAL qCFatal(libclientLog)
    
    // Typedefs (required to avoid '<' and '>' in the DBus XML)
    typedef QMap<QString, QString> MapStringString;
    typedef QMap<QString, int> MapStringInt;
    typedef QMap<QString, double> MapStringDouble;
    typedef QMap<QPair<QString, QString>, bool> MapPairStrStrBool;
    typedef QVector<int> VectorInt;
    typedef QVector<uint> VectorUInt;
    typedef QVector<qulonglong> VectorULongLong;
    typedef QVector<QMap<QString, QString>> VectorMapStringString;
    typedef QVector<QString> VectorString;
    typedef QMap<QString, QMap<QString, QVector<QString>>> MapStringMapStringVectorString;
    typedef QMap<QString, QVector<QString>> MapStringVectorString;
    typedef QMap<QString, QMap<QString, QStringList>> MapStringMapStringStringList;
    typedef QMap<QString, QStringList> MapStringStringList;
    typedef QVector<QByteArray> VectorVectorByte;
    typedef uint64_t DataTransferId;
    // accountId, conversationId
    typedef QPair<QString, QString> PositionKey;
    
    constexpr static const char* TRUE_STR = "true";
    constexpr static const char* TEXT_PLAIN = "text/plain";
    constexpr static const char* APPLICATION_GEO = "application/geo";
    constexpr static const char* FALSE_STR = "false";
    
    enum class MessageFlag : int {
        Text = 0,
        Reply = 1,
        Reaction = 2,
    };
    
    // Adapted from libring libjami::DataTransferInfo
    struct DataTransferInfo
    {
        QString accountId;
        quint32 lastEvent;
        quint32 flags;
        qlonglong totalSize;
        qlonglong bytesProgress;
        QString author;
        QString peer;
        QString conversationId;
        QString displayName;
        QString path;
        QString mimetype;
    };
    
    struct SwarmMessage
    {
        QString id;
        QString type;
        QString linearizedParent;
        MapStringString body;
        VectorMapStringString reactions;
        VectorMapStringString editions;
        MapStringInt status;
    };
    typedef QVector<SwarmMessage> VectorSwarmMessage;
    
    struct Message
    {
        QString from;
        MapStringString payloads;
        quint64 received;
    };
    
    typedef QVector<Message> messages;
    
    /**
     * This function add a safe way to get an enum class size
     * @note it cannot be "const" due to some compiler issues
     * @note it cannot be unsigned to avoid some compiler warnings
     */
    template<typename A>
    constexpr int
    enum_class_size()
    {
        return static_cast<int>(A::COUNT__);
    }
    
    #ifdef LRC_IMPORT
    #define LIB_EXPORT Q_DECL_IMPORT
    #else
    #if defined(_MSC_VER)
    #define LIB_EXPORT
    #else
    #define LIB_EXPORT Q_DECL_EXPORT
    #endif
    #endif
    
    // Doesn't work
    #if ((__GNUC_MINOR__ > 8) || (__GNUC_MINOR__ == 8))
    #define STRINGIFY(x) #x
    #define IGNORE_NULL(content) \
        _Pragma(STRINGIFY(GCC diagnostic ignored "-Wzero-as-null-pointer-constant")) content
    #else
    #define IGNORE_NULL(content) content
    #endif // ENABLE_IGNORE_NULL
    
    /**
     * Create a safe pack of flags from an enum class.
     *
     * This class exist to ensure all sources come from the same enum and that it is
     * never accidentally accidentally into an integer.
     *
     * This assume that the enum has been setup as flags.
     */
    template<class T>
    class LIB_EXPORT FlagPack
    {
    public:
        FlagPack()
            : m_Flags(0)
        {}
        FlagPack(const T& base)
            : m_Flags(static_cast<uint>(base))
        {}
        FlagPack(const FlagPack<T>& other)
            : m_Flags(other.m_Flags)
        {}
    
        // Operator
        FlagPack<T>& operator|(const T& other)
        {
            m_Flags |= static_cast<uint>(other);
            return *this;
        }
    
        FlagPack<T>& operator|(const FlagPack<T>& other)
        {
            m_Flags |= other.m_Flags;
            return *this;
        }
    
        FlagPack<T>& operator|=(const T& other)
        {
            m_Flags |= static_cast<uint>(other);
            return *this;
        }
    
        FlagPack<T>& operator|=(const FlagPack<T>& other)
        {
            m_Flags |= other.m_Flags;
            return *this;
        }
    
        FlagPack<T>& operator^=(const T& other)
        {
            m_Flags ^= static_cast<uint>(other);
            return *this;
        }
    
        FlagPack<T>& operator^=(const FlagPack<T>& other)
        {
            m_Flags ^= other.m_Flags;
            return *this;
        }
    
        FlagPack<T> operator&(const T& other) const
        {
            return FlagPack<T>(m_Flags & static_cast<uint>(other));
        }
    
        FlagPack<T> operator&(const FlagPack<T>& other) const
        {
            return FlagPack<T>(m_Flags & other.m_Flags);
        }
    
        FlagPack<T>& operator=(const FlagPack<T>& other)
        {
            m_Flags = other.m_Flags;
            return *this;
        }
    
        bool operator!=(const T& other) const
        {
            return m_Flags != static_cast<uint>(other);
        }
    
        bool operator==(const T& other) const
        {
            return m_Flags == static_cast<uint>(other);
        }
    
        bool operator==(const FlagPack<T>& other) const
        {
            return m_Flags == other.m_Flags;
        }
    
        bool operator!() const
        {
            return !m_Flags;
        }
    
        operator bool() const
        {
            return m_Flags != 0;
        }
    
        uint value() const
        {
            return m_Flags;
        }
    
    private:
        FlagPack(uint base)
            : m_Flags(base)
        {}
        uint m_Flags;
    };
    
    #ifdef _MSC_VER
    #define DO_PRAGMA(x)     /*do nothing*/
    #define __attribute__(A) /*do nothing*/
    #include <ciso646>
    #else
    #define DO_PRAGMA(x) _Pragma(#x)
    #endif // _MSC_VER
    
    // Globally disable the "-Wunused-function" warning for GCC
    // refs: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=55578
    #if ((__GNUC_MINOR__ > 8) || (__GNUC_MINOR__ == 8))
    #pragma GCC diagnostic ignored "-Wunused-function"
    #endif
    
    #define DECLARE_ENUM_FLAGS(T) \
        DO_PRAGMA(GCC diagnostic push) \
        DO_PRAGMA(GCC diagnostic ignored "-Wunused-function") \
        __attribute__((unused)) static FlagPack<T> operator|(const T& first, const T& second) \
        { \
            FlagPack<T> p(first); \
            return p | second; \
        } \
        DO_PRAGMA(GCC diagnostic pop)