ATreeModelIndex.h

#pragma once
 
#include <AUI/Common/AException.h>
#include <any>
#include <variant>
 
class ATreeModelIndex {
public:
    class Exception: public AException {
    public:
        using AException::AException;
    };
 
    explicit ATreeModelIndex(std::size_t row, std::size_t column, std::any userdata) noexcept:
        mRow(row),
        mColumn(column),
        mUserdata(std::move(userdata)) {}
 
    template<typename T>
    [[nodiscard]]
    T as() const {
        try {
            return std::any_cast<T>(mUserdata);
        } catch (...) {
            throw Exception("ATreeModelIndex::as any_cast failed (asked for {}, actually stored {})"_format(
                typeid(T).name(), mUserdata.type().name()));
        }
    }
 
    [[nodiscard]]
    bool hasValue() const noexcept {
        return mUserdata.has_value();
    }
 
    [[nodiscard]]
    std::size_t row() const {
        return mRow;
    }
 
    [[nodiscard]]
    std::size_t column() const {
        return mColumn;
    }
 
    static constexpr struct {} ROOT {};
 
private:
    std::size_t mRow;
 
    std::size_t mColumn;
    
    std::any mUserdata;
};
 
using ATreeModelIndexOrRoot = std::variant<ATreeModelIndex, decltype(ATreeModelIndex::ROOT)>;
 
// these allow the following expression:
// vertex == ATreeModelIndex::ROOT
 
inline bool operator==(const ATreeModelIndexOrRoot& lhs, const decltype(ATreeModelIndex::ROOT)&) {
    return !std::holds_alternative<ATreeModelIndex>(lhs);
}
 
inline bool operator!=(const ATreeModelIndexOrRoot& lhs, const decltype(ATreeModelIndex::ROOT)&) {
    return std::holds_alternative<ATreeModelIndex>(lhs);
}
 
// this allows the following expression:
// ATreeModelIndexOrRoot vertex = ...
// ATreeModelIndex index = *vertex
 
inline const ATreeModelIndex& operator*(const ATreeModelIndexOrRoot& v) {
    if (auto i = std::get_if<ATreeModelIndex>(&v)) {
        return *i;
    }
    throw ATreeModelIndex::Exception("ATreeModelIndexOrRoot holds root");
}