BlockSet.h

Aller à la documentation de ce fichier.

 
#pragma once
 
#include <array>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "Modules/Elements/ShuntingElements/StraightBlock.h"
#include "Modules/Elements/ShuntingElements/SwitchBlock.h"
 
struct BlockEndpoint
{
    size_t      frontierNodeId = 0;
    std::string neighbourId;
};
 
struct BlockSet
{
    // =========================================================================
    // Blocs — ownership exclusif
    // =========================================================================
 
    std::vector<std::unique_ptr<StraightBlock>> straights;
    std::vector<std::unique_ptr<SwitchBlock>>   switches;
 
    // =========================================================================
    // Index de lookup
    // =========================================================================
 
    std::unordered_map<size_t, std::vector<StraightBlock*>> straightsByNode;
 
    std::unordered_map<size_t, SwitchBlock*> switchByNode;
 
    std::unordered_map<size_t, StraightBlock*> straightByEndpointPair;
 
    std::unordered_map<size_t, std::vector<StraightBlock*>> straightByDirectedPair;
 
    // =========================================================================
    // Endpoints — index parallèles aux vecteurs straights / switches
    // =========================================================================
 
    std::vector<std::pair<BlockEndpoint, BlockEndpoint>> straightEndpoints;
 
    std::vector<std::array<BlockEndpoint, 3>>            switchEndpoints;
 
    // =========================================================================
    // Utilitaires
    // =========================================================================
 
    void clear()
    {
        straights.clear();               straights.shrink_to_fit();
        switches.clear();                switches.shrink_to_fit();
        straightsByNode.clear();
        switchByNode.clear();
        straightByEndpointPair.clear();
        straightByDirectedPair.clear();
        straightEndpoints.clear();
        switchEndpoints.clear();
    }
 
    [[nodiscard]] size_t totalCount() const
    {
        return straights.size() + switches.size();
    }
 
    void rebuildStraightIndex()
    {
        straightsByNode.clear();
        straightByEndpointPair.clear();
        straightByDirectedPair.clear();
 
        for (size_t i = 0; i < straights.size(); ++i)
        {
            if (i >= straightEndpoints.size()) break;
            StraightBlock* st = straights[i].get();
            const size_t   nA = straightEndpoints[i].first.frontierNodeId;
            const size_t   nB = straightEndpoints[i].second.frontierNodeId;
 
            // Saute les sous-blocs internes — pas de nœud frontière réel
            if (nA == SIZE_MAX || nB == SIZE_MAX) continue;
 
            straightsByNode[nA].push_back(st);
            straightsByNode[nB].push_back(st);
 
            const size_t a = std::min(nA, nB);
            const size_t b = std::max(nA, nB);
            straightByEndpointPair[(a + b) * (a + b + 1) / 2 + b] = st;
 
            // Multi-valué : push_back pour conserver les deux entrées crossover
            straightByDirectedPair[nA * 1'000'000ULL + nB].push_back(st);
            straightByDirectedPair[nB * 1'000'000ULL + nA].push_back(st);
        }
    }
};