CoreFactory.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.hpp"
#include "CoreTypes.hpp"
 
#include <chrono>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
 
namespace helics {
namespace CoreFactory {
    class CoreBuilder {
      public:
        virtual std::shared_ptr<Core> build(std::string_view name) = 0;
    };
 
    template<class CoreTYPE>
    class CoreTypeBuilder final: public CoreBuilder {
      public:
        static_assert(std::is_base_of<Core, CoreTYPE>::value,
                      "Type does not inherit from helics::Core");
 
        using core_build_type = CoreTYPE;
        virtual std::shared_ptr<Core> build(std::string_view name) override
        {
            return std::make_shared<CoreTYPE>(name);
        }
    };
 
    //** define a new Core Builder from the builder give a name and build code*/
    void defineCoreBuilder(std::shared_ptr<CoreBuilder> builder,
                           std::string_view coreTypeName,
                           int code);
 
    template<class CoreTYPE>
    std::shared_ptr<CoreBuilder> addCoreType(std::string_view coreTypeName, int code)
    {
        auto bld = std::make_shared<CoreTypeBuilder<CoreTYPE>>();
        std::shared_ptr<CoreBuilder> cbld = std::static_pointer_cast<CoreBuilder>(bld);
        defineCoreBuilder(cbld, coreTypeName, code);
        return cbld;
    }
 
    std::vector<std::string> getAvailableCoreTypes();
 
    std::shared_ptr<Core>
        create(CoreType type, std::string_view coreName, std::string_view configureString);
    std::shared_ptr<Core> create(CoreType type, std::string_view configureString);
 
    std::shared_ptr<Core> create(CoreType type, int argc, char* argv[]);
 
    std::shared_ptr<Core> create(std::vector<std::string> args);
 
    std::shared_ptr<Core> create(CoreType type, std::vector<std::string> args);
 
    std::shared_ptr<Core> create(int argc, char* argv[]);
 
    std::shared_ptr<Core> create(CoreType type, std::string_view coreName, int argc, char* argv[]);
 
    std::shared_ptr<Core>
        create(CoreType type, std::string_view coreName, std::vector<std::string> args);
 
    std::shared_ptr<Core>
        FindOrCreate(CoreType type, std::string_view coreName, std::string_view configureString);
 
    std::shared_ptr<Core>
        FindOrCreate(CoreType type, std::string_view coreName, int argc, char* argv[]);
 
    std::shared_ptr<Core>
        FindOrCreate(CoreType type, std::string_view coreName, std::vector<std::string> args);
    std::shared_ptr<Core> findJoinableCoreOfType(CoreType type);
 
    std::shared_ptr<Core> findCore(std::string_view name);
 
    std::shared_ptr<Core> getEmptyCore();
 
    Core* getEmptyCorePtr();
 
    bool registerCore(const std::shared_ptr<Core>& core, CoreType type);
 
    void unregisterCore(std::string_view name);
 
    void addAssociatedCoreType(std::string_view name, CoreType type);
 
    size_t cleanUpCores();
    size_t cleanUpCores(std::chrono::milliseconds delay);
 
    bool copyCoreIdentifier(std::string_view copyFromName, std::string_view copyToName);
 
    void displayHelp(CoreType type = CoreType::UNRECOGNIZED);
 
    void terminateAllCores();
    void abortAllCores(int errorCode, std::string_view errorString);
 
    size_t getCoreCount();
}  // namespace CoreFactory
 
}  // namespace helics