HandleManager.hpp

/*
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 "BasicHandleInfo.hpp"
#include "Core.hpp"
#include "helicsTime.hpp"
 
#include <deque>
#include <string>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
 
namespace helics {
 
class HandleManager {
  private:
    using MapType = std::unordered_map<std::string_view, InterfaceHandle>;
    std::deque<BasicHandleInfo> handles;  
    MapType publications;
    MapType endpoints;
    MapType inputs;  
    MapType filters;  
    std::unordered_map<std::uint64_t, int32_t> unique_ids;  
    std::unordered_map<std::string_view, std::vector<std::string_view>> aliases;
    std::unordered_set<std::string> alias_names;  
  public:
    HandleManager() = default;
    BasicHandleInfo& addHandle(GlobalFederateId fed_id,
                               InterfaceType what,
                               std::string_view key,
                               std::string_view type,
                               std::string_view units);
    BasicHandleInfo& addHandle(GlobalFederateId fed_id,
                               InterfaceHandle local_id,
                               InterfaceType what,
                               std::string_view key,
                               std::string_view type,
                               std::string_view units);
 
    void addHandle(const BasicHandleInfo& otherHandle);
    void addHandleAtIndex(const BasicHandleInfo& otherHandle, int32_t index);
    void removeHandle(GlobalHandle handle);
    void removeFederateHandles(GlobalFederateId fedToRemove);
    BasicHandleInfo* getHandleInfo(int32_t index);
    const BasicHandleInfo* getHandleInfo(int32_t index) const;
    BasicHandleInfo* getHandleInfo(InterfaceHandle handle);
    const BasicHandleInfo* getHandleInfo(InterfaceHandle handle) const;
    BasicHandleInfo* findHandle(GlobalHandle id);
    const BasicHandleInfo* findHandle(GlobalHandle id) const;
 
    void setHandleOption(InterfaceHandle handle, int32_t option, int32_t val);
 
    int32_t getHandleOption(InterfaceHandle handle, int32_t option) const;
    BasicHandleInfo* getInterfaceHandle(std::string_view name, InterfaceType type);
    const BasicHandleInfo* getInterfaceHandle(std::string_view name, InterfaceType type) const;
    BasicHandleInfo* getInterfaceHandle(InterfaceHandle handle, InterfaceType type);
    const BasicHandleInfo* getInterfaceHandle(InterfaceHandle handle, InterfaceType type) const;
 
    LocalFederateId getLocalFedID(InterfaceHandle handle) const;
 
    BasicHandleInfo& operator[](size_t index) { return handles[index]; }
    const BasicHandleInfo& operator[](size_t index) const { return handles[index]; }
    void addAlias(std::string_view interfaceName, std::string_view alias);
    auto begin() { return handles.begin(); }
    auto end() { return handles.end(); }
    auto begin() const { return handles.begin(); }
    auto end() const { return handles.end(); }
    auto size() const { return handles.size(); }
    /* search for handles based on a regex string and type*/
    std::vector<GlobalHandle> regexSearch(const std::string& regexExpression,
                                          InterfaceType type) const;
    const std::unordered_map<std::string_view, std::vector<std::string_view>>& getAliases() const
    {
        return aliases;
    }
 
  private:
    void addSearchFields(const BasicHandleInfo& handle, int32_t index);
    std::string generateName(InterfaceType what) const;
    // alias must be a stable string_view here
    void addPublicationAlias(std::string_view interfaceName, std::string_view alias);
    // alias must be a stable string_view here
    void addInputAlias(std::string_view interfaceName, std::string_view alias);
    // alias must be a stable string_view here
    void addEndpointAlias(std::string_view interfaceName, std::string_view alias);
    // alias must be a stable string_view here
    void addFilterAlias(std::string_view interfaceName, std::string_view alias);
    bool addAliasName(std::string_view interfaceName, std::string_view alias);
    MapType& getMap(InterfaceType type);
    const MapType& getMap(InterfaceType type) const;
};
 
}  // namespace helics