Recorder.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 <map>
#include <memory>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
namespace helics {
class CloningFilter;
 
namespace apps {
    class HELICS_CXX_EXPORT Recorder: public App {
      public:
        Recorder(std::string_view name, FederateInfo& fedInfo);
        explicit Recorder(std::vector<std::string> args);
        Recorder(int argc, char* argv[]);
 
        Recorder(std::string_view name,
                 const std::shared_ptr<Core>& core,
                 const FederateInfo& fedInfo);
        Recorder(std::string_view name, CoreApp& core, const FederateInfo& fedInfo);
        Recorder(std::string_view name, const std::string& jsonString);
        Recorder(Recorder&& other_recorder) = default;
        Recorder& operator=(Recorder&& other_recorder) = default;
        ~Recorder();
        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 saveFile(const std::string& filename);
        auto pointCount() const { return points.size(); }
        auto messageCount() const { return messages.size(); }
        std::tuple<Time, std::string_view, std::string> getValue(std::size_t index) const;
        std::unique_ptr<Message> getMessage(std::size_t index) const;
 
      private:
        void initialSetup();
        virtual void loadJsonFile(const std::string& jsonString,
                                  bool enableFederateInterfaceRegistration) override;
        virtual void loadTextFile(const std::string& textFile) override;
        void writeJsonFile(const std::string& filename);
        void writeTextFile(const std::string& filename);
 
        virtual void initialize() override;
        void generateInterfaces();
        void captureForCurrentTime(Time currentTime, int iteration = 0);
        void loadCaptureInterfaces();
 
        std::shared_ptr<helicsCLI11App> buildArgParserApp();
        void processArgs();
 
      protected:
        class ValueCapture {
          public:
            helics::Time time;
            int index{-1};
            int16_t iteration{0};
            bool first{false};
            std::string value;
            ValueCapture() = default;
            ValueCapture(helics::Time t1, int id1, std::string_view val):
                time(t1), index(id1), value(val)
            {
            }
        };
 
        class ValueStats {
          public:
            helics::Time time{helics::Time::minVal()};
            std::string lastVal;
            std::string key;
            int cnt{0};
        };
 
        bool allow_iteration{false};  
        bool verbose{false};  
        Time nextPrintTimeStep{
            helics::timeZero};  
        std::unique_ptr<CloningFilter> cFilt;  
        std::vector<ValueCapture> points;  
        std::deque<Input> subscriptions;  
        std::vector<std::string> targets;  
        std::deque<Endpoint> endpoints;  
        std::unique_ptr<Endpoint> cloneEndpoint;  
        std::vector<std::unique_ptr<Message>> messages;  
        std::map<helics::InterfaceHandle, int> subids;  
        std::map<std::string_view, int> subkeys;  
        std::map<helics::InterfaceHandle, int> eptids;  // translate subscription id to index
        std::map<std::string_view, int> eptNames;  
        std::vector<ValueStats> vStat;  
        std::vector<std::string> captureInterfaces;  
        std::string mapfile;  
    };
 
}  // namespace apps
}  // namespace helics