LocalEventModel.hpp

#pragma once
 
#include "ConnectedSubsetTreeLocalizer.hpp"
#include "../utils/Common.hpp"
 
#include <array>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <initializer_list>
#include <limits>
#include <optional>
#include <set>
#include <span>
#include <stdexcept>
#include <utility>
#include <vector>
 
namespace mmcfilters::local_attributes {
 
namespace detail {
struct BinaryVisibilityStateAccess;
}
 
class ObservationWindow {
  public:
    static constexpr std::size_t maxNumOffsets = 32;
 
    explicit ObservationWindow(std::vector<WindowOffset> offsets) : offsets_(std::move(offsets)) { validate(); }
    ObservationWindow(std::initializer_list<WindowOffset> offsets) : ObservationWindow(std::vector<WindowOffset>(offsets)) {}
 
    template <std::size_t N>
    explicit ObservationWindow(const std::array<WindowOffset, N>& offsets) : ObservationWindow(std::vector<WindowOffset>(offsets.begin(), offsets.end())) {}
 
    [[nodiscard]] std::size_t size() const noexcept { return offsets_.size(); }
    [[nodiscard]] const WindowOffset& operator[](std::size_t index) const noexcept { return offsets_[index]; }
    [[nodiscard]] std::span<const WindowOffset> offsets() const noexcept { return offsets_; }
    [[nodiscard]] auto begin() const noexcept { return offsets_.begin(); }
    [[nodiscard]] auto end() const noexcept { return offsets_.end(); }
 
  private:
    void validate() const {
        if (offsets_.empty()) {
            throw std::invalid_argument("ObservationWindow requires at least one offset.");
        }
        if (offsets_.size() > maxNumOffsets) {
            throw std::invalid_argument("ObservationWindow supports at most 32 offsets.");
        }
 
        std::size_t numZeroOffsets = 0;
        for (std::size_t i = 0; i < offsets_.size(); ++i) {
            if (offsets_[i] == WindowOffset{}) {
                ++numZeroOffsets;
            }
            for (std::size_t j = 0; j < i; ++j) {
                if (offsets_[i] == offsets_[j]) {
                    throw std::invalid_argument("ObservationWindow does not permit duplicate offsets.");
                }
            }
        }
        if (numZeroOffsets != 1) {
            throw std::invalid_argument("ObservationWindow requires the zero offset exactly once.");
        }
    }
 
    std::vector<WindowOffset> offsets_; 
};
 
class BinaryVisibilityState {
  public:
    BinaryVisibilityState(std::uint32_t bits, std::size_t coordinateCount) : bits_(bits), coordinateCount_(coordinateCount) {
        if (coordinateCount_ == 0) {
            throw std::invalid_argument("BinaryVisibilityState requires at least one coordinate.");
        }
        if (coordinateCount_ > ObservationWindow::maxNumOffsets) {
            throw std::invalid_argument("BinaryVisibilityState supports at most 32 coordinates.");
        }
        const std::uint32_t validMask = coordinateCount_ == 32 ? std::numeric_limits<std::uint32_t>::max()
                                                               : (std::uint32_t{1} << coordinateCount_) - std::uint32_t{1};
        if ((bits_ & ~validMask) != 0) {
            throw std::invalid_argument("BinaryVisibilityState contains bits outside its coordinate domain.");
        }
    }
 
    [[nodiscard]] std::uint32_t bits() const noexcept { return bits_; }
    [[nodiscard]] std::size_t coordinateCount() const noexcept { return coordinateCount_; }
 
    [[nodiscard]] bool isVisible(std::size_t coordinate) const {
        if (coordinate >= coordinateCount_) {
            throw std::out_of_range("BinaryVisibilityState coordinate is outside the observation window.");
        }
        return (bits_ & (std::uint32_t{1} << coordinate)) != 0;
    }
 
    [[nodiscard]] BinaryVisibilityState withEnteringOffsets(std::uint32_t enteringOffsetMask) const {
        return BinaryVisibilityState(bits_ | enteringOffsetMask, coordinateCount_);
    }
 
    friend bool operator==(const BinaryVisibilityState& lhs, const BinaryVisibilityState& rhs) = default;
 
  private:
    struct UncheckedConstructionTag {};
 
    BinaryVisibilityState(UncheckedConstructionTag, std::uint32_t bits, std::size_t coordinateCount) noexcept
        : bits_(bits), coordinateCount_(coordinateCount) {}
 
    std::uint32_t bits_ = 0;             
    std::size_t coordinateCount_ = 0;    
 
    friend struct detail::BinaryVisibilityStateAccess;
};
 
struct AnchoredEntryMask {
    NodeId node = InvalidNode;                 
    std::uint32_t enteringOffsetMask = 0;      
 
    friend bool operator==(const AnchoredEntryMask& lhs, const AnchoredEntryMask& rhs) = default;
};
 
class AnchoredEntryMap {
  public:
    AnchoredEntryMap(PixelId anchorPixel, std::vector<std::optional<NodeId>> entries) : anchorPixel_(anchorPixel), entries_(std::move(entries)) {}
 
    [[nodiscard]] PixelId anchorPixel() const noexcept { return anchorPixel_; }
    [[nodiscard]] std::size_t size() const noexcept { return entries_.size(); }
    [[nodiscard]] const std::optional<NodeId>& operator[](std::size_t coordinate) const noexcept { return entries_[coordinate]; }
    [[nodiscard]] std::span<const std::optional<NodeId>> entries() const noexcept { return entries_; }
 
  private:
    PixelId anchorPixel_ = InvalidPixel;                 
    std::vector<std::optional<NodeId>> entries_;         
};
 
using AnchorBranch = std::vector<NodeId>;
using AnchoredEntrySet = std::set<NodeId>;
using OrderedAnchoredEntries = std::vector<AnchoredEntryMask>;
 
template <class Value> struct EventDelta {
    PixelId anchorPixel = InvalidPixel; 
    NodeId anchoredEntry = InvalidNode; 
    Value value{};                      
 
    friend bool operator==(const EventDelta& lhs, const EventDelta& rhs) = default;
};
 
template <class Value> struct LocalAttributeIncrement {
    NodeId node = InvalidNode; 
    Value value{};             
 
    friend bool operator==(const LocalAttributeIncrement& lhs, const LocalAttributeIncrement& rhs) = default;
};
 
template <class Value> struct NodeAttribute {
    NodeId node = InvalidNode; 
    Value value{};             
 
    friend bool operator==(const NodeAttribute& lhs, const NodeAttribute& rhs) = default;
};
 
template <class Decision>
concept LocalDecision = requires(const Decision& decision, BinaryVisibilityState state) {
    typename Decision::Value;
    { decision.evaluateLocalDecision(state) } -> std::same_as<typename Decision::Value>;
};
 
template <class Algebra, class Value>
concept EventAlgebra = requires(const Algebra& algebra, Value& target, const Value& source) {
    { algebra.additiveIdentity() } -> std::same_as<Value>;
    { algebra.addAssign(target, source) } -> std::same_as<void>;
    { algebra.subtractAssign(target, source) } -> std::same_as<void>;
};
 
} // namespace mmcfilters::local_attributes