Endpoints.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 "Federate.hpp"
#include "data_view.hpp"
 
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
 
namespace helics {
class MessageFederate;
 
class HELICS_CXX_EXPORT Endpoint: public Interface {
  private:
    MessageFederate* fed{nullptr};  
    int referenceIndex{-1};  
    void* dataReference{nullptr};  
    bool disableAssign{false};  
    bool receiveOnly{false};  
    std::string defDest;  
  public:
    Endpoint() = default;
    
    // constructor used by messageFederateManager
    Endpoint(MessageFederate* mFed, std::string_view name, InterfaceHandle hid);
 
    Endpoint(MessageFederate* mFed,
             std::string_view name,
             std::string_view type = std::string_view{});
 
    template<class FedPtr>
    Endpoint(FedPtr& mFed, std::string_view name, std::string_view type = std::string_view{}):
        Endpoint(std::addressof(*mFed), name, type)
    {
        static_assert(
            std::is_base_of<MessageFederate, std::remove_reference_t<decltype(*mFed)>>::value,
            "first argument must be a pointer to a MessageFederate");
    }
    Endpoint(InterfaceVisibility locality,
             MessageFederate* mFed,
             std::string_view name,
             std::string_view type = std::string_view{});
    template<class FedPtr>
    Endpoint(InterfaceVisibility locality,
             FedPtr& mFed,
             std::string_view name,
             std::string_view type = std::string_view{}):
        Endpoint(locality, std::addressof(*mFed), name, type)
    {
        static_assert(
            std::is_base_of<MessageFederate, std::remove_reference_t<decltype(*mFed)>>::value,
            "second argument must be a pointer to a MessageFederate");
    }
    const std::string& getType() const { return getExtractionType(); }
    void send(const char* data, size_t data_size) const;
 
    void subscribe(std::string_view key);
 
    void sendTo(const char* data, size_t data_size, std::string_view dest) const;
    void sendAt(const char* data, size_t data_size, Time sendTime) const;
 
    void sendTo(const data_view& data, std::string_view dest) const
    {
        sendTo(data.data(), data.size(), dest);
    }
    void sendToAt(const data_view& data, std::string_view dest, Time sendTime) const
    {
        sendToAt(data.data(), data.size(), dest, sendTime);
    }
    void sendToAt(const char* data, size_t data_size, std::string_view dest, Time sendTime) const;
 
    void send(const void* data, size_t data_size) const;
 
    void send(const data_view& data) const { send(data.data(), data.size()); }
    void sendAt(const data_view& data, Time sendTime) const
    {
        sendAt(data.data(), data.size(), sendTime);
    }
    void send(std::unique_ptr<Message> mess) const;
 
    void send(const Message& mess) const { send(std::make_unique<Message>(mess)); }
 
    std::unique_ptr<Message> getMessage() const;
    bool hasMessage() const;
    std::uint64_t pendingMessageCount() const;
    void setCallback(const std::function<void(const Endpoint&, Time)>& callback);
 
    void addSourceFilter(std::string_view filterName);
    void addDestinationFilter(std::string_view filterName);
    void setDefaultDestination(std::string_view target);
    void addSourceEndpoint(std::string_view endpointName);
    void addDestinationEndpoint(std::string_view endpointName);
 
    const std::string& getDefaultDestination() const;
    virtual const std::string& getDisplayName() const override { return getName(); }
 
  private:
    friend class MessageFederateManager;
};
}  // namespace helics