AttributeNames.hpp

#pragma once
 
#include "AttributeRegistry.hpp"
#include "AttributeTypes.hpp"
 
#include <optional>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace mmcfilters {
inline const std::unordered_map<AttributeGroup, std::vector<Attribute>>& ATTRIBUTE_GROUPS =
    attributes::registry::attributeGroups();
 
 
class AttributeNamesWithDelta {
public:
    std::unordered_map<AttributeKey, int> indexMap;
 
    const int NUM_ATTRIBUTES;
 
    AttributeNamesWithDelta(std::unordered_map<AttributeKey, int>&& map)
        : indexMap(std::move(map)), NUM_ATTRIBUTES(static_cast<int>(indexMap.size())) {}
 
    [[nodiscard]] static AttributeNamesWithDelta create(int delta, const std::vector<Attribute>& attributes) {
        std::unordered_map<AttributeKey, int> map;
        int offset = 0;
        for (int d = -delta; d <= delta; ++d) {
            for (std::size_t i = 0; i < attributes.size(); ++i) {
                const AttributeKey key{attributes[i], d};
                const auto [_, inserted] = map.emplace(key, offset++);
                if (!inserted) {
                    throw std::invalid_argument(
                        "AttributeNamesWithDelta::create received duplicate attribute " +
                        toString(key));
                }
            }
        }
        return AttributeNamesWithDelta(std::move(map));
    }
 
    [[nodiscard]] int getIndex(Attribute attr, int delta) const {
        return getIndex(AttributeKey{attr, delta});
    }
 
    [[nodiscard]] int getIndex(AttributeKey attrKey) const {
        return indexMap.at(attrKey);
    }
 
    [[nodiscard]] int linearIndex(int nodeIndex, Attribute attr, int delta) const {
        return nodeIndex * NUM_ATTRIBUTES + getIndex(attr, delta);
    }
 
    [[nodiscard]] int linearIndex(int nodeIndex, AttributeKey attrKey) const {
        return linearIndex(nodeIndex, attrKey.attr, attrKey.delta);
    }
 
    [[nodiscard]] static std::string toString(AttributeKey attrKey) {
        return toString(attrKey.attr, attrKey.delta);
    }
 
    [[nodiscard]] static std::string toString(Attribute attr, int delta) {
        std::string name(attributes::registry::name(attr));
 
        if (delta < 0) {
            name += "_ASC_" + std::to_string(-delta);
        } else if (delta > 0) {
            name += "_DESC_" + std::to_string(delta);
        }
 
        return name;
    }
};
 
 
class AttributeNames {
public:
    std::unordered_map<Attribute, int> indexMap;
 
    const int NUM_ATTRIBUTES;
 
    AttributeNames(std::unordered_map<Attribute, int>&& map)
        : indexMap(std::move(map)), NUM_ATTRIBUTES(static_cast<int>(indexMap.size())) {}
 
    [[nodiscard]] static AttributeNames fromList(const std::vector<Attribute>& attributes) {
        std::unordered_map<Attribute, int> map;
        int i = 0;
        for (auto attr : attributes) {
            const auto [_, inserted] = map.emplace(attr, i++);
            if (!inserted) {
                throw std::invalid_argument(
                    "AttributeNames::fromList received duplicate attribute " +
                    toString(attr));
            }
        }
        return AttributeNames(std::move(map));
    }
 
    [[nodiscard]] static AttributeNames fromGroup(AttributeGroup group) {
        auto it = ATTRIBUTE_GROUPS.find(group);
        if (it == ATTRIBUTE_GROUPS.end()) {
            throw std::invalid_argument("Unknown attribute group.");
        }
        return fromList(it->second);
    }
 
    [[nodiscard]] int getIndex(Attribute attr) const {
        return indexMap.at(attr);
    }
 
    [[nodiscard]] bool contains(Attribute attr) const noexcept {
        return indexMap.contains(attr);
    }
 
    [[nodiscard]] int offset(Attribute attr) const {
        return getIndex(attr);
    }
 
    [[nodiscard]] int linearIndex(int nodeIndex, Attribute attr) const {
        return nodeIndex * NUM_ATTRIBUTES + getIndex(attr);
    }
 
    [[nodiscard]] static std::string toString(Attribute attr) {
        return std::string(attributes::registry::name(attr));
    }
 
    static std::string describe(Attribute attr) {
        return std::string(attributes::registry::description(attr));
    }
 
    [[nodiscard]] static std::optional<Attribute> parse(const std::string& str) {
        return attributes::registry::parse(str);
    }
};
 
} // namespace mmcfilters