Player.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/HelicsPrimaryTypes.hpp"
#include "../application_api/Publications.hpp"
#include "helicsApp.hpp"
 
#include <deque>
#include <memory>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace helics {
namespace apps {
    struct ValueSetter {
        Time time{Time::minVal()};
        int iteration = 0;
        int index{-1};
        std::string type;
        std::string pubName;
        defV value;
    };
 
    struct MessageHolder {
        Time sendTime{Time::minVal()};
        int index{-1};
        Message mess;
    };
 
    class HELICS_CXX_EXPORT Player: public App {
      public:
        Player() = default;
        explicit Player(std::vector<std::string> args);
        Player(int argc, char* argv[]);
        explicit Player(std::string_view name, const FederateInfo& fedInfo);
        Player(std::string_view name,
               const std::shared_ptr<Core>& core,
               const FederateInfo& fedInfo);
        Player(std::string_view name, CoreApp& core, const FederateInfo& fedInfo);
        Player(std::string_view appName, const std::string& configString);
 
        Player(Player&& other_player) = default;
        Player& operator=(Player&& fed) = default;
 
        virtual void initialize() override;
 
        virtual void runTo(Time stopTime_input) override;
 
        void addPublication(std::string_view name,
                            DataType type,
                            std::string_view pubUnits = std::string_view());
 
        template<class valType>
        typename std::enable_if_t<helicsType<valType>() != DataType::HELICS_CUSTOM>
            addPublication(std::string_view key, std::string_view pubUnits = std::string_view())
        {
            if (!useLocal) {
                publications.emplace_back(
                    InterfaceVisibility::GLOBAL, fed.get(), key, helicsType<valType>(), pubUnits);
            } else {
                publications.emplace_back(fed.get(), key, helicsType<valType>(), pubUnits);
            }
 
            pubids[key] = static_cast<int>(publications.size()) - 1;
        }
 
        void addEndpoint(std::string_view endpointName,
                         std::string_view endpointType = std::string_view());
        template<class valType>
        void addPoint(Time pubTime, std::string_view key, const valType& val)
        {
            points.resize(points.size() + 1);
            points.back().time = pubTime;
            points.back().pubName = key;
            points.back().value = val;
        }
 
        template<class valType>
        void addPoint(Time pubTime, int iteration, std::string_view key, const valType& val)
        {
            points.resize(points.size() + 1);
            points.back().time = pubTime;
            points.back().iteration = iteration;
            points.back().pubName = key;
            points.back().value = val;
        }
        void addMessage(Time sendTime,
                        std::string_view src,
                        std::string_view dest,
                        std::string_view payload);
 
        void addMessage(Time sendTime,
                        Time actionTime,
                        std::string_view src,
                        std::string_view dest,
                        std::string_view payload);
 
        auto pointCount() const { return points.size(); }
        auto messageCount() const { return messages.size(); }
        auto publicationCount() const { return publications.size(); }
        auto endpointCount() const { return endpoints.size(); }
        const auto& getPoint(int index) const { return points[index]; }
        const auto& getMessage(int index) const { return messages[index]; }
 
      private:
        std::unique_ptr<helicsCLI11App> generateParser();
        void processArgs();
 
        void initialSetup();
        virtual void loadJsonFile(const std::string& jsonString,
                                  bool enableFederateInterfaceRegistration) override;
        virtual void loadTextFile(const std::string& filename) override;
        void sortTags();
        void generatePublications();
        void generateEndpoints();
        void cleanUpPointList();
 
        void sendInformation(Time sendTime, int iteration = 0);
 
        helics::Time extractTime(std::string_view str, int lineNumber = 0) const;
 
      private:
        std::vector<ValueSetter> points;  
        std::vector<MessageHolder> messages;  
        std::unordered_map<std::string, std::string> tags;  
        std::set<std::string> epts;  
        std::deque<Publication> publications;  
        std::deque<Endpoint> endpoints;  
        std::unordered_map<std::string_view, int> pubids;  
        std::unordered_map<std::string_view, int> eptids;  
        helics::DataType defType =
            helics::DataType::HELICS_STRING;  
        size_t pointIndex = 0;  
        size_t messageIndex = 0;  
        time_units units = time_units::sec;
        double timeMultiplier =
            1.0;  
        Time nextPrintTimeStep =
            helics::timeZero;  
    };
}  // namespace apps
}  // namespace helics