InterfaceInfo.hpp

Go to the documentation of this file.

/*
Copyright (c) 2017-2024,
Battelle Memorial Institute; Lawrence Livermore National Security, LLC; Alliance for Sustainable
Energy, LLC.  See the top-level NOTICE for additional details. All rights reserved.
SPDX-License-Identifier: BSD-3-Clause
*/
#pragma once
#include "../common/GuardedTypes.hpp"
#include "EndpointInfo.hpp"
#include "FederateIdExtra.hpp"
#include "InputInfo.hpp"
#include "PublicationInfo.hpp"
#include "gmlc/containers/DualMappedPointerVector.hpp"
 
#include "json/forwards.h"
#include <atomic>
#include <string>
#include <utility>
#include <vector>
 
namespace helics {
class InterfaceInfo {
  public:
    InterfaceInfo() = default;
    const PublicationInfo* getPublication(const std::string& pubName) const;
    const PublicationInfo* getPublication(InterfaceHandle handle) const;
    PublicationInfo* getPublication(const std::string& pubName);
    PublicationInfo* getPublication(InterfaceHandle handle);
    const InputInfo* getInput(const std::string& inputName) const;
    const InputInfo* getInput(InterfaceHandle handle) const;
    InputInfo* getInput(const std::string& inputName);
    InputInfo* getInput(InterfaceHandle handle);
    const EndpointInfo* getEndpoint(const std::string& endpointName) const;
    const EndpointInfo* getEndpoint(InterfaceHandle handle) const;
    EndpointInfo* getEndpoint(const std::string& endpointName);
    EndpointInfo* getEndpoint(InterfaceHandle handle);
 
    void createPublication(InterfaceHandle handle,
                           std::string_view key,
                           std::string_view type,
                           std::string_view units,
                           std::uint16_t flags);
    void createInput(InterfaceHandle handle,
                     std::string_view key,
                     std::string_view type,
                     std::string_view units,
                     std::uint16_t flags);
    void createEndpoint(InterfaceHandle handle,
                        std::string_view endpointName,
                        std::string_view type,
                        std::uint16_t flags);
 
    auto getEndpoints() { return endpoints.lock(); }
    auto getPublications() { return publications.lock(); }
    auto getInputs() { return inputs.lock(); }
    auto getEndpoints() const { return endpoints.lock_shared(); }
    auto getPublications() const { return publications.lock_shared(); }
    auto getInputs() const { return inputs.lock_shared(); }
    auto cgetEndpoints() const { return endpoints.lock_shared(); }
    auto cgetPublications() const { return publications.lock_shared(); }
    auto cgetInputs() const { return inputs.lock_shared(); }
    void setGlobalId(GlobalFederateId newglobalId) { global_id = newglobalId; }
    void setChangeUpdateFlag(bool updateFlag);
    bool getChangeUpdateFlag() const { return only_update_on_change; }
    bool setInputProperty(InterfaceHandle hid, int32_t option, int32_t value);
    bool setPublicationProperty(InterfaceHandle hid, int32_t option, int32_t value);
    bool setEndpointProperty(InterfaceHandle hid, int32_t option, int32_t value);
    int32_t getInputProperty(InterfaceHandle hid, int32_t option) const;
    int32_t getPublicationProperty(InterfaceHandle hid, int32_t option) const;
    int32_t getEndpointProperty(InterfaceHandle hid, int32_t option) const;
 
    std::vector<std::pair<int, std::string>> checkInterfacesForIssues();
    void generateInferfaceConfig(Json::Value& base) const;
    void generateDataFlowGraph(Json::Value& base) const;
    void getUnconnectedInterfaces(Json::Value& base) const;
    void reset();
    void disconnectFederate(GlobalFederateId fedToDisconnect, Time disconnectTime);
 
  private:
    std::atomic<GlobalFederateId> global_id;
    bool only_update_on_change{false};
    shared_guarded<
        gmlc::containers::DualMappedPointerVector<PublicationInfo, std::string, InterfaceHandle>>
        publications;  
    shared_guarded<
        gmlc::containers::DualMappedPointerVector<EndpointInfo, std::string, InterfaceHandle>>
        endpoints;  
    shared_guarded<
        gmlc::containers::DualMappedPointerVector<InputInfo, std::string, InterfaceHandle>>
        inputs;  
};
}  // namespace helics