helicsApp.hpp

/*
Copyright (c) 2017-2025,
Battelle Memorial Institute; Lawrence Livermore National Security, LLC; Alliance for Sustainable
Energy, LLC.  See the top-level NOTICE for additional details. All rights reserved.
SPDX-License-Identifier: BSD-3-Clause
*/
#pragma once
 
#include "../application_api/CombinationFederate.hpp"
 
#include <fstream>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
namespace CLI {
class App;
}  // namespace CLI
 
namespace helics::fileops {
class JsonBuffer;
}
namespace helics::apps {
 
class AppTextParser;
 
class HELICS_CXX_EXPORT App {
  public:
    App() = default;
    App(std::string_view defaultAppName, std::vector<std::string> args);
    App(std::string_view defaultAppName, int argc, char* argv[]);
    App(std::string_view appName, const FederateInfo& fedInfo);
    App(std::string_view appName, const std::shared_ptr<Core>& core, const FederateInfo& fedInfo);
    App(std::string_view appName, CoreApp& core, const FederateInfo& fedInfo);
    App(std::string_view appName, const std::string& configString);
 
    App(App&& other_app) = default;
    App(const App& other_app) = delete;
    App& operator=(App&& app) = default;
    App& operator=(const App& app) = delete;
    virtual ~App();
 
    void loadFile(const std::string& filename, bool enableFederateInterfaceRegistration = true);
    virtual void initialize();
    /*run the Player*/
    virtual void run();
 
    virtual void runTo(Time stopTime_input) = 0;
 
    virtual void finalize();
 
    bool isActive() const { return !deactivated; }
    const CombinationFederate& accessUnderlyingFederate() const { return *fed; }
 
    std::shared_ptr<CombinationFederate> getUnderlyingFederatePointer() { return fed; }
 
  protected:
    virtual void loadJsonFile(const std::string& jsonString,
                              bool enableFederateInterfaceRegistration);
    void loadJsonFileConfiguration(const std::string& appName,
                                   const std::string& jsonString,
                                   bool enableFederateInterfaceRegistration);
    virtual void loadTextFile(const std::string& textFile);
    void loadInputFiles();
    void loadConfigOptions(AppTextParser& aparser);
 
  private:
    void loadConfigOptions(const fileops::JsonBuffer& element);
    std::unique_ptr<helicsCLI11App> generateParser();
    void processArgs(std::unique_ptr<helicsCLI11App>& app,
                     FederateInfo& fedInfo,
                     std::string_view defaultAppName);
 
  protected:
    std::shared_ptr<CombinationFederate> fed;  
    Time stopTime = Time::maxVal();  
    std::string configFileName;  
    std::string inputFileName;  
    std::string outFileName;  
    bool useLocal{false};
    bool fileLoaded{false};
    bool deactivated{false};
    bool quietMode{false};
    bool helpMode{false};
    std::vector<std::string> remArgs;
};
 
class AppTextParser {
  public:
    explicit AppTextParser(const std::string& filename);
    std::vector<int> preParseFile(const std::vector<char>& klines);
 
    const std::string& configString() const { return configStr; }
    bool loadNextLine(std::string& line, int& lineNumber);
    void reset();
 
  private:
    bool mLineComment{false};
    std::ifstream filePtr;
    std::string configStr;
    std::string mFileName;
    int currentLineNumber{0};
};
}  // namespace helics::apps