application_api/CoreApp.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 "../core/CoreTypes.hpp"
#include "helics_cxx_export.h"
 
#include <chrono>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
namespace helics {
class Core;
class helicsCLI11App;
 
class HELICS_CXX_EXPORT CoreApp {
  public:
    CoreApp() = default;
    explicit CoreApp(std::vector<std::string> args);
    CoreApp(CoreType ctype, std::vector<std::string> args);
 
    CoreApp(CoreType ctype, std::string_view coreName, std::vector<std::string> args);
    CoreApp(int argc, char* argv[]);
    CoreApp(CoreType ctype, std::string_view coreName, int argc, char* argv[]);
    CoreApp(CoreType ctype, int argc, char* argv[]);
    explicit CoreApp(std::string_view argString);
    CoreApp(CoreType ctype, std::string_view argString);
    CoreApp(CoreType ctype, std::string_view coreName, std::string_view argString);
 
    explicit CoreApp(std::shared_ptr<Core> cr);
    bool isConnected() const;
 
    bool connect();
 
    bool isOpenToNewFederates() const;
    void forceTerminate();
    bool waitForDisconnect(std::chrono::milliseconds waitTime = std::chrono::milliseconds(0));
    void linkEndpoints(std::string_view source, std::string_view target);
    void dataLink(std::string_view source, std::string_view target);
    void addSourceFilterToEndpoint(std::string_view filter, std::string_view endpoint);
    void addDestinationFilterToEndpoint(std::string_view filter, std::string_view endpoint);
    void addAlias(std::string_view interfaceName, std::string_view alias);
    void makeConnections(const std::string& file);
    const std::string& getIdentifier() const;
    const std::string& getAddress() const;
 
    std::string query(std::string_view target,
                      std::string_view queryStr,
                      HelicsSequencingModes mode = HELICS_SEQUENCING_MODE_FAST);
 
    void setTag(std::string_view tag, std::string_view value = "true");
    const std::string& getTag(std::string_view tag) const;
 
    void setGlobal(std::string_view valueName, std::string_view value = "true");
 
    void sendCommand(std::string_view target,
                     std::string_view commandStr,
                     HelicsSequencingModes mode = HELICS_SEQUENCING_MODE_FAST);
 
    void setLogFile(std::string_view logFile);
    void setLoggingLevel(int loglevel);
    void setReadyToInit();
    void haltInit();
#ifdef HELICS_CXX_STATIC_DEFINE
    auto* operator->() const { return core.operator->(); }
#else
    CoreApp* operator->() { return this; }
    const CoreApp* operator->() const { return this; }
#endif
    std::shared_ptr<Core> getCopyofCorePointer() const { return core; }
 
    void reset();
    void globalError(int32_t errorCode, std::string_view errorString);
 
  private:
    void processArgs(std::unique_ptr<helicsCLI11App>& app);
    std::unique_ptr<helicsCLI11App> generateParser();
 
    std::shared_ptr<Core> core;  
    std::string name;  
};
 
class CoreKeeper {
  public:
    template<class... Args>
    explicit CoreKeeper(Args&&... args): cr(std::forward<Args...>(args...))
    {
    }
    CoreKeeper(CoreKeeper&& brkeep) = default;
    CoreKeeper(const CoreKeeper& crkeep) = default;
    CoreKeeper& operator=(CoreKeeper&& crkeep) = default;
    CoreKeeper& operator=(const CoreKeeper& crkeep) = default;
    bool isConnected() { return cr.isConnected(); }
    void forceTerminate() { cr.forceTerminate(); }
    ~CoreKeeper()
    {
        if (cr.isConnected()) {
            cr.waitForDisconnect();
        }
    }
 
  private:
    CoreApp cr;
};
}  // namespace helics