application_api/BrokerApp.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 "../core/helicsTime.hpp"
#include "helics_cxx_export.h"
 
#include <chrono>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
namespace helics {
class Broker;
class helicsCLI11App;
 
class HELICS_CXX_EXPORT BrokerApp {
  public:
    BrokerApp() = default;
    explicit BrokerApp(std::vector<std::string>&& args);
    BrokerApp(CoreType ctype, std::vector<std::string>&& args);
    BrokerApp(CoreType ctype, const std::string& broker_name, std::vector<std::string>&& args);
    explicit BrokerApp(std::vector<std::string>& args);
    BrokerApp(CoreType ctype, std::vector<std::string>& args);
    BrokerApp(CoreType ctype, const std::string& broker_name, std::vector<std::string>& args);
    BrokerApp(int argc, char* argv[]);
    BrokerApp(CoreType ctype, int argc, char* argv[]);
    BrokerApp(CoreType ctype, std::string_view brokerName, int argc, char* argv[]);
    explicit BrokerApp(std::string_view argString);
    explicit BrokerApp(CoreType ctype, std::string_view argString = std::string_view{});
    BrokerApp(CoreType ctype, std::string_view brokerName, std::string_view argString);
 
    explicit BrokerApp(std::shared_ptr<Broker> brk);
 
    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 setGlobal(std::string_view valueName, std::string_view value);
 
    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 reset();
#ifdef HELICS_CXX_STATIC_DEFINE
    auto* operator->() const { return broker.operator->(); }
#else
    BrokerApp* operator->() { return this; }
    const BrokerApp* operator->() const { return this; }
#endif
    std::shared_ptr<Broker> getCopyofBrokerPointer() const { return broker; }
 
    void setTimeBarrier(Time barrierTime);
    void clearTimeBarrier();
    void globalError(int32_t errorCode, std::string_view errorString);
 
  private:
    void processArgs(std::unique_ptr<helicsCLI11App>& app);
    std::unique_ptr<helicsCLI11App> generateParser(bool noTypeOption = false);
    std::shared_ptr<Broker> broker;  
    std::string name;  
};
 
class BrokerKeeper {
  public:
    template<class... Args>
    explicit BrokerKeeper(Args&&... args): brk(std::forward<Args...>(args...))
    {
    }
    BrokerKeeper(BrokerKeeper&& brkeep) = default;
    BrokerKeeper(const BrokerKeeper& brkeep) = default;
    BrokerKeeper& operator=(BrokerKeeper&& brkeep) = default;
    BrokerKeeper& operator=(const BrokerKeeper& brkeep) = default;
    bool isConnected() { return brk.isConnected(); }
    void forceTerminate() { brk.forceTerminate(); }
    ~BrokerKeeper()
    {
        if (brk.isConnected()) {
            brk.waitForDisconnect();
        }
    }
 
  private:
    BrokerApp brk;
};
 
}  // namespace helics