IndexTypes.h

Go to the documentation of this file.

 
#ifndef HELIOS_INDEX_TYPES_H
#define HELIOS_INDEX_TYPES_H
 
#include <cstddef>
#include <vector>
#include <stdexcept>
#include <algorithm>
#include <iostream>
 
namespace helios {
 
    // ========== Strong Index Types ==========
 
    struct PrimitiveUUID {
        uint value; 
 
        explicit constexpr PrimitiveUUID(uint v) : value(v) {
        }
 
        explicit operator uint() const {
            return value;
        }
 
        constexpr bool operator==(const PrimitiveUUID &other) const {
            return value == other.value;
        }
        constexpr bool operator!=(const PrimitiveUUID &other) const {
            return value != other.value;
        }
    };
 
    struct ArrayPosition {
        size_t value; 
 
        explicit constexpr ArrayPosition(size_t v) : value(v) {
        }
 
        constexpr operator size_t() const {
            return value;
        }
 
        constexpr bool operator==(const ArrayPosition &other) const {
            return value == other.value;
        }
        constexpr bool operator!=(const ArrayPosition &other) const {
            return value != other.value;
        }
    };
 
    constexpr ArrayPosition INVALID_POSITION{SIZE_MAX};
 
    // ========== UUID ↔ Position Mapper ==========
 
    class UUIDPositionMapper {
    private:
        std::vector<size_t> uuid_to_position_; 
        std::vector<uint> position_to_uuid_; 
 
#ifndef NDEBUG
        bool debug_validation_enabled_ = true; 
#endif
 
    public:
        void build(const std::vector<uint> &primitive_uuids) {
            position_to_uuid_ = primitive_uuids;
 
            if (primitive_uuids.empty()) {
                uuid_to_position_.clear();
                return;
            }
 
            // Find max UUID to size sparse array
            uint max_uuid = *std::max_element(primitive_uuids.begin(), primitive_uuids.end());
            uuid_to_position_.assign(max_uuid + 1, SIZE_MAX);
 
            // Populate UUID → position mapping
            for (size_t pos = 0; pos < primitive_uuids.size(); ++pos) {
                uuid_to_position_[primitive_uuids[pos]] = pos;
            }
        }
 
        ArrayPosition toPosition(PrimitiveUUID uuid) const {
            if (uuid.value >= uuid_to_position_.size()) {
                return INVALID_POSITION;
            }
 
            size_t pos = uuid_to_position_[uuid.value];
            if (pos == SIZE_MAX) {
                return INVALID_POSITION;
            }
 
            return ArrayPosition{pos};
        }
 
        PrimitiveUUID toUUID(ArrayPosition pos) const {
            if (pos.value >= position_to_uuid_.size()) {
                throw std::out_of_range("ArrayPosition " + std::to_string(pos.value) + " out of range [0, " + std::to_string(position_to_uuid_.size()) + ")");
            }
            return PrimitiveUUID{position_to_uuid_[pos.value]};
        }
 
        bool isValidUUID(PrimitiveUUID uuid) const {
            return toPosition(uuid) != INVALID_POSITION;
        }
 
        size_t getPrimitiveCount() const {
            return position_to_uuid_.size();
        }
 
        bool empty() const {
            return position_to_uuid_.empty();
        }
    };
 
    // ========== Debug Validation (compiled out in release builds) ==========
 
#ifndef NDEBUG
 
    class IndexValidator {
    private:
        const UUIDPositionMapper *mapper_;
 
    public:
        explicit IndexValidator(const UUIDPositionMapper *mapper) : mapper_(mapper) {
        }
 
        void validatePosition(size_t value, const char *context) const {
            if (value >= mapper_->getPrimitiveCount()) {
                throw std::runtime_error(std::string(context) + ": Position " + std::to_string(value) + " out of range [0, " + std::to_string(mapper_->getPrimitiveCount()) + ")");
            }
        }
 
        void warnPossibleMixup(size_t value, const char *context) const {
            if (value >= mapper_->getPrimitiveCount()) {
                PrimitiveUUID test_uuid{static_cast<uint>(value)};
                if (mapper_->isValidUUID(test_uuid)) {
                    std::cerr << "WARNING [" << context << "]: Value " << value << " looks like UUID but used as position\n";
                }
            }
        }
    };
 
#define VALIDATE_POSITION(mapper, pos, ctx) IndexValidator(mapper).validatePosition(pos, ctx)
 
#define WARN_UUID_MIXUP(mapper, val, ctx) IndexValidator(mapper).warnPossibleMixup(val, ctx)
 
#else
#define VALIDATE_POSITION(mapper, pos, ctx) ((void) 0)
#define WARN_UUID_MIXUP(mapper, val, ctx) ((void) 0)
#endif
 
} // namespace helios
 
#endif // HELIOS_INDEX_TYPES_H