SwitchBlock.h

Aller à la documentation de ce fichier.

 
#pragma once
 
#include <array>
#include <optional>
#include <sstream>
#include <string>
#include <vector>
 
#include "Engine/Core/Coordinates/CoordinateLatLon.h"
#include "Engine/Core/Coordinates/CoordinateXY.h"
#include "ShuntingElement.h"
 
enum class ActiveBranch { NORMAL, DEVIATION };
 
 
class SwitchBlock : public ShuntingElement
{
public:
 
    // =========================================================================
    // Construction
    // =========================================================================
 
    SwitchBlock() = default;
 
    SwitchBlock(std::string              switchId,
        CoordinateLatLon         junctionWGS84,
        std::vector<std::string> branchIds = {});
 
    // =========================================================================
    // Interface ShuntingElement
    // =========================================================================
 
    [[nodiscard]] std::string            getId()    const override { return m_id; }
    [[nodiscard]] ElementType getType()  const override { return ElementType::SWITCH; }
    [[nodiscard]] ShuntingState          getState() const override { return m_state; }
 
    void setState(ShuntingState state) { m_state = state; }
 
    // =========================================================================
    // Requêtes — géométrie
    // =========================================================================
 
    [[nodiscard]] const CoordinateLatLon& getJunctionWGS84() const { return m_junctionWGS84; }
 
    [[nodiscard]] const CoordinateXY& getJunctionUTM() const { return m_junctionUTM; }
 
    [[nodiscard]] const std::optional<CoordinateLatLon>& getTipOnRoot()      const { return m_tipOnRoot; }
 
    [[nodiscard]] const std::optional<CoordinateLatLon>& getTipOnNormal()    const { return m_tipOnNormal; }
 
    [[nodiscard]] const std::optional<CoordinateLatLon>& getTipOnDeviation() const { return m_tipOnDeviation; }
 
    [[nodiscard]] const std::vector<CoordinateLatLon>& getAbsorbedNormalCoordinates()    const { return m_absorbedNormalCoords; }
 
    [[nodiscard]] const std::vector<CoordinateLatLon>& getAbsorbedDeviationCoordinates() const { return m_absorbedDeviationCoords; }
 
    [[nodiscard]] const std::vector<CoordinateXY>& getAbsorbedNormalCoordsUTM()     const { return m_absorbedNormalCoordsUTM; }
 
    [[nodiscard]] const std::vector<CoordinateXY>& getAbsorbedDeviationCoordsUTM()  const { return m_absorbedDeviationCoordsUTM; }
 
    [[nodiscard]] const std::optional<double>& getTotalLengthMeters() const { return m_totalLengthMeters; }
 
    // =========================================================================
    // Requêtes — topologie IDs
    // =========================================================================
 
    [[nodiscard]] const std::vector<std::string>& getBranchIds() const { return m_branchIds; }
 
    [[nodiscard]] bool isOriented() const { return m_branches.root != nullptr; }
 
    [[nodiscard]] const std::optional<std::string>& getRootBranchId()      const { return m_rootBranchId; }
 
    [[nodiscard]] const std::optional<std::string>& getNormalBranchId()    const { return m_normalBranchId; }
 
    [[nodiscard]] const std::optional<std::string>& getDeviationBranchId() const { return m_deviationBranchId; }
 
    [[nodiscard]] const std::optional<std::string>& getDoubleOnNormal()    const { return m_doubleOnNormal; }
 
    [[nodiscard]] const std::optional<std::string>& getDoubleOnDeviation() const { return m_doubleOnDeviation; }
 
    [[nodiscard]] bool isDouble() const
    {
        return m_doubleOnNormal.has_value() || m_doubleOnDeviation.has_value();
    }
 
    // =========================================================================
    // Requêtes — pointeurs résolus
    // =========================================================================
 
    struct SwitchBranches
    {
        ShuntingElement* root = nullptr;  
        ShuntingElement* normal = nullptr;  
        ShuntingElement* deviation = nullptr;  
    };
 
    [[nodiscard]] const SwitchBranches& getBranches() const { return m_branches; }
 
    [[nodiscard]] ShuntingElement* getRootBlock()      const { return m_branches.root; }
 
    [[nodiscard]] ShuntingElement* getNormalBlock()    const { return m_branches.normal; }
 
    [[nodiscard]] ShuntingElement* getDeviationBlock() const { return m_branches.deviation; }
 
    [[nodiscard]] SwitchBlock* getPartnerOnNormal() const
    {
        return m_doubleOnNormal
            ? static_cast<SwitchBlock*>(m_branches.normal)
            : nullptr;
    }
 
    [[nodiscard]] SwitchBlock* getPartnerOnDeviation() const
    {
        return m_doubleOnDeviation
            ? static_cast<SwitchBlock*>(m_branches.deviation)
            : nullptr;
    }
 
    // =========================================================================
    // Requêtes — état opérationnel
    // =========================================================================
 
    [[nodiscard]] ActiveBranch getActiveBranch() const { return m_activeBranch; }
 
    [[nodiscard]] bool isDeviationActive() const { return m_activeBranch == ActiveBranch::DEVIATION; }
 
    [[nodiscard]] std::string activeBranchToString() const
    {
        return m_activeBranch == ActiveBranch::DEVIATION ? "DEVIATION" : "NORMAL";
    }
 
    [[nodiscard]] std::string toString() const;
 
    // =========================================================================
    // Mutations — identifiant
    // =========================================================================
 
    void setId(std::string id) { m_id = std::move(id); }
 
    // =========================================================================
    // Mutations — géométrie
    // =========================================================================
 
    void setRootBranchId(std::string id) { m_rootBranchId = std::move(id); }
    void setNormalBranchId(std::string id) { m_normalBranchId = std::move(id); }
    void setDeviationBranchId(std::string id) { m_deviationBranchId = std::move(id); }
 
    [[nodiscard]] const std::optional<CoordinateXY>& getTipOnRootUTM() const
    {
        return m_tipOnRootUTM;
    }
 
    [[nodiscard]] const std::optional<CoordinateXY>& getTipOnNormalUTM() const
    {
        return m_tipOnNormalUTM;
    }
 
    [[nodiscard]] const std::optional<CoordinateXY>& getTipOnDeviationUTM() const
    {
        return m_tipOnDeviationUTM;
    }
 
    // SwitchBlock.h — section mutations géométrie
 
    void setTipsUTM(std::optional<CoordinateXY> tipRoot,
        std::optional<CoordinateXY> tipNormal,
        std::optional<CoordinateXY> tipDeviation);
 
    void setJunctionWGS84(CoordinateLatLon coord) { m_junctionWGS84 = coord; }
 
    void setJunctionUTM(CoordinateXY coord) { m_junctionUTM = coord; }
 
    void setTips(std::optional<CoordinateLatLon> tipRoot,
        std::optional<CoordinateLatLon> tipNormal,
        std::optional<CoordinateLatLon> tipDeviation);
 
    void setAbsorbedCoords(const std::string& side,
        std::vector<CoordinateLatLon> coords);
 
    // =========================================================================
    // Mutations — topologie IDs
    // =========================================================================
 
    void addBranchId(const std::string& id);
 
    void orient(std::string rootId, std::string normalId, std::string deviationId);
 
    void swapNormalDeviation();
 
    void absorbLink(const std::string& linkId,
        const std::string& partnerId,
        std::vector<CoordinateLatLon> linkCoordsWGS84,
        std::vector<CoordinateXY>     linkCoordsUTM);
 
    void replaceBranchPointer(ShuntingElement* oldElem, ShuntingElement* newElem);
 
    void computeTotalLength();
 
    // =========================================================================
    // Mutations — pointeurs résolus (Phase9_RepositoryTransfer)
    // =========================================================================
 
    void setRootPointer(ShuntingElement* elem) { m_branches.root = elem; }
 
    void setNormalPointer(ShuntingElement* elem) { m_branches.normal = elem; }
 
    void setDeviationPointer(ShuntingElement* elem) { m_branches.deviation = elem; }
 
    void setBranchPointers(SwitchBranches branches);
 
    // =========================================================================
    // Mutations — état opérationnel
    // =========================================================================
 
    void setActiveBranch(ActiveBranch branch, bool propagate = true);
 
    ActiveBranch toggleActiveBranch(bool propagate = true);
 
private:
 
    // =========================================================================
    // Champs — géométrie
    // =========================================================================
 
    CoordinateLatLon m_junctionWGS84;
 
    CoordinateXY m_junctionUTM;
 
    std::optional<CoordinateLatLon> m_tipOnRoot;
 
    std::optional<CoordinateLatLon> m_tipOnNormal;
 
    std::optional<CoordinateLatLon> m_tipOnDeviation;
 
    std::optional<double> m_totalLengthMeters;
 
    std::vector<CoordinateLatLon> m_absorbedNormalCoords;
 
    std::vector<CoordinateLatLon> m_absorbedDeviationCoords;
 
    std::vector<CoordinateXY>     m_absorbedNormalCoordsUTM;
    std::vector<CoordinateXY>     m_absorbedDeviationCoordsUTM;
 
    std::optional<CoordinateXY> m_tipOnRootUTM;
 
    std::optional<CoordinateXY> m_tipOnNormalUTM;
 
    std::optional<CoordinateXY> m_tipOnDeviationUTM;
 
    // =========================================================================
    // Champs — topologie IDs
    // =========================================================================
 
    std::vector<std::string> m_branchIds;
 
    std::optional<std::string> m_rootBranchId;
 
    std::optional<std::string> m_normalBranchId;
 
    std::optional<std::string> m_deviationBranchId;
 
    std::optional<std::string> m_doubleOnNormal;
 
    std::optional<std::string> m_doubleOnDeviation;
 
    // =========================================================================
    // Champs — pointeurs résolus
    // =========================================================================
 
    SwitchBranches m_branches;
 
    // =========================================================================
    // Champs — état opérationnel
    // =========================================================================
 
    ActiveBranch m_activeBranch = ActiveBranch::NORMAL;
 
    // =========================================================================
    // Helpers privés
    // =========================================================================
 
    static double haversineDistanceMeters(const CoordinateLatLon& a,
        const CoordinateLatLon& b);
};