LhaID.h

Go to the documentation of this file.

#ifndef LHA_ID_H
#define LHA_ID_H
 
#include <string>
#include <stdexcept>
#include <algorithm>
#include <iostream>
#include <unordered_set>
#include <initializer_list>
#include <map>
#include <vector>
#include <set>
#include <ranges>
#include <concepts>
#include <variant>
#include "Logger.h"
#include "Utils.h"
#include "GeneralEnum.h"
 
namespace fs = std::filesystem;
 
struct LhaID {
    std::vector<long> parts;     
    template<typename... Args>
    requires (std::convertible_to<Args, long> && ...)
    LhaID(Args... sub_ids) : parts({static_cast<long>(sub_ids)...}) {}
 
    LhaID(const std::string& parts);
 
    LhaID(const std::vector<long>& sub_ids) : parts(sub_ids) {}
    LhaID(std::vector<long>&& sub_ids) : parts(std::move(sub_ids)) {}
 
    // /**
    //  * @brief Constructs an LhaID from an initializer list of sub-ids.
    //  *
    //  * This is especially convenient for brace-initialization:
    //  * @code
    //  * LhaID id{5, 2};
    //  * @endcode
    //  *
    //  * @param sub_ids Sub-identifiers of the element.
    //  */
    // LhaID(std::initializer_list<long> sub_ids) : parts(sub_ids) {}
 
    LhaID(long id) : parts({id}) {}
 
    std::string to_string() const;
 
    std::vector<long> get_parts() const { return parts; }
    
    operator long() const;
 
    inline friend bool operator==(const LhaID& lhs, const LhaID& rhs) { return lhs.parts == rhs.parts; };
 
    inline friend bool operator!=(const LhaID& lhs, const LhaID& rhs) { return !(lhs == rhs); };
 
    inline friend bool operator<(const LhaID& lhs, const LhaID& rhs) { return (lhs.parts <=> rhs.parts) == std::weak_ordering::less; };
 
    friend std::ostream& operator<<(std::ostream&, const LhaID&);
};
 
namespace std {
    template <>
    struct hash<LhaID> {
        std::size_t operator()(const LhaID& p) const noexcept {
            return std::hash<std::string>{}(p.to_string());
        }
    };
}
 
#endif