Signal.h

//  trax track library
//  AD 2014 
//
//  "Voelker hoert die Signale,"
//   auf zum letzten Gefecht!"
//
//              Emil Luckhardt
//
// 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 "Identified.h"
#include "Track.h"
#include "Location.h"
 
namespace trax{
 
    struct Jack;
    struct MultiPlug;
    struct SocketRegistry;
 

    struct Signal : Identified<Signal>
    {
        virtual const char* TypeName() const noexcept = 0;
 

        enum class Status{
            none        = -1,
            stop        = 0,
            clear       = 1,
            slow,
            velocity0 = stop,
            velocity1 = clear,
            velocity2 = slow,
            velocity3,
            velocity4,
            velocity5,
            velocity6,
            velocity7,
            velocity8,
            velocity9,
            velocity10,
            velocity11,
            velocity12,
            velocityMax = velocity12,
            caution,
            doors_open,
            doors_close,
            uncouple,
            lights_on,
            jump,
            count,
            toggle,
            change
        };
 

        virtual Status Set( Status status, bool pulse = true ) = 0;
 

        virtual void Toggle( bool pulse = true ) = 0;
 

        virtual Status Get() const = 0;
 

        virtual int CountStatus() const = 0;
 

        virtual void Attach( TrackBuilder* pTrackBuilder ) noexcept = 0;
 

        virtual TrackBuilder* TrackAttached() const = 0;
 

        virtual void GetTrackRange( TrackRange& trackRange ) const = 0;
 

        virtual Location GetLocation() const = 0;
 

        virtual MultiPlug& PlugToToggle() = 0;
 

        virtual Jack& JackOnChange() = 0;
 

        virtual Jack& JackOn( Status status ) = 0;
 

        virtual Jack& JackOnChangeTo( Status status ) = 0;
 

        virtual MultiPlug& PlugTo( Status status ) = 0;
 

        virtual void RegisterSockets( SocketRegistry& modul ) = 0;
 

        virtual void UnregisterSockets( SocketRegistry& modul ) = 0;
    };
 
    dclspc constexpr bool IsVelocityStatus( Signal::Status status );
 

    struct VelocityControl : virtual Signal
    {
        static dclspc std::unique_ptr<VelocityControl> Make() noexcept;
 

        virtual bool AffectTravelVelocity( Status status, bool bTravel ) = 0;
 

        virtual bool AffectTravelVelocity( Status status ) const = 0;
 

        virtual void SetVelocity( Status status, Velocity velocityMin, Velocity velocityMax ) = 0;
 

        virtual void SetVelocity( Status status, Velocity velocity ) = 0;
 

        virtual void VelocityMin( Status status, Velocity velocityMin ) = 0;
 

        virtual void VelocityMax( Status status, Velocity velocityMax) = 0;
 

        virtual Velocity VelocityMin( Status status ) const = 0;
 

        virtual Velocity VelocityMax( Status status ) const = 0;
 

        virtual bool IsValidState( Status status ) const = 0;
 

        virtual void Remove( Status status ) = 0;
 

        virtual void Clear() = 0;
 

        virtual void StopDistance( Length distance ) = 0;
 

        virtual Length StopDistance() const = 0;
 

        virtual Jack& JackOnVelocity( Status status ) = 0;
 

        virtual MultiPlug& PlugToVelocity( Status status ) = 0;
    };
 
    struct Depot;

    struct JumpSite : virtual Signal{

        static dclspc std::unique_ptr<JumpSite> Make() noexcept;

        virtual void Target( const Location& target ) = 0;
 

        virtual void Target( std::shared_ptr<Depot> pDepot ) = 0;
 

        virtual bool IsTargetLocation() const = 0;
 

        virtual const Location& TargetLocation() const = 0;
 

        virtual std::shared_ptr<Depot> TargetDepot() const = 0;
 

        virtual Jack& JackOnJump() = 0;
 

        virtual Jack& JackOnChangeToJump() = 0;
 

        virtual MultiPlug& PlugToJump() = 0;
 

        virtual Jack& JackOnClear() = 0;
 

        virtual Jack& JackOnChangeToClear() = 0;
 

        virtual MultiPlug& PlugToClear() = 0;
    };
 

    struct TrackEndTransition : virtual Signal{

        static dclspc std::unique_ptr<TrackEndTransition> Make( Track* pToTrack, Track::EndType toEnd ) noexcept;

        virtual Track* From( Track::EndType& end ) const = 0;
 

        virtual Track* From() const = 0;
 

        virtual Track* To( Track::EndType& end ) const = 0;
 

        virtual Track* To() const = 0;
    };
 

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

    dclspc Signal::Status ToSignalStatus( const std::string& status );
 
 
    dclspc Signal::Status SignalStatusFrom( const std::string& socketName );
 
 

    struct SignalTarget{

        virtual bool Notify( const Signal& signal, Length distance ) = 0;
 

        virtual void Active( bool bActive ) noexcept = 0;
 

        virtual bool Active() const noexcept = 0;
 
 
        virtual ~SignalTarget() = default;
        SignalTarget( const SignalTarget& ) = delete;
        SignalTarget( SignalTarget&& ) = delete;
        SignalTarget& operator=( const SignalTarget& ) = delete;
        SignalTarget& operator=( SignalTarget&& ) = delete;
    protected:
        SignalTarget() = default;
    };

    struct SignalAligned{
 
        virtual void Attach( std::shared_ptr<Signal> pSignal, Length parameterOffset = 0_m ) = 0;
 
        virtual IDType GetSignalRef() const = 0;
 
        virtual Length ParameterOffset() const = 0;
 
        virtual void ParameterOffset( Length parameterOffset ) = 0;
 
        virtual bool PreserveUpDirection() const = 0;
 
        virtual void PreserveUpDirection( bool bPreserveUpDirection ) = 0;
 
        virtual ~SignalAligned() = default;
        SignalAligned( const SignalAligned& ) = delete;
        SignalAligned( SignalAligned&& ) = delete;
        SignalAligned& operator=( const SignalAligned& ) = delete;
        SignalAligned& operator=( SignalAligned&& ) = delete;
    protected:
        SignalAligned() = default;
    };
 
}