BrokerFactory.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 "Broker.hpp"
#include "CoreTypes.hpp"
 
#include <chrono>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
 
namespace helics {
namespace BrokerFactory {
 
    class BrokerBuilder {
      public:
        virtual std::shared_ptr<Broker> build(std::string_view name) = 0;
    };
 
    template<class BrokerTYPE>
    class BrokerTypeBuilder final: public BrokerBuilder {
      public:
        static_assert(std::is_base_of<Broker, BrokerTYPE>::value,
                      "Type does not inherit from helics::Broker");
 
        using broker_build_type = BrokerTYPE;
        virtual std::shared_ptr<Broker> build(std::string_view name) override
        {
            return std::make_shared<BrokerTYPE>(name);
        }
    };
 
    void defineBrokerBuilder(std::shared_ptr<BrokerBuilder> builder,
                             std::string_view name,
                             int code);
 
    template<class BrokerTYPE>
    std::shared_ptr<BrokerBuilder> addBrokerType(std::string_view brokerTypeName, int code)
    {
        auto bld = std::make_shared<BrokerTypeBuilder<BrokerTYPE>>();
        std::shared_ptr<BrokerBuilder> bbld = std::static_pointer_cast<BrokerBuilder>(bld);
        defineBrokerBuilder(bbld, brokerTypeName, code);
        return bbld;
    }
 
    std::shared_ptr<Broker> create(CoreType type, std::string_view configureString);
    std::shared_ptr<Broker> create(CoreType type, int argc, char* argv[]);
    std::shared_ptr<Broker> create(CoreType type, std::vector<std::string> args);
 
    std::shared_ptr<Broker>
        create(CoreType type, std::string_view brokerName, std::string_view configureString);
 
    std::shared_ptr<Broker>
        create(CoreType type, std::string_view brokerName, int argc, char* argv[]);
 
    std::shared_ptr<Broker>
        create(CoreType type, std::string_view brokerName, std::vector<std::string> args);
 
    std::shared_ptr<Broker> findBroker(std::string_view brokerName);
    std::shared_ptr<Broker> getConnectedBroker();
    std::shared_ptr<Broker> getBrokerByIndex(size_t index);
 
    std::shared_ptr<Broker> findJoinableBrokerOfType(CoreType type);
 
    std::vector<std::shared_ptr<Broker>> getAllBrokers();
 
    bool brokersActive();
 
    bool registerBroker(const std::shared_ptr<Broker>& broker, CoreType type);
    void unregisterBroker(std::string_view name);
 
    void addAssociatedBrokerType(std::string_view name, CoreType type);
 
    size_t cleanUpBrokers();
 
    size_t cleanUpBrokers(std::chrono::milliseconds delay);
 
    bool copyBrokerIdentifier(std::string_view copyFromName, std::string_view copyToName);
 
    void displayHelp(CoreType type = CoreType::UNRECOGNIZED);
 
    void terminateAllBrokers();
    void abortAllBrokers(int errorCode, std::string_view errorString);
}  // namespace BrokerFactory
}  // namespace helics