Connector.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 "CoreApp.hpp"
#include "helicsApp.hpp"
 
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace helics::apps {
enum class InterfaceDirection { TO_FROM = -1, BIDIRECTIONAL = 0, FROM_TO = 1 };
 
struct Connection {
    std::string_view interface1;
    std::string_view interface2;
    InterfaceDirection direction;
    std::vector<std::size_t> tags;
    std::shared_ptr<std::string> stringBuffer{nullptr};
};
 
struct ConnectionsList;
struct PotentialConnections;
class RegexMatcher;
class TemplateMatcher;
 
class HELICS_CXX_EXPORT Connector: public App {
  public:
    Connector() = default;
    explicit Connector(std::vector<std::string> args);
    Connector(int argc, char* argv[]);
    explicit Connector(std::string_view name, const FederateInfo& fedInfo);
    Connector(std::string_view name,
              const std::shared_ptr<Core>& coreObj,
              const FederateInfo& fedInfo);
    Connector(std::string_view name, CoreApp& coreObj, const FederateInfo& fedInfo);
    Connector(std::string_view appName, const std::string& configString);
 
    Connector(Connector&& other_player) = default;
    Connector& operator=(Connector&& fed) = default;
 
    virtual void initialize() override;
 
    virtual void runTo(Time stopTime_input) override;
 
    void addConnection(std::string_view interface1,
                       std::string_view interface2,
                       InterfaceDirection direction = InterfaceDirection::BIDIRECTIONAL,
                       const std::vector<std::string>& tags = {});
 
    std::size_t addTag(std::string_view tagName);
 
    std::string_view addInterface(std::string_view interfaceName);
 
    auto connectionCount() const { return connections.size(); }
    auto madeConnections() const { return matchCount; }
    void allowMultipleConnections(bool value = true) { matchMultiple = value; }
    void matchEndpointTargets(bool value = true) { matchTargetEndpoints = value; }
 
    using ConnectionsType = std::unordered_multimap<std::string_view, Connection>;
 
  private:
    std::unique_ptr<helicsCLI11App> generateParser();
    void processArgs();
 
    void initialSetup();
    virtual void loadJsonFile(const std::string& jsonString,
                              bool enableFederateInterfaceRegistration) override;
    virtual void loadTextFile(const std::string& filename) override;
 
    bool addConnectionVector(const std::vector<std::string>& connection);
    void establishPotentialInterfaces(ConnectionsList& possibleConnections);
 
    void scanPotentialInterfaces(ConnectionsList& possibleConnections);
 
    void scanPotentialInterfaceTemplates(ConnectionsList& possibleConnections);
 
    void scanUnconnectedInterfaces(ConnectionsList& possibleConnections);
 
    void makeConnections(ConnectionsList& possibleConnections);
    int makeTargetConnection(
        std::string_view origin,
        const std::vector<std::size_t>& tagList,
        std::unordered_set<std::string_view>& possibleConnections,
        const std::unordered_multimap<std::string_view, std::string_view>& aliases,
        const std::function<void(std::string_view origin, std::string_view target)>& callback);
    bool makePotentialConnection(
        std::string_view interfaceName,
        const std::vector<std::size_t>& tagList,
        std::unordered_map<std::string_view, PotentialConnections>& potentials,
        const std::unordered_multimap<std::string_view, std::string_view>& aliases);
 
    bool makePotentialTemplateConnection(
        std::string_view interfaceName,
        const std::vector<std::size_t>& tagList,
        std::vector<TemplateMatcher>& potentialTemplates,
        const std::unordered_multimap<std::string_view, std::string_view>& aliases);
 
    bool checkPotentialConnection(
        std::string_view interface,
        const std::vector<std::size_t>& tagList,
        std::unordered_set<std::string_view>& possibleConnections,
        std::unordered_map<std::string_view, PotentialConnections>& potentials,
        std::vector<TemplateMatcher>& potentialTemplates,
        const std::unordered_multimap<std::string_view, std::string_view>& aliases);
    std::vector<Connection>
        buildPossibleConnectionList(std::string_view startingInterface,
                                    const std::vector<std::size_t>& tagList) const;
    void generateRegexMatchers();
 
  private:
    CoreApp core;
    ConnectionsType connections;
    std::vector<Connection> matchers;
    std::vector<std::shared_ptr<RegexMatcher>> regexMatchers;
    std::unordered_map<std::size_t, std::string> tags;
    std::unordered_set<std::string> interfaces;
    std::uint64_t matchCount{0};
    std::uint64_t interfacesRequested{0};
    bool matchTargetEndpoints{false};
    bool matchMultiple{false};
    bool alwaysCheckRegex{false};
};
}  // namespace helics::apps