Clone.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/Publications.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 Clone: public App {
      public:
        Clone(std::string_view appName, FederateInfo& fedInfo);
        explicit Clone(std::vector<std::string> args);
        Clone(int argc, char* argv[]);
 
        Clone(std::string_view appName,
              const std::shared_ptr<Core>& core,
              const FederateInfo& fedInfo);
 
        Clone(std::string_view appName, CoreApp& core, const FederateInfo& fedInfo);
 
        Clone(std::string_view appName, const std::string& configString);
        Clone(Clone&& other_recorder) = default;
        Clone& operator=(Clone&& record) = default;
        ~Clone();
        virtual void runTo(Time runToTime) override;
        void saveFile(const std::string& filename = std::string{});
        auto pointCount() const { return points.size(); }
        auto messageCount() const { return messages.size(); }
        std::tuple<Time, std::string, std::string> getValue(int index) const;
        std::unique_ptr<Message> getMessage(int index) const;
 
        void setFederateToClone(std::string_view federateName);
        void setOutputFile(std::string_view fileName) { outFileName = fileName; }
 
      private:
        void addSubscription(std::string_view key);
 
        void addSourceEndpointClone(std::string_view sourceEndpoint);
 
        virtual void initialize() override;
        void generateInterfaces();
        void captureForCurrentTime(Time currentTime, int iteration = 0);
        std::shared_ptr<helicsCLI11App> buildArgParserApp();
 
        void initialSetup();
        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)
            {
            }
        };
 
        bool allow_iteration{false};  
        bool verbose{false};  
        bool fileSaved{false};  
        Time nextPrintTimeStep{
            helics::timeZero};  
        std::unique_ptr<CloningFilter> cFilt;  
        std::vector<ValueCapture> points;  
        std::deque<Input> subscriptions;  
        std::vector<std::string>
            cloneSubscriptionNames;  
        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::string captureFederate;  
        std::string fedConfig;  
        std::vector<int> pubPointCount;  
    };
 
}  // namespace apps
}  // namespace helics