Endpoint.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
*/
#ifndef HELICS_CPP98_ENDPOINT_HPP_
#define HELICS_CPP98_ENDPOINT_HPP_
#pragma once
 
#include "DataBuffer.hpp"
#include "helics/helics.h"
#include "helicsExceptions.hpp"
 
#include <string>
#include <vector>
 
namespace helicscpp {
class Endpoint;
class Federate;
 
class Message {
  public:
    Message() HELICS_NOTHROW: mo(HELICS_NULL_POINTER) {}
    explicit Message(const Federate& fed);
    explicit Message(const Endpoint& ept);
    explicit Message(HelicsMessage hmo) HELICS_NOTHROW: mo(hmo) {}
 
    Message(const Message& mess) HELICS_NOTHROW:
        mo(helicsMessageClone(mess.mo, HELICS_IGNORE_ERROR))
    {
    }
    Message& operator=(const Message& mess) HELICS_NOTHROW
    {
        if (mo != HELICS_NULL_POINTER) {
            helicsMessageFree(mo);
        }
        mo = helicsMessageClone(mess.mo, HELICS_IGNORE_ERROR);
        return *this;
    }
#ifdef HELICS_HAS_RVALUE_REFS
    Message(Message&& mess) HELICS_NOTHROW: mo(mess.release()) {}
    Message& operator=(Message&& mess) HELICS_NOTHROW
    {
        mo = mess.release();
        return *this;
    }
#endif
    ~Message()
    {
        if (mo != HELICS_NULL_POINTER) {
            helicsMessageFree(mo);
        }
    }
    operator HelicsMessage() const { return mo; }
    bool isValid() const { return (helicsMessageIsValid(mo) == HELICS_TRUE); }
    const char* source() const { return helicsMessageGetSource(mo); }
    Message& source(const std::string& src)
    {
        helicsMessageSetSource(mo, src.c_str(), hThrowOnError());
        return *this;
    }
    Message& source(const char* src)
    {
        helicsMessageSetSource(mo, src, hThrowOnError());
        return *this;
    }
    const char* destination() const { return helicsMessageGetDestination(mo); }
    Message& destination(const std::string& dest)
    {
        helicsMessageSetDestination(mo, dest.c_str(), hThrowOnError());
        return *this;
    }
    Message& destination(const char* dest)
    {
        helicsMessageSetDestination(mo, dest, hThrowOnError());
        return *this;
    }
    const char* originalSource() const { return helicsMessageGetOriginalSource(mo); }
    Message& originalSource(const std::string& osrc)
    {
        helicsMessageSetOriginalSource(mo, osrc.c_str(), hThrowOnError());
        return *this;
    }
    const char* originalDestination() const { return helicsMessageGetOriginalDestination(mo); }
    Message& originalDestination(const std::string& odest)
    {
        helicsMessageSetOriginalDestination(mo, odest.c_str(), hThrowOnError());
        return *this;
    }
    int size() const { return helicsMessageGetByteCount(mo); }
    void resize(int newSize) { helicsMessageResize(mo, newSize, hThrowOnError()); }
    void reserve(int newSize) { helicsMessageReserve(mo, newSize, hThrowOnError()); }
    void* data() const { return helicsMessageGetBytesPointer(mo); }
    Message& data(const void* ptr, int size)
    {
        helicsMessageSetData(mo, ptr, size, hThrowOnError());
        return *this;
    }
    Message& data(const std::string& str)
    {
        helicsMessageSetString(mo, str.c_str(), hThrowOnError());
        return *this;
    }
    Message& data(const char* str)
    {
        helicsMessageSetString(mo, str, hThrowOnError());
        return *this;
    }
    Message& data(DataBuffer buffer)
    {
        helicsMessageSetDataBuffer(mo, buffer.getHelicsDataBuffer(), hThrowOnError());
        return *this;
    }
    Message& append(const void* ptr, int size)
    {
        helicsMessageAppendData(mo, ptr, size, hThrowOnError());
        return *this;
    }
    Message& append(const std::string& str)
    {
        helicsMessageAppendData(mo, str.c_str(), static_cast<int>(str.size()), hThrowOnError());
        return *this;
    }
    const char* c_str() const { return helicsMessageGetString(mo); }
    HelicsTime time() const { return helicsMessageGetTime(mo); }
    Message& time(HelicsTime val)
    {
        helicsMessageSetTime(mo, val, hThrowOnError());
        return *this;
    }
    Message& setFlag(int flag, bool val)
    {
        helicsMessageSetFlagOption(mo, flag, val ? HELICS_TRUE : HELICS_FALSE, hThrowOnError());
        return *this;
    }
    bool getFlagOption(int flag) const
    {
        return (helicsMessageGetFlagOption(mo, flag) == HELICS_TRUE);
    }
    int messageID() const { return helicsMessageGetMessageID(mo); }
    Message& messageID(int newId)
    {
        helicsMessageSetMessageID(mo, newId, hThrowOnError());
        return *this;
    }
    HelicsMessage release()
    {
        HelicsMessage mreturn = mo;
        mo = HELICS_NULL_POINTER;
        return mreturn;
    }
    void clear() { helicsMessageClear(mo, HELICS_IGNORE_ERROR); }
    DataBuffer dataBuffer() { return DataBuffer(helicsMessageDataBuffer(mo, HELICS_IGNORE_ERROR)); }
    Message& newMessageObject(const Federate& fed);
 
    Message& newMessageObject(const Endpoint& ept);
 
  private:
    HelicsMessage mo;  
};
 
class Endpoint {
  public:
    explicit Endpoint(HelicsEndpoint hep) HELICS_NOTHROW: ep(hep) {}
    Endpoint() HELICS_NOTHROW: ep(HELICS_NULL_POINTER) {}
    Endpoint(const Endpoint& endpoint) HELICS_NOTHROW: ep(endpoint.ep) {}
    Endpoint& operator=(const Endpoint& endpoint)
    {
        ep = endpoint.ep;
        return *this;
    }
    operator HelicsEndpoint() { return ep; }
    HelicsEndpoint baseObject() const { return ep; }
    bool isValid() const { return (helicsEndpointIsValid(ep) == HELICS_TRUE); }
    /* Checks if endpoint has unread messages **/
    bool hasMessage() const
    {
        // returns int, 1 = true, 0 = false
        return helicsEndpointHasMessage(ep) > 0;
    }
    void setDefaultDestination(const std::string& dest)
    {
        helicsEndpointSetDefaultDestination(ep, dest.c_str(), hThrowOnError());
    }
    const char* getDefaultDestination() const { return helicsEndpointGetDefaultDestination(ep); }
    uint64_t pendingMessageCount() const { return helicsEndpointPendingMessageCount(ep); }
 
    Message getMessage() { return Message(helicsEndpointGetMessage(ep)); }
 
    Message createMessage() { return Message(helicsEndpointCreateMessage(ep, hThrowOnError())); }
 
    void send(const void* data, size_t data_size)
    {
        helicsEndpointSendBytes(ep, data, static_cast<int>(data_size), hThrowOnError());
    }
 
    void sendTo(const void* data, size_t data_size, const std::string& dest)
    {
        helicsEndpointSendBytesTo(
            ep, data, static_cast<int>(data_size), dest.c_str(), hThrowOnError());
    }
    void sendAt(const char* data, size_t data_size, HelicsTime time)
    {
        helicsEndpointSendBytesAt(ep, data, static_cast<int>(data_size), time, hThrowOnError());
    }
    void sendToAt(const void* data, size_t data_size, const std::string& dest, HelicsTime time)
    {
        helicsEndpointSendBytesToAt(
            ep, data, static_cast<int>(data_size), dest.c_str(), time, hThrowOnError());
    }
    void send(const std::string& data)
    {
        helicsEndpointSendBytes(ep, &(data[0]), static_cast<int>(data.size()), hThrowOnError());
    }
 
    void sendTo(const std::string& data, const std::string& dest)
    {
        helicsEndpointSendBytesTo(
            ep, &(data[0]), static_cast<int>(data.size()), dest.c_str(), hThrowOnError());
    }
    void sendAt(const std::string& data, HelicsTime time)
    {
        helicsEndpointSendBytesAt(
            ep, &(data[0]), static_cast<int>(data.size()), time, hThrowOnError());
    }
    void sendToAt(const std::string& data, const std::string& dest, HelicsTime time)
    {
        helicsEndpointSendBytesToAt(
            ep, &(data[0]), static_cast<int>(data.size()), dest.c_str(), time, hThrowOnError());
    }
 
    void send(const std::vector<char>& data)
    {
        helicsEndpointSendBytes(ep, data.data(), static_cast<int>(data.size()), hThrowOnError());
    }
 
    void sendTo(const std::vector<char>& data, const std::string& dest)
    {
        helicsEndpointSendBytesTo(
            ep, data.data(), static_cast<int>(data.size()), dest.c_str(), hThrowOnError());
    }
    void sendAt(const std::vector<char>& data, HelicsTime time)
    {
        helicsEndpointSendBytesAt(
            ep, data.data(), static_cast<int>(data.size()), time, hThrowOnError());
    }
    void sendToAt(const std::vector<char>& data, const std::string& dest, HelicsTime time)
    {
        helicsEndpointSendBytesToAt(
            ep, data.data(), static_cast<int>(data.size()), dest.c_str(), time, hThrowOnError());
    }
 
    void sendMessage(const Message& message)
    {
        // returns helicsStatus
        helicsEndpointSendMessage(ep, message, hThrowOnError());
    }
#ifdef HELICS_HAS_RVALUE_REFS
    void sendMessage(Message&& message)
    {
        // returns helicsStatus
        helicsEndpointSendMessageZeroCopy(ep, message.release(), hThrowOnError());
    }
#endif
    void sendMessageZeroCopy(Message& message)
    {
        // returns helicsStatus
        helicsEndpointSendMessageZeroCopy(ep, static_cast<HelicsMessage>(message), hThrowOnError());
        message.release();
    }
    const char* getName() const { return helicsEndpointGetName(ep); }
    const char* getType() { return helicsEndpointGetType(ep); }
 
    const char* getInfo() const { return helicsEndpointGetInfo(ep); }
    void setInfo(const std::string& info)
    {
        helicsEndpointSetInfo(ep, info.c_str(), HELICS_IGNORE_ERROR);
    }
 
  private:
    HelicsEndpoint ep;  
};
 
inline Message::Message(const Endpoint& ept):
    mo(helicsEndpointCreateMessage(ept.baseObject(), hThrowOnError()))
{
}
 
inline Message& Message::newMessageObject(const Endpoint& ept)
{
    HelicsMessage newmo = helicsEndpointCreateMessage(ept.baseObject(), hThrowOnError());
    if (mo != HELICS_NULL_POINTER) {
        helicsMessageFree(mo);
    }
    mo = newmo;
    return *this;
}
 
}  // namespace helicscpp
#endif