tag.h

/*
    SPDX-FileCopyrightText: 2014 Christian Mollekopf <[email protected]>

    SPDX-License-Identifier: LGPL-2.0-or-later
*/

#ifndef AKONADI_TAG_H
#define AKONADI_TAG_H

#include "akonadicore_export.h"
#include "attribute.h"

#include <QString>
#include <QSharedPointer>
#include <QUrl>
#include <QDebug>

namespace Akonadi
{
class TagModifyJob;
class TagPrivate;

class AKONADICORE_EXPORT Tag
{
public:
    typedef QVector<Tag> List;
    typedef qint64 Id;

    static const char PLAIN[];

    static const char GENERIC[];

    Tag();
    explicit Tag(Id id);
    explicit Tag(const QString &name);

    Tag(const Tag &);

    Tag(Tag &&) noexcept;

    ~Tag();

    Tag &operator=(const Tag &);
    Tag &operator=(Tag &&) noexcept;
    //Avoid slicing
    bool operator==(const Tag &) const;
    bool operator!=(const Tag &) const;

    static Tag fromUrl(const QUrl &url);

    void addAttribute(Attribute *attribute);

    void removeAttribute(const QByteArray &name);

    bool hasAttribute(const QByteArray &name) const;

    Attribute::List attributes() const;

    void clearAttributes();

    const Attribute *attribute(const QByteArray &name) const;
    Attribute *attribute(const QByteArray &name);

    enum CreateOption {
        AddIfMissing,    
        DontCreate       
    };

    template <typename T>
    inline T *attribute(CreateOption option = DontCreate);

    template <typename T>
    inline const T *attribute() const;

    template <typename T>
    inline void removeAttribute();

    template <typename T>
    inline bool hasAttribute() const;

    QUrl url() const;

    void setId(Id identifier);

    Id id() const;

    void setGid(const QByteArray &gid);
    QByteArray gid() const;

    void setRemoteId(const QByteArray &remoteId);
    QByteArray remoteId() const;

    void setType(const QByteArray &type);
    QByteArray type() const;

    void setName(const QString &name);
    QString name() const;

    void setParent(const Tag &parent);
    Tag parent() const;

    bool isValid() const;

    bool isImmutable() const;

    static Tag genericTag(const QString &name);

private:
    bool checkAttribute(const Attribute *attr, const QByteArray &type) const;
    void markAttributeModified(const QByteArray &type);

    //@cond PRIVATE
    friend class TagModifyJob;
    friend class TagFetchJob;
    friend class ProtocolHelper;

    QSharedDataPointer<TagPrivate> d_ptr;
    //@endcond
};

AKONADICORE_EXPORT uint qHash(const Akonadi::Tag &);

template <typename T>
inline T *Tag::attribute(CreateOption option)
{
    const QByteArray type = T().type();
    markAttributeModified(type);
    if (hasAttribute(type)) {
        T *attr = dynamic_cast<T *>(attribute(type));
        if (checkAttribute(attr, type)) {
            return attr;
        }
    } else if (option == AddIfMissing) {
        T *attr = new T();
        addAttribute(attr);
        return attr;
    }

    return nullptr;
}

template <typename T>
inline const T *Tag::attribute() const
{
    const QByteArray type = T().type();
    if (hasAttribute(type)) {
        const T *attr = dynamic_cast<const T *>(attribute(type));
        if (checkAttribute(attr, type)) {
            return attr;
        }
    }

    return nullptr;
}

template <typename T>
inline void Tag::removeAttribute()
{
    const T dummy;
    removeAttribute(dummy.type());
}

template <typename T>
inline bool Tag::hasAttribute() const
{
    const T dummy;
    return hasAttribute(dummy.type());
}

} // namespace Akonadi

AKONADICORE_EXPORT QDebug operator<<(QDebug debug, const Akonadi::Tag &tag);

Q_DECLARE_METATYPE(Akonadi::Tag)
Q_DECLARE_METATYPE(Akonadi::Tag::List)
Q_DECLARE_METATYPE(QSet<Akonadi::Tag>)
Q_DECLARE_TYPEINFO(Akonadi::Tag, Q_MOVABLE_TYPE);

#endif