AttributeNames.hpp

#pragma once
 
#include "AttributeRegistry.hpp"
#include "AttributeTypes.hpp"
#include "../utils/Contract.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 NodeAttributeSampleLayout {
  public:
    std::unordered_map<NodeAttributeSampleKey, int> indexMap;
 
    const int NUM_ATTRIBUTES;
 
    NodeAttributeSampleLayout(std::unordered_map<NodeAttributeSampleKey, int>&& map)
        : indexMap(std::move(map)), NUM_ATTRIBUTES(static_cast<int>(indexMap.size())) {}
 
    [[nodiscard]] static NodeAttributeSampleLayout create(int samplingRadius, const std::vector<Attribute>& attributes) {
        std::unordered_map<NodeAttributeSampleKey, int> map;
        int offset = 0;
        for (int sampleOffset = -samplingRadius; sampleOffset <= samplingRadius; ++sampleOffset) {
            for (std::size_t i = 0; i < attributes.size(); ++i) {
                const NodeAttributeSampleKey key{attributes[i], sampleOffset};
                const auto [_, inserted] = map.emplace(key, offset++);
                MMCFILTERS_CONTRACT_REQUIRE(
                    inserted, throw std::invalid_argument("NodeAttributeSampleLayout::create received duplicate attribute " + toString(key)));
            }
        }
        return NodeAttributeSampleLayout(std::move(map));
    }
 
    [[nodiscard]] int getIndex(Attribute attribute, int sampleOffset) const {
        return getIndex(NodeAttributeSampleKey{attribute, sampleOffset});
    }
 
    [[nodiscard]] int getIndex(NodeAttributeSampleKey sampleKey) const { return indexMap.at(sampleKey); }
 
    [[nodiscard]] int linearIndex(int nodeIndex, Attribute attribute, int sampleOffset) const {
        return nodeIndex * NUM_ATTRIBUTES + getIndex(attribute, sampleOffset);
    }
 
    [[nodiscard]] int linearIndex(int nodeIndex, NodeAttributeSampleKey sampleKey) const {
        return linearIndex(nodeIndex, sampleKey.attribute, sampleKey.sampleOffset);
    }
 
    [[nodiscard]] static std::string toString(NodeAttributeSampleKey sampleKey) {
        return toString(sampleKey.attribute, sampleKey.sampleOffset);
    }
 
    [[nodiscard]] static std::string toString(Attribute attribute, int sampleOffset) {
        std::string name(attributes::registry::name(attribute));
 
        if (sampleOffset < 0) {
            name += "_ANCESTOR_" + std::to_string(-sampleOffset);
        } else if (sampleOffset > 0) {
            name += "_DESCENDANT_" + std::to_string(sampleOffset);
        }
 
        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++);
            MMCFILTERS_CONTRACT_REQUIRE(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);
        MMCFILTERS_CONTRACT_REQUIRE(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