core/Core.hpp

Go to the documentation of this file.

/*
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 "LocalFederateId.hpp"
#include "core-data.hpp"
 
#include <functional>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
namespace helics {
class CoreFederateInfo;
 
class Core {
  public:
    Core() = default;
    virtual ~Core() = default;
 
    virtual void configure(std::string_view configureString) = 0;
    virtual void configureFromArgs(int argc, char* argv[]) = 0;
    virtual void configureFromVector(std::vector<std::string> args) = 0;
    virtual bool isConfigured() const = 0;
 
    virtual bool connect() = 0;
    virtual bool isConnected() const = 0;
 
    virtual void disconnect() = 0;
 
    /*return true if the core has an error*/
    virtual bool hasError() const = 0;
    virtual bool waitForDisconnect(
        std::chrono::milliseconds msToWait = std::chrono::milliseconds(0)) const = 0;
 
    virtual bool isOpenToNewFederates() const = 0;
    virtual const std::string& getIdentifier() const = 0;
    virtual const std::string& getAddress() const = 0;
 
    virtual void globalError(LocalFederateId federateID,
                             int32_t errorCode,
                             std::string_view errorString) = 0;
 
    virtual void
        localError(LocalFederateId federateID, int32_t errorCode, std::string_view errorString) = 0;
 
    virtual int getErrorCode() const = 0;
    virtual std::string getErrorMessage() const = 0;
    virtual void finalize(LocalFederateId federateID) = 0;
 
    virtual bool enterInitializingMode(LocalFederateId federateID,
                                       IterationRequest iterate = NO_ITERATION) = 0;
 
    virtual void setCoreReadyToInit() = 0;
 
    virtual iteration_time enterExecutingMode(LocalFederateId federateID,
                                              IterationRequest iterate = NO_ITERATION) = 0;
 
    virtual LocalFederateId registerFederate(std::string_view name,
                                             const CoreFederateInfo& info) = 0;
 
    virtual const std::string& getFederateName(LocalFederateId federateID) const = 0;
 
    virtual LocalFederateId getFederateId(std::string_view name) const = 0;
 
    virtual int32_t getFederationSize() = 0;
 
    virtual Time timeRequest(LocalFederateId federateID, Time next) = 0;
 
    virtual iteration_time
        requestTimeIterative(LocalFederateId federateID, Time next, IterationRequest iterate) = 0;
 
    virtual void processCommunications(LocalFederateId fedId,
                                       std::chrono::milliseconds msToWait) = 0;
    virtual void setTimeProperty(LocalFederateId federateID, int32_t property, Time timeValue) = 0;
    virtual Time getTimeProperty(LocalFederateId federateID, int32_t property) const = 0;
    virtual void
        setIntegerProperty(LocalFederateId federateID, int32_t property, int16_t propValue) = 0;
    virtual int16_t getIntegerProperty(LocalFederateId federateID, int32_t property) const = 0;
    virtual Time getCurrentTime(LocalFederateId federateID) const = 0;
 
    virtual void setFlagOption(LocalFederateId federateID, int32_t flag, bool flagValue) = 0;
 
    virtual bool getFlagOption(LocalFederateId federateID, int32_t flag) const = 0;
    virtual InterfaceHandle registerPublication(LocalFederateId federateID,
                                                std::string_view key,
                                                std::string_view type,
                                                std::string_view units) = 0;
 
    virtual InterfaceHandle getPublication(LocalFederateId federateID,
                                           std::string_view key) const = 0;
 
    virtual InterfaceHandle registerInput(LocalFederateId federateID,
                                          std::string_view key,
                                          std::string_view type,
                                          std::string_view units) = 0;
    virtual InterfaceHandle getInput(LocalFederateId federateID, std::string_view key) const = 0;
 
    virtual const std::string& getHandleName(InterfaceHandle handle) const = 0;
    virtual void removeTarget(InterfaceHandle handle, std::string_view targetToRemove) = 0;
 
    virtual const std::string& getExtractionUnits(InterfaceHandle handle) const = 0;
    virtual const std::string& getInjectionUnits(InterfaceHandle handle) const = 0;
 
    virtual const std::string& getInjectionType(InterfaceHandle handle) const = 0;
 
    virtual const std::string& getExtractionType(InterfaceHandle handle) const = 0;
 
    virtual void setHandleOption(InterfaceHandle handle, int32_t option, int32_t option_value) = 0;
 
    virtual int32_t getHandleOption(InterfaceHandle handle, int32_t option) const = 0;
 
    virtual void closeHandle(InterfaceHandle handle) = 0;
    virtual void setValue(InterfaceHandle handle, const char* data, uint64_t len) = 0;
 
    virtual const std::shared_ptr<const SmallBuffer>& getValue(InterfaceHandle handle,
                                                               uint32_t* inputIndex = nullptr) = 0;
 
    virtual const std::vector<std::shared_ptr<const SmallBuffer>>&
        getAllValues(InterfaceHandle handle) = 0;
 
    virtual const std::vector<InterfaceHandle>& getValueUpdates(LocalFederateId federateID) = 0;
 
    virtual InterfaceHandle registerEndpoint(LocalFederateId federateID,
                                             std::string_view name,
                                             std::string_view type) = 0;
 
    virtual InterfaceHandle registerTargetedEndpoint(LocalFederateId federateID,
                                                     std::string_view name,
                                                     std::string_view type) = 0;
 
    virtual InterfaceHandle getEndpoint(LocalFederateId federateID,
                                        std::string_view name) const = 0;
 
    virtual InterfaceHandle registerDataSink(LocalFederateId federateID, std::string_view name) = 0;
 
    virtual InterfaceHandle getDataSink(LocalFederateId federateID,
                                        std::string_view name) const = 0;
 
    virtual InterfaceHandle registerCloningFilter(std::string_view filterName,
                                                  std::string_view type_in,
                                                  std::string_view type_out) = 0;
 
    virtual InterfaceHandle registerFilter(std::string_view filterName,
                                           std::string_view type_in,
                                           std::string_view type_out) = 0;
 
    virtual InterfaceHandle registerTranslator(std::string_view translatorName,
                                               std::string_view endpointType,
                                               std::string_view units) = 0;
 
    virtual void addDestinationTarget(InterfaceHandle handle,
                                      std::string_view dest,
                                      InterfaceType hint = InterfaceType::UNKNOWN) = 0;
 
    virtual void addSourceTarget(InterfaceHandle handle,
                                 std::string_view name,
                                 InterfaceType hint = InterfaceType::UNKNOWN) = 0;
 
    virtual const std::string& getDestinationTargets(InterfaceHandle handle) const = 0;
 
    virtual const std::string& getSourceTargets(InterfaceHandle handle) const = 0;
 
    virtual InterfaceHandle getFilter(std::string_view name) const = 0;
 
    virtual InterfaceHandle getTranslator(std::string_view name) const = 0;
 
    virtual void addDependency(LocalFederateId federateID, std::string_view federateName) = 0;
 
    virtual void linkEndpoints(std::string_view source, std::string_view dest) = 0;
 
    virtual void addAlias(std::string_view interfaceKey, std::string_view alias) = 0;
 
    virtual void makeConnections(const std::string& file) = 0;
 
    virtual void dataLink(std::string_view source, std::string_view target) = 0;
    virtual void addSourceFilterToEndpoint(std::string_view filter, std::string_view target) = 0;
    virtual void addDestinationFilterToEndpoint(std::string_view filter,
                                                std::string_view target) = 0;
 
    virtual void send(InterfaceHandle sourceHandle, const void* data, uint64_t length) = 0;
    virtual void sendTo(InterfaceHandle sourceHandle,
                        const void* data,
                        uint64_t length,
                        std::string_view destination) = 0;
 
    virtual void
        sendAt(InterfaceHandle sourceHandle, const void* data, uint64_t length, Time time) = 0;
 
    virtual void sendToAt(InterfaceHandle sourceHandle,
                          const void* data,
                          uint64_t length,
                          std::string_view destination,
                          Time time) = 0;
 
    virtual void sendMessage(InterfaceHandle sourceHandle, std::unique_ptr<Message> message) = 0;
 
    virtual uint64_t receiveCount(InterfaceHandle destination) = 0;
 
    virtual std::unique_ptr<Message> receive(InterfaceHandle destination) = 0;
 
    virtual std::unique_ptr<Message> receiveAny(LocalFederateId federateID,
                                                InterfaceHandle& endpoint_id) = 0;
 
    virtual uint64_t receiveCountAny(LocalFederateId federateID) = 0;
 
    virtual void
        logMessage(LocalFederateId federateID, int logLevel, std::string_view messageToLog) = 0;
 
    virtual void setFilterOperator(InterfaceHandle filter,
                                   std::shared_ptr<FilterOperator> callback) = 0;
 
    virtual void setTranslatorOperator(InterfaceHandle translator,
                                       std::shared_ptr<TranslatorOperator> callback) = 0;
 
    virtual void setFederateOperator(LocalFederateId fed,
                                     std::shared_ptr<FederateOperator> callback) = 0;
 
    virtual void setLoggingCallback(
        LocalFederateId federateID,
        std::function<void(int, std::string_view, std::string_view)> logFunction) = 0;
 
    virtual void setLoggingLevel(int logLevel) = 0;
 
    virtual void setLogFile(std::string_view lfile) = 0;
 
    virtual void setGlobal(std::string_view valueName, std::string_view value) = 0;
 
    virtual void sendCommand(std::string_view target,
                             std::string_view commandStr,
                             std::string_view source,
                             HelicsSequencingModes mode) = 0;
 
    virtual std::pair<std::string, std::string> getCommand(LocalFederateId federateID) = 0;
 
    virtual std::pair<std::string, std::string> waitCommand(LocalFederateId federateID) = 0;
 
    virtual std::string
        query(std::string_view target, std::string_view queryStr, HelicsSequencingModes mode) = 0;
 
    virtual void setQueryCallback(LocalFederateId federateID,
                                  std::function<std::string(std::string_view)> queryFunction,
                                  int order) = 0;
 
    virtual void setInterfaceInfo(InterfaceHandle handle, std::string_view info) = 0;
 
    virtual const std::string& getInterfaceInfo(InterfaceHandle handle) const = 0;
    virtual void
        setInterfaceTag(InterfaceHandle handle, std::string_view tag, std::string_view value) = 0;
    virtual const std::string& getInterfaceTag(InterfaceHandle handle,
                                               std::string_view tag) const = 0;
 
    virtual void
        setFederateTag(LocalFederateId fid, std::string_view tag, std::string_view value) = 0;
    virtual const std::string& getFederateTag(LocalFederateId fid, std::string_view tag) const = 0;
};
 
}  // namespace helics