UnknownHandleManager.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 "CoreTypes.hpp"
#include "GlobalFederateId.hpp"
 
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace helics {
class UnknownHandleManager {
  public:
    using TargetInfo = std::pair<GlobalHandle, uint16_t>;
 
  private:
    std::unordered_multimap<std::string, TargetInfo>
        unknown_publications;  
    std::unordered_multimap<std::string, TargetInfo>
        unknown_endpoints;  
    std::unordered_multimap<std::string, TargetInfo> unknown_inputs;  
    std::unordered_multimap<std::string, TargetInfo>
        unknown_filters;  
 
    std::unordered_multimap<std::string, std::string>
        unknown_links;  
    std::unordered_multimap<std::string, std::string>
        unknown_endpoint_links;  
    std::unordered_multimap<std::string, std::string>
        unknown_src_filters;  
    std::unordered_multimap<std::string, std::string>
        unknown_dest_filters;  
 
    std::unordered_multimap<std::string, TargetInfo>
        reconnectable_publications;  
    std::unordered_multimap<std::string, TargetInfo>
        reconnectable_endpoints;  
    std::unordered_multimap<std::string, TargetInfo>
        reconnectable_inputs;  
    std::unordered_multimap<std::string, TargetInfo>
        reconnectable_filters;  
  public:
    UnknownHandleManager() = default;
    void addUnknownPublication(std::string_view key, GlobalHandle target, uint16_t flags);
    void addUnknownInput(std::string_view key, GlobalHandle target, uint16_t flags);
    void addUnknownEndpoint(std::string_view key, GlobalHandle target, uint16_t flags);
    void addUnknownFilter(std::string_view key, GlobalHandle target, uint16_t flags);
 
    void addReconnectablePublication(std::string_view key, GlobalHandle target, uint16_t flags);
    void addReconnectableInput(std::string_view key, GlobalHandle target, uint16_t flags);
    void addReconnectableEndpoint(std::string_view key, GlobalHandle target, uint16_t flags);
    void addReconnectableFilter(std::string_view key, GlobalHandle target, uint16_t flags);
 
    void addDataLink(std::string_view source, std::string_view target);
    void addEndpointLink(std::string_view source, std::string_view target);
 
    void addSourceFilterLink(std::string_view filter, std::string_view endpoint);
    void addDestinationFilterLink(std::string_view filter, std::string_view endpoint);
    std::vector<TargetInfo> checkForInputs(const std::string& newInput) const;
    std::vector<TargetInfo> checkForPublications(const std::string& newPublication) const;
    std::vector<TargetInfo> checkForEndpoints(const std::string& newEndpoint) const;
 
    std::vector<TargetInfo> checkForFilters(const std::string& newFilter) const;
 
    std::vector<TargetInfo> checkForReconnectionInputs(const std::string& newInput) const;
    std::vector<TargetInfo>
        checkForReconnectionPublications(const std::string& newPublication) const;
    std::vector<TargetInfo> checkForReconnectionEndpoints(const std::string& newEndpoint) const;
 
    std::vector<TargetInfo> checkForReconnectionFilters(const std::string& newFilter) const;
 
    std::vector<std::string> checkForLinks(const std::string& newSource) const;
 
    std::vector<std::string> checkForEndpointLinks(const std::string& newSource) const;
 
    std::vector<std::string> checkForFilterSourceTargets(const std::string& newFilter) const;
    std::vector<std::string> checkForFilterDestTargets(const std::string& newFilter) const;
    void clearInput(const std::string& newInput);
    void clearPublication(const std::string& newPublication);
    void clearEndpoint(const std::string& newEndpoint);
 
    void clearFilter(const std::string& newFilter);
    void clearFederateUnknowns(GlobalFederateId id);
    void clearUnknownsIf(
        const std::function<bool(const std::string& name, InterfaceType, TargetInfo)>& cfunc);
    bool hasUnknowns() const;
 
    bool hasNonOptionalUnknowns() const;
 
    bool hasRequiredUnknowns() const;
    void processRequiredUnknowns(
        const std::function<void(const std::string& name, InterfaceType, TargetInfo)>& cfunc) const;
 
    void processNonOptionalUnknowns(
        const std::function<void(const std::string& name, InterfaceType, TargetInfo)>& cfunc) const;
 
    void processUnknowns(
        const std::function<void(const std::string& name, InterfaceType, TargetInfo)>& cfunc) const;
 
    void processUnknownLinks(const std::function<void(const std::string& origin,
                                                      InterfaceType,
                                                      const std::string& target,
                                                      InterfaceType)>& cfunc) const;
};
 
}  // namespace helics