azothcommon.h

Go to the documentation of this file.

/**********************************************************************
 * LeechCraft - modular cross-platform feature rich internet client.
 * Copyright (C) 2006-2014  Georg Rudoy
 *
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 **********************************************************************/
 
#pragma once
 
#include <variant>
#include <QHashFunctions>
#include <QMetaType>
#include <interfaces/azoth/imessage.h>
 
namespace LC
{
namespace Azoth
{
    enum class IdKind : std::uint8_t
    {
        Persistent,
        Conventional,
    };
 
    template<IdKind>
    struct EntryId
    {
        QString Id_;
 
        EntryId () = default;
 
        static EntryId FromString (const QString& id) { return EntryId { id }; }
 
        bool operator== (const EntryId&) const = default;
 
        friend size_t qHash (const EntryId& id, size_t seed = 0) { return qHash (id.Id_, seed); }
 
        [[nodiscard]] QString ToString () const { return Id_; }
    private:
        explicit EntryId (const QString& id) : Id_ { id } {}
    };
 
    using EntryPersistentId = EntryId<IdKind::Persistent>;
    using EntryConventionalId = EntryId<IdKind::Conventional>;
 
    template<IdKind K>
    struct GlobalId
    {
        QString AccountId_;
        EntryId<K> EntryId_;
 
        bool operator== (const GlobalId&) const = default;
 
        friend size_t qHash (const GlobalId& id, size_t seed = 0) { return qHashMulti (seed, id.AccountId_, id.EntryId_); }
 
        [[nodiscard]] QString ToString () const { return AccountId_ + ':' + EntryId_.ToString (); }
    };
 
    using GlobalPersistentId = GlobalId<IdKind::Persistent>;
    using GlobalConventionalId = GlobalId<IdKind::Conventional>;
 
    template<template<IdKind> typename Id>
    struct StrongestId : std::variant<Id<IdKind::Persistent>, Id<IdKind::Conventional>>
    {
        using Base = std::variant<Id<IdKind::Persistent>, Id<IdKind::Conventional>>;
        using Base::Base;
 
        bool operator== (const StrongestId&) const = default;
 
        friend size_t qHash (const StrongestId& strongestId, size_t seed = 0)
        {
            const auto index = strongestId.index ();
            return std::visit ([&] (const auto& id) { return qHashMulti (seed, index, id); }, strongestId.ToVariant ());
        }
 
        [[nodiscard]] QString ToString () const
        {
            return std::visit ([] (const auto& id) { return id.ToString (); }, *this);
        }
 
        [[nodiscard]] const Base& ToVariant () const
        {
            return *this;
        }
    };
 
    using EntryStrongestId = StrongestId<EntryId>;
    using GlobalStrongestId = StrongestId<GlobalId>;
 
    inline GlobalStrongestId AsGlobalId (const QString& accountId, const EntryStrongestId& entryId)
    {
        return std::visit ([&accountId] (const auto& id) { return GlobalStrongestId { GlobalId { accountId, id } }; },
                entryId);
    }
 
    inline QString GetAccountId (const GlobalStrongestId& strongestId)
    {
        return std::visit ([] (const auto& id) { return id.AccountId_; }, strongestId.ToVariant ());
    }

    enum State : std::uint8_t
    {
        SOffline,
        SOnline,
        SAway,
        SXA,
        SDND,
        SChat,
        SInvisible,
        SProbe,
        SError,
        SInvalid,

        SConnecting
    };

    constexpr bool IsLess (State s1, State s2)
    {
        constexpr int order [] = { 7, 3, 4, 5, 6, 1, 2, 8, 9, 10, 11 };
        return order [s1] < order [s2];
    }

    enum AuthStatus
    {
        ASNone = 0x00,

        ASFrom = 0x01,

        ASTo = 0x02,

        ASBoth = 0x03,

        ASContactRequested = 0x08
    };

    enum ChatPartState : std::uint8_t
    {
        CPSNone,

        CPSActive,

        CPSInactive,

        CPSGone,

        CPSComposing,

        CPSPaused
    };

    struct CustomStatus
    {
        QString Name_;

        State State_;

        QString Text_;
    };

    struct EntryStatus
    {
        State State_ = SOffline;

        QString StatusString_ {};
 
        bool operator== (const EntryStatus& es2) const = default;
    };
}
}
 
Q_DECLARE_METATYPE (LC::Azoth::ChatPartState)
Q_DECLARE_METATYPE (LC::Azoth::EntryStatus)
Q_DECLARE_METATYPE (LC::Azoth::State)