TrackSystem.h

//  trax track library
//  AD 2013 
//
//  "the resolution of all the fruitless searches"
//
//                              Peter Gabriel
//
// Copyright (c) 2025 Trend Redaktions- und Verlagsgesellschaft mbH
// Copyright (c) 2019 Marc-Michael Horstmann
//
// Permission is hereby granted to any person obtaining a copy of this software 
// and associated source code (the "Software"), to use, view, and study the 
// Software for personal or internal business purposes, subject to the following 
// conditions:
//
// 1. Redistribution, modification, sublicensing, or commercial use of the 
// Software is NOT permitted without prior written consent from the copyright 
// holder.
//
// 2. The Software is provided "AS IS", without warranty of any kind, express 
// or implied.
//
// 3. All copies of the Software must retain this license notice.
//
// For further information, please contact: horstmann.marc@trendverlag.de
 
#pragma once
 
#include "Collection.h"
#include "CollectionDecorator.h"
#include "trax/Identified.h"
 
#include "trax/Simulated.h"
#include "trax/Track.h"
#include "trax/Location.h"
 
namespace spat{
    template<typename> struct Sphere;
}
 
namespace trax{
 
    struct ConnectorCollection;
    //struct Module;
    struct TrackCollectionContainer;

    struct TrackSystem :    Collection<TrackSystem,TrackBuilder>,
                            Simulated,
                            Identified<TrackSystem>
    {
        static dclspc std::shared_ptr<TrackSystem> Make() noexcept;
 
        static dclspc std::shared_ptr<TrackSystem> Make( 
            std::unique_ptr<TrackCollectionContainer> pTrackCollectionContainer ) noexcept;
 
        static dclspc std::shared_ptr<TrackSystem> Make( 
            std::unique_ptr<TrackCollectionContainer> pTrackCollectionContainer,
            std::unique_ptr<ConnectorCollection> pConnectorCollection ) noexcept;
 

        virtual std::shared_ptr<TrackSystem> This() const noexcept = 0;
 
 
        // TrackCollections:

        virtual IDType CreateCollection( IDType id = 0 ) = 0;
 

        virtual void RemoveCollection( IDType id ) = 0;
 

        virtual void SetCollectionFrame( IDType id, const spat::Frame<Length,One>& frame ) = 0;
 

        virtual const spat::Frame<Length,One>& GetCollectionFrame( IDType id ) const = 0;
 

        virtual IDType SetActiveCollection( IDType id ) = 0;
 

        virtual IDType GetActiveCollection() const = 0;
 
 
        virtual std::shared_ptr<TrackCollectionContainer> SetTrackCollectionContainer( std::shared_ptr<TrackCollectionContainer> pTrackCollectionContainer ) = 0;
 

        virtual std::shared_ptr<TrackCollectionContainer> GetCollectionContainer() const = 0;
 

        virtual std::shared_ptr<ConnectorCollection> SetConnectorCollection( std::shared_ptr<ConnectorCollection> pConnectorCollection ) = 0;
 

        virtual ConnectorCollection* GetConnectorCollection() const = 0;
 

        virtual void Couple( std::pair<std::shared_ptr<TrackBuilder>,Track::EndType> trackEnd1, std::pair<std::shared_ptr<TrackBuilder>,Track::EndType> trackEnd2 ) const = 0;
 
        virtual void Couple( const Track::Coupling& coupling, bool bUncoupledOnly = false ) const = 0;
 

        virtual std::shared_ptr<Sensor> GetSensor( IDType id, TrackLocation* pTrackLocation ) const = 0;
 

        virtual Length CalculateGapSize( const Track::End& theOne, const Track::End& theOther ) const = 0;
 

        virtual std::vector<Track::End> GetUncoupledIn( const spat::Sphere<Length>& area ) const = 0;
 

        virtual void Connection( Track::Coupling& coupling ) const = 0;
 
        virtual void Connection( const Track::End& end, Track::End& coupled ) const = 0;

        virtual void Connection( const Track::Coupling& couplings, Track::Coupling& active ) const = 0;
        

        virtual void CoupleAll( Length maxDistance = 1_m, Angle maxKink = pi, bool bSilent = true ) = 0;
 

        virtual void DeCoupleAll() = 0;
    };
    

    std::vector<std::tuple<std::shared_ptr<TrackBuilder>,Track::EndType,Length>> dclspc FindTrackEnds( const TrackSystem& system, const spat::Sphere<Length>& area, bool sort = false );
 

    std::vector<std::pair<Location,Length>> dclspc FindTrackLocations( const TrackSystem& system, const spat::Sphere<Length>& area, bool sort = false );
 
    Location dclspc FindTrackLocation( const TrackSystem& system, const spat::Sphere<Length>& area );
    

    std::vector<std::pair<Location,Length>> dclspc FindTrackLocations( const TrackSystem& system, const spat::VectorBundle<Length,One>& ray, Length gauge = 0_m, bool sort = false );
    

    class TrackSystemDecorator : public CollectionDecorator<SimulatedDecorator<ObjectIDDecorator<Decorator<TrackSystem>>>>{
    public:

        typedef TrackSystem ComponentType;
 
 
        TrackSystemDecorator() = delete;
        
        TrackSystemDecorator( std::shared_ptr<TrackSystem> pTrackSystem )
            : CollectionDecorator<SimulatedDecorator<ObjectIDDecorator<Decorator<TrackSystem>>>>{ pTrackSystem }
        {}
 

        std::shared_ptr<TrackSystem> This() const noexcept override{
            return m_pComponent->This();
        }
 
        IDType CreateCollection( IDType id = 0 ) override{
            return m_pComponent->CreateCollection(id);
        }
 
        void RemoveCollection( IDType id ) override{
            return m_pComponent->RemoveCollection(id);
        }
 
        void SetCollectionFrame( IDType id, const spat::Frame<Length,One>& frame ) override{
            return m_pComponent->SetCollectionFrame(id,frame);
        }
 
        const spat::Frame<Length,One>& GetCollectionFrame( IDType id ) const override{
            return m_pComponent->GetCollectionFrame(id);
        }
 
        IDType SetActiveCollection( IDType id ) override{
            return m_pComponent->SetActiveCollection(id);
        }
 
        IDType GetActiveCollection() const override{
            return m_pComponent->GetActiveCollection();
        }
 
        std::shared_ptr<TrackCollectionContainer> GetCollectionContainer() const override{
            return m_pComponent->GetCollectionContainer();
        }
 
        std::shared_ptr<TrackCollectionContainer> SetTrackCollectionContainer( std::shared_ptr<TrackCollectionContainer> pTrackCollectionContainer ) override{
            return m_pComponent->SetTrackCollectionContainer( pTrackCollectionContainer );
        }
        
        std::shared_ptr<ConnectorCollection> SetConnectorCollection( std::shared_ptr<ConnectorCollection> pConnectorCollection ) override{
            return m_pComponent->SetConnectorCollection( pConnectorCollection );
        }
 
        ConnectorCollection* GetConnectorCollection() const override{
            return m_pComponent->GetConnectorCollection();
        }
 
        void Couple( std::pair<std::shared_ptr<TrackBuilder>,Track::EndType> trackEnd1, std::pair<std::shared_ptr<TrackBuilder>,Track::EndType> trackEnd2 ) const override{
            return m_pComponent->Couple( trackEnd1, trackEnd2 );
        }
 
        void Couple( const Track::Coupling& coupling, bool bUncoupledOnly = false ) const override{
            return m_pComponent->Couple( coupling, bUncoupledOnly );
        }
 
        std::shared_ptr<Sensor> GetSensor( IDType id, TrackLocation* pTrackLocation ) const override{
            return m_pComponent->GetSensor( id, pTrackLocation );
        }
 
        Length CalculateGapSize( const Track::End& theOne, const Track::End& theOther ) const override{
            return m_pComponent->CalculateGapSize( theOne, theOther );
        }
 
        std::vector<Track::End> GetUncoupledIn( const spat::Sphere<Length>& area ) const override{
            return m_pComponent->GetUncoupledIn( area );
        }
 
        void Connection( Track::Coupling& coupling ) const override{
            return m_pComponent->Connection(coupling);
        }
 
        void Connection( const Track::End& end, Track::End& coupled ) const override{
            return m_pComponent->Connection(end,coupled);
        }
 
        void Connection( const Track::Coupling& couplings, Track::Coupling& active ) const override{
            return m_pComponent->Connection(couplings,active);
        }
 
        void DeCoupleAll() override{
            return m_pComponent->DeCoupleAll();
        }

    };
}