Tracer.hpp

/*
Copyright (c) 2017-2026,
Battelle Memorial Institute; Lawrence Livermore National Security, LLC; Alliance for Energy
Innovation LLC.  See the top-level NOTICE for additional details. All rights reserved.
SPDX-License-Identifier: BSD-3-Clause
*/
#pragma once
 
#include "../application_api/Endpoints.hpp"
#include "../application_api/Subscriptions.hpp"
#include "helicsApp.hpp"
 
#include <deque>
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
namespace helics {
class CloningFilter;
 
namespace apps {
    class HELICS_CXX_EXPORT Tracer: public App {
      public:
        explicit Tracer(std::string_view name, FederateInfo& fedInfo);
        explicit Tracer(std::vector<std::string> args);
 
        Tracer(int argc, char* argv[]);
 
        Tracer(std::string_view name,
               const std::shared_ptr<Core>& core,
               const FederateInfo& fedInfo);
 
        Tracer(std::string_view name, CoreApp& core, const FederateInfo& fedInfo);
 
        Tracer(std::string_view name, const std::string& configString);
        Tracer(Tracer&& other_tracer) = default;
        Tracer& operator=(Tracer&& tracer) = default;
        ~Tracer();
        virtual void runTo(Time runToTime) override;
        void addSubscription(std::string_view key);
        void addEndpoint(std::string_view endpoint);
        void addSourceEndpointClone(std::string_view sourceEndpoint);
        void addDestEndpointClone(std::string_view destEndpoint);
        void addCapture(std::string_view captureDesc);
 
        void setClonedMessageCallback(std::function<void(Time, std::unique_ptr<Message>)> callback)
        {
            clonedMessageCallback = std::move(callback);
        }
        void setEndpointMessageCallback(
            std::function<void(Time, std::string_view, std::unique_ptr<Message>)> callback)
        {
            endpointMessageCallback = std::move(callback);
        }
        void
            setValueCallback(std::function<void(Time, std::string_view, std::string_view)> callback)
        {
            valueCallback = std::move(callback);
        }
        void enableTextOutput() { printMessage = true; }
        void disableTextOutput() { printMessage = false; }
 
      private:
        void initialSetup();
        virtual void loadJsonFile(const std::string& jsonString,
                                  bool enableFederateInterfaceRegistration) override;
        virtual void loadTextFile(const std::string& textFile) override;
 
        virtual void initialize() override;
        void generateInterfaces();
        void captureForCurrentTime(Time currentTime, int iteration = 0);
        void loadCaptureInterfaces();
 
        std::shared_ptr<helicsCLI11App> buildArgParserApp();
        void processArgs();
 
      protected:
        bool printMessage = false;
        bool allow_iteration =
            false;  
        bool skiplog = false;  
        std::unique_ptr<CloningFilter> cFilt;  
 
        std::deque<Input> subscriptions;  
        std::map<std::string_view, int> subkeys;  
 
        std::deque<Endpoint> endpoints;  
        std::map<std::string_view, int> eptNames;  
        std::unique_ptr<Endpoint> cloneEndpoint;  
        std::vector<std::string> captureInterfaces;  
 
        std::function<void(Time, std::unique_ptr<Message>)> clonedMessageCallback;
        std::function<void(Time, std::string_view, std::unique_ptr<Message>)>
            endpointMessageCallback;
        std::function<void(Time, std::string_view, std::string_view)> valueCallback;
    };
 
}  // namespace apps
}  // namespace helics