Fleet.h

//  trax track library
//  AD 2014 
//
//  "If you want to be a hero
//   well just follow me."
//
//              John Lennon
// 
// 
// 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 "trax/Configuration.h"
#include "trax/collections/Collection.h"
 
#include "trax/Simulated.h"
//#include "trax/collections/CollectionDecorator.h"
 
namespace trax{
 
//  struct DepotCollection;
//  struct Materials;
    struct Train;
 

    struct Fleet : Collection<Fleet,Train>,
                   Simulated
    {
        static dclspc std::unique_ptr<Fleet> Make() noexcept;
 

        //virtual void Couple( const Bogie::Coupling& coupling ) const = 0;
 

        //virtual Train* GetTrain( const RailRunner* pRailRunner ) const = 0;
 

        //virtual std::shared_ptr<RailRunner> GetAny( const std::string& name ) const = 0;
 

        virtual void EnableTrainGeneration( bool bEnable = true ) noexcept = 0;
 

        virtual bool IsTrainGenerationEnabled() const noexcept = 0;
 
 
 
 

        //virtual std::shared_ptr<DepotCollection> Attach( std::shared_ptr<DepotCollection> pDepotCollection ) = 0;
 

        //virtual DepotCollection* GetDepotCollection() const noexcept = 0;
 

        //virtual void Hit( const Bogie* pBogie, const spat::VectorBundle<Real>& hitData, int filterCombination, const Materials& materialCombination ) = 0;
    };
 

    //void AddRecursive( Fleet& fleet, std::shared_ptr<RailRunner> pRailRunner );
 

    //void RemoveRecursiveFrom( Fleet& fleet, RailRunner& railRunner );
 

/*  class FleetDecorator : public CollectionDecorator<Decorator<Fleet>>{
    public:
        typedef Fleet ComponentType;
 

        FleetDecorator( std::shared_ptr<Fleet> pFleet )
            : CollectionDecorator<Decorator<Fleet>>{ pFleet }
        {}
        

        const Module* GetModule() const override{
            return m_pComponent->GetModule();
        }
 
        void Update() override{
            return m_pComponent->Update();
        }
 
        void Couple( const Bogie::Coupling& coupling ) const override{
            return m_pComponent->Couple( coupling );
        }
 
        Train* GetTrain( const RailRunner* pRailRunner ) const override{
            return m_pComponent->GetTrain( pRailRunner );
        }
 
        std::shared_ptr<RailRunner> GetAny( const std::string& name ) const override{
            return m_pComponent->GetAny( name );
        }
 
        void EnableDerailing( bool bEnable ) override{
            return m_pComponent->EnableDerailing( bEnable );
        }
 
        bool IsDerailingEnabled() const override{
            return m_pComponent->IsDerailingEnabled();
        }
 
        void EnableCouplingForceLimits( bool bEnable ) override{
            return m_pComponent->EnableCouplingForceLimits( bEnable );
        }
 
        bool IsCouplingForceLimitsEnabled() const override{
            return m_pComponent->IsCouplingForceLimitsEnabled();
        }
 
        std::shared_ptr<DepotCollection> Attach( std::shared_ptr<DepotCollection> pDepotCollection ) override{
            return m_pComponent->Attach( pDepotCollection );
        }
 
        DepotCollection* GetDepotCollection() const noexcept override{
            return m_pComponent->GetDepotCollection();
        }
 
        void Hit( const Bogie* pBogie, const spat::VectorBundle<Real>& hitData, int filterCombination, const Materials& materialCombination ) override{
            return m_pComponent->Hit(pBogie,hitData,filterCombination,materialCombination);
        }
    };*/
}