EndpointInfo.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 "../common/GuardedTypes.hpp"
#include "basic_CoreTypes.hpp"
 
#include <atomic>
#include <deque>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
namespace helics {
 
struct EndpointInformation {
    GlobalHandle id;
    std::string key;
    std::string type;
    EndpointInformation() = default;
    EndpointInformation(GlobalHandle gid, std::string_view key_, std::string_view type_):
        id(gid), key(key_), type(type_)
    {
    }
};
class EndpointInfo {
  public:
    EndpointInfo(GlobalHandle handle, std::string_view key_, std::string_view type_):
        id(handle), key(key_), type(type_)
    {
    }
 
    const GlobalHandle id;  
    const std::string key;  
    const std::string type;  
  private:
    shared_guarded<std::deque<std::unique_ptr<Message>>> message_queue;
    std::atomic<int32_t> mAvailableMessages{0};  
 
    std::vector<EndpointInformation> sourceInformation;
    std::vector<EndpointInformation> targetInformation;
    std::vector<std::pair<GlobalHandle, std::string_view>> targets;
    mutable std::string sourceTargets;
    mutable std::string destinationTargets;
 
  public:
    bool hasFilter{false};  
    bool required{false};
    bool targetedEndpoint{false};  
    bool sourceOnly{false};  
    bool receiveOnly{false};  
    int32_t requiredConnections{0};  
    std::unique_ptr<Message> getMessage(Time maxTime);
    int32_t availableMessages() const;
    int32_t queueSize(Time maxTime) const;
    int32_t queueSizeUpTo(Time maxTime) const;
    void addMessage(std::unique_ptr<Message> message);
    bool updateTimeUpTo(Time newTime);
    bool updateTimeInclusive(Time newTime);
 
    bool hasConnection() const;
    bool hasSource() const;
    bool hasTarget() const;
    bool updateTimeNextIteration(Time newTime);
    Time firstMessageTime() const;
    void clearQueue();
    void addDestination(GlobalHandle dest, std::string_view destName, std::string_view destType);
    void addSource(GlobalHandle source, std::string_view sourceName, std::string_view sourceType);
    void removeTarget(GlobalHandle targetId);
    void disconnectFederate(GlobalFederateId fedToDisconnect);
    const std::vector<std::pair<GlobalHandle, std::string_view>>& getTargets() const
    {
        return targets;
    }
    const std::string& getSourceTargets() const;
    const std::string& getDestinationTargets() const;
 
    void checkInterfacesForIssues(std::vector<std::pair<int, std::string>>& issues);
 
    void setProperty(int32_t option, int32_t value);
    int32_t getProperty(int32_t option) const;
};
}  // namespace helics