BlockName.h

Go to the documentation of this file.

#ifndef BLOCK_NAME_H
#define BLOCK_NAME_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;
 
class BlockName {
private:
    std::unordered_set<std::string> block_names;
    std::string primary;
    
    static inline std::string upper_copy(std::string s) {
        std::transform(s.begin(), s.end(), s.begin(),
                       [](unsigned char c){ return static_cast<char>(std::toupper(c)); });
        return s;
    }
 
    static inline std::unordered_set<std::string> split_aliases(const std::string& s) {
        std::unordered_set<std::string> out;
        std::string cur;
        for (char ch : s) {
            if (ch == '/') {
                if (!cur.empty()) out.insert(cur);
                cur.clear();
            } else cur.push_back(ch);
        }
        if (!cur.empty()) out.insert(cur);
        return out;
    }
 
    static std::unordered_set<std::string> split_slash_aliases(const std::string& s) {
        std::unordered_set<std::string> out;
        std::string cur;
        cur.reserve(s.size());
        for (char c : s) {
            if (c == '/') {
                if (!cur.empty()) { out.insert(cur); cur.clear(); }
            } else {
                cur.push_back(c);
            }
        }
        if (!cur.empty()) out.insert(cur);
        return out;
    }
    public:
    BlockName() = default;
    
    BlockName(const std::string& name);
    
    BlockName(const char* name);
    
    BlockName(std::initializer_list<std::string> names);
    
    BlockName(const std::unordered_set<std::string>& names);
    
    std::unordered_set<std::string> get_alias() const;
    
    const std::string& canonical() const;
    
    operator std::string() const;
 
    bool hasAlias(const std::string& alias) const;
 
    std::string to_string() const;
 
    bool operator==(const BlockName& other) const;
 
    bool operator!=(const BlockName& other) const;
 
    bool operator==(const std::string& name) const;
 
    bool operator==(const char* name) const;
 
    bool operator!=(const std::string& name) const;
 
    BlockName& addAlias(const std::string& alias);
 
    BlockName& addAliases(const std::unordered_set<std::string>& as);
 
    friend BlockName operator+(const std::string& lhs, const BlockName& rhs);
 
    friend std::ostream& operator<<(std::ostream& os, const BlockName& block);
 
    void to_upper();
 
    bool operator<(const BlockName& other) const;
};
 
inline bool operator==(const std::string& lhs, const BlockName& rhs) {
    return rhs == lhs;
}
 
inline bool operator!=(const std::string& lhs, const BlockName& rhs) {
    return !(rhs == lhs);
}
 
// inline bool operator==(const std::string& lhs, const BlockName& rhs) { return rhs.hasAlias(lhs); }
// inline bool operator!=(const std::string& lhs, const BlockName& rhs) { return !(lhs == rhs); }
 
namespace std {
    template <>
    struct hash<BlockName> {
        // std::size_t operator()(const BlockName& p) const noexcept {
        //     size_t h = 0;
        //     for (const auto& name : p.get_alias()) {
        //         h ^= std::hash<std::string>{}(name) + 0x9e3779b9 + (h << 6) + (h >> 2); // boost-style hash combine
        //     }
        //     return h;
        // }
        // size_t operator()(const BlockName& b) const noexcept {
        //     return std::hash<std::string>{}(b.canonical());
        // }
         std::size_t operator()(const BlockName& p) const noexcept {
            // hash order-independent sur tous les aliases
            size_t h = 0;
            for (const auto& name : p.get_alias()) {
                h ^= std::hash<std::string>{}(name) + 0x9e3779b9 + (h << 6) + (h >> 2);
            }
            return h;
        }
        // size_t operator()(const BlockName& p) const noexcept {
        //     return std::hash<std::string>{}(p.canonical());
        // }
    };
}
 
#endif