TrackLocation.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 "IDType.h"
#include "Units.h"
#include "Orientation.h"
 
#include "common/Interval.h"
 
namespace trax{

    struct TrackLocation
    {
        Length      parameter;      
        Orientation orientation;    
 

        TrackLocation() noexcept
            : parameter{0}, orientation{ Orientation::Value::para }{}
        explicit TrackLocation( Length param ) noexcept
            : parameter{ param }, orientation{ Orientation::Value::para }{}
        explicit TrackLocation( Length param, bool orient ) noexcept
            : parameter{param}, orientation{orient}{}
        TrackLocation( Length param, Orientation::Value orient ) noexcept
            : parameter{param}, orientation{orient}{}
        TrackLocation( Length param, Orientation orient ) noexcept
            : parameter{ param }, orientation{ orient }{}
 
 
        bool operator==( const TrackLocation& tl ) const noexcept{
            return parameter == tl.parameter && orientation == tl.orientation;
        }
 
        bool operator!=( const TrackLocation& tl ) const noexcept{
            return !operator==( tl );
        }
 

        bool Equals( const TrackLocation& loc, Length _epsilon ) const noexcept{
            return  orientation == loc.orientation &&
                    common::Equals( parameter, loc.parameter, _epsilon );
        }
 

        void Flip() noexcept{
            orientation.Flip();
        }
    };
 

    inline void operator+=( TrackLocation& tl, Length dp ) noexcept;
 

    inline void operator-=( TrackLocation& tl, Length dp ) noexcept;
 

    struct TrackLocationRef
    {
        TrackLocation   location;   
        IDType          refid;      
 

        TrackLocationRef() noexcept = default;
        explicit TrackLocationRef( const TrackLocation& tl ) noexcept
            : location{tl} 
        {}
        TrackLocationRef( Length param, bool orient, IDType id ) noexcept
            : location{ param, orient },
            refid{id}
        {}
 
 
        bool operator==( const TrackLocationRef& tlr ) const noexcept{
            return location == tlr.location && refid == tlr.refid;
        }
 
        bool operator!=( const TrackLocationRef& tlr ) const noexcept{
            return !operator==( tlr );
        }
    };
 

    struct TrackRange{
        common::Interval<Length> range; 
        IDType refid;                   

        TrackRange() noexcept = default;
        explicit TrackRange( IDType id ) noexcept
            :   refid{id} 
        {}
        TrackRange( IDType id, trax::Length near_, trax::Length far_ ) noexcept
            :   range{near_,far_},
                refid{id}
        {}
        explicit TrackRange( const common::Interval<trax::Length>& interval ) noexcept
            :   range{interval}
        {}
 
 
        bool operator==( const TrackRange& tr ) const noexcept{
            return range == tr.range && refid == tr.refid;
        }
 
        bool operator!=( const TrackRange& tr ) const noexcept{
            return !operator==( tr );
        }
    };
 
 
//inlines:
inline void operator+=( TrackLocation& tl, Length dp ) noexcept{
    if( tl.orientation )
        tl.parameter += dp;
    else
        tl.parameter -= dp;
}
 
inline void operator-=( TrackLocation& tl, Length dp ) noexcept{
    if( tl.orientation )
        tl.parameter -= dp;
    else
        tl.parameter += dp;
}
 
}