Switch.h

//  trax track library
//  AD 2014 
//
//  "Doesn't anybody ever know ..."
//
//                      Our Lady Peace
//
// 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 "Connector.h"
 
namespace trax{
 
    class Location;

    struct NarrowSwitch : virtual Connector{

        static dclspc std::unique_ptr<NarrowSwitch> Make( unsigned char numBranches ) noexcept;
 
        enum SlotNames : char{
            slot_none = -1,
            slot_0 = 0,     
            slot_1,         
            slot_2,         
            slot_3,         
            slot_4,         
            slot_5,         
            slot_N = 125,   
            maxSlots
        };
 

        enum class Status : char{
            none = -1,
            go,                 
            branch  = 1,        
            branch1 = 1,        
            branch2 = 2,        
            branch3 = 3,
            branch4 = 4,
            bramch5 = 5,
            branchN = 124,
            maxBranches = 124,
            toggle,             
            change,     
            empty               
        };
 

        virtual Status Set( Status to, bool pulse = true ) = 0;
 
        using Connector::Set;
 

        virtual Status Get() const = 0;
 

        virtual void NarrowTrack( std::shared_ptr<TrackBuilder> pNarrowTrack, Track::EndType trackEnd ) = 0;
 

        virtual std::pair<std::shared_ptr<TrackBuilder>,Track::EndType> NarrowTrack() const = 0;
 

        virtual void ClearNarrowTrack() = 0;
 

        virtual void StraightTrack( std::shared_ptr<TrackBuilder> pStaightTrack, Track::EndType trackEnd ) = 0;
 

        virtual std::pair<std::shared_ptr<TrackBuilder>,Track::EndType> StraightTrack() const = 0;
 

        virtual void ClearStraightTrack() = 0;
 

        virtual void DivergedTrack( int divTrackID, std::shared_ptr<TrackBuilder> pDivergedTrack, Track::EndType trackEnd ) = 0;
 

        virtual std::pair<std::shared_ptr<TrackBuilder>,Track::EndType> DivergedTrack( int divTrackID ) const = 0;
 

        virtual void ClearDivergedTrack( int divTrackID ) = 0;
 

        virtual int CntDivergedTracks() const = 0;
 

        virtual Location Bifurcation() const = 0;
 

        virtual Jack& JackOnGo() noexcept = 0;
 

        virtual MultiPlug& PlugToGo() noexcept = 0;
 

        virtual Jack& JackOn( Status status ) = 0;
 

        virtual MultiPlug& PlugTo( Status status ) = 0;
 

        virtual Jack& JackOnDivergedTrack( int divTrackID ) = 0;
 

        virtual MultiPlug& PlugToDivergedTrack( int divTrackID ) = 0;
    };
 

    dclspc std::string ToString( NarrowSwitch::Status status );
 

    dclspc NarrowSwitch::Status ToNarrowSwitchStatus( const std::string& status );
 

    dclspc NarrowSwitch::Status NarrowSwitchStatusFrom( const std::string& socketName );
 

    struct Switch : virtual NarrowSwitch
    {
        static dclspc std::unique_ptr<Switch> Make() noexcept;
 
 
        static constexpr char slot_count = 3;
        static constexpr char status_count = 2;
        static constexpr char branch_count = 1;
 
        using NarrowSwitch::DivergedTrack;

        virtual void DivergedTrack( std::shared_ptr<TrackBuilder> pDivergedTrack, Track::EndType trackEnd ) = 0;
 

        virtual std::pair<std::shared_ptr<TrackBuilder>,Track::EndType> DivergedTrack() const = 0;
 
 
        using NarrowSwitch::ClearDivergedTrack;

        virtual void ClearDivergedTrack() = 0;
 

        virtual void SwapTracks() = 0;
 

        virtual bool IsNormal( bool bStopAtFirstTrack = true, Length maxDistance = infinite__length ) const = 0;
 

        virtual bool Normalize() = 0;
 

        virtual bool IsY( bool bStopAtFirstTrack = true, Length maxDistance = infinite__length, AnglePerLength margin = epsilon__angle / 80_m ) const = 0;
 

        virtual bool IsHorizontal( bool bStopAtFirstTrack = true, Length maxDistance = infinite__length ) const = 0;
 

        virtual bool IsVertical( bool bStopAtFirstTrack = true, Length maxDistance = infinite__length ) const = 0;
 

        virtual bool BranchLeftOrRight( bool bStopAtFirstTrack = true, Length maxDistance = infinite__length ) const = 0;
 

        virtual bool BranchUpOrDown( bool bStopAtFirstTrack = true, Length maxDistance = infinite__length ) const = 0;
 

        virtual Jack& JackOnBranch() noexcept = 0;
 

        virtual MultiPlug& PlugToBranch() noexcept = 0;
    };
 

    struct ThreeWaySwitch : virtual NarrowSwitch{

        static dclspc std::unique_ptr<ThreeWaySwitch> Make() noexcept;
 
 
        static constexpr char slot_count = 4;
        static constexpr char status_count = 3;
        static constexpr char branch_count = 2;
 

        virtual void DivergedTrack1( std::shared_ptr<TrackBuilder> pDivergedTrack1, Track::EndType trackEnd ) = 0;
 

        virtual std::pair<std::shared_ptr<TrackBuilder>,Track::EndType> DivergedTrack1() const = 0;
 

        virtual void ClearDivergedTrack1() = 0;
 

        virtual void DivergedTrack2( std::shared_ptr<TrackBuilder> pDivergedTrack2, Track::EndType trackEnd ) = 0;
 

        virtual std::pair<std::shared_ptr<TrackBuilder>,Track::EndType> DivergedTrack2() const = 0;
 

        virtual void ClearDivergedTrack2() = 0;
 

        virtual void SwapStraightWithDiverged() = 0;

        virtual void SwapStraightWithDiverged2() = 0;

        virtual void SwapDivergedWithDiverged2() = 0;
 

        virtual bool IsNormal() const = 0;
 

        virtual bool Normalize() = 0;
 

        virtual Status StatusToLeft() const = 0;
 

        virtual Status StatusToMiddle() const = 0;
 

        virtual Status StatusToRight() const = 0;
 

        virtual Jack& JackOnBranch1() noexcept = 0;
 

        virtual MultiPlug& PlugToBranch1() noexcept = 0;
 

        virtual Jack& JackOnBranch2() noexcept = 0;
 

        virtual MultiPlug& PlugToBranch2() noexcept = 0;
    };
 

    struct SingleSlipSwitch : virtual Connector{

        static dclspc std::unique_ptr<SingleSlipSwitch> Make() noexcept;
 
        enum SlotNames{
            slot_none = -1,
            slot_0 = 0, 
            slot_1,     
            slot_2,     
            slot_3,     
            slot_4,     
            slot_5,     
            slot_count
        };

        enum class Status{
            none = -1,          
            go,                 
            go1 = go,           
            go2,                
            branch,             
            count,              
            toggle,             
            change              
        };

        virtual Status Set( Status to, bool pulse = true ) = 0;
 
        using Connector::Set;
 

        virtual Status Get() const = 0;
 

        virtual void SetCenter( const spat::Frame<Length,One>& center ) = 0;
 

        virtual Jack& JackOn( Status status ) = 0;
 

        virtual MultiPlug& PlugTo( Status status ) = 0;
    };
 

    dclspc std::string ToString( SingleSlipSwitch::Status status );
 

    dclspc SingleSlipSwitch::Status ToSingleSlipSwitchStatus( const std::string& status );
 

    dclspc SingleSlipSwitch::Status SingleSlipSwitchStatusFrom( const std::string& socketName );
 

    struct DoubleSlipSwitch : virtual Connector{

        static dclspc std::unique_ptr<DoubleSlipSwitch> Make() noexcept;
 
 
        enum SlotNames{
            slot_none = -1,
            slot_0 = 0,     
            slot_1,         
            slot_2,         
            slot_3,         
            slot_4,         
            slot_5,         
            slot_6,         
            slot_7,         
            slot_8,         
            slot_9,         
            slot_10,        
            slot_11,        
            slot_count
        };
 

        enum class Status{
            none = -1,          
            go,                 
            go1 = go,           
            go2,                
            branch,             
            branch1 = branch,   
            branch2,            
            count,              
            toggle,             
            change              
        };

        virtual Status Set( Status to, bool pulse = true ) = 0;
 
        using Connector::Set;
 

        virtual Status Get() const = 0;
 

        virtual void SetCenter( const spat::Frame<Length,One>& center ) = 0;
 

        virtual Jack& JackOn( Status status ) = 0;
 

        virtual MultiPlug& PlugTo( Status status ) = 0;
    };
 

    dclspc std::string ToString( DoubleSlipSwitch::Status status );
 

    dclspc DoubleSlipSwitch::Status ToDoubleSlipSwitchStatus( const std::string& status );
 

    dclspc DoubleSlipSwitch::Status DoubleSlipSwitchStatusFrom( const std::string& socketName );
 
 
    struct SwitchAligned{
 
        virtual void Attach( std::shared_ptr<Connector> pSwitch ) = 0;
 
        virtual bool PreserveUpDirection() const = 0;
 
        virtual void PreserveUpDirection( bool bPreserveUpDirection ) = 0;
 
        virtual IDType GetSwitchRef() const = 0;
 
        virtual std::shared_ptr<Connector> GetSwitch() const = 0;
 
 
        virtual ~SwitchAligned() = default;
        SwitchAligned( const SwitchAligned& ) = delete;
        SwitchAligned( SwitchAligned&& ) = delete;
        SwitchAligned& operator=( const SwitchAligned& ) = delete;
        SwitchAligned& operator=( SwitchAligned&& ) = delete;
    protected:
        SwitchAligned() = default;
    };
 
}