Publication.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
*/
#ifndef HELICS_CPP98_PUBLICATION_HPP_
#define HELICS_CPP98_PUBLICATION_HPP_
#pragma once
 
#include "DataBuffer.hpp"
#include "helics/helics.h"
#include "helicsExceptions.hpp"
 
#include <string>
#include <vector>
 
namespace helicscpp {
class Publication {
  public:
    explicit Publication(HelicsPublication hpub) HELICS_NOTHROW: pub(hpub) {}
    Publication() HELICS_NOTHROW: pub(HELICS_NULL_POINTER) {}
    Publication(const Publication& publication): pub(publication.pub) {}
    Publication& operator=(const Publication& publication)
    {
        pub = publication.pub;
        return *this;
    }
    // there is no need for move operators since copying the underlying object is fine, it is a
    // non-owning pointer
    operator HelicsPublication() const { return pub; }
    HELICS_NODISCARD HelicsPublication baseObject() const { return pub; }
 
    HELICS_NODISCARD bool isValid() const { return (helicsPublicationIsValid(pub) == HELICS_TRUE); }
 
    void publish(const char* data, int len)
    {
        // returns helics_status
        helicsPublicationPublishBytes(pub, data, len, HELICS_IGNORE_ERROR);
    }
    void publish(const char* str) { helicsPublicationPublishString(pub, str, HELICS_IGNORE_ERROR); }
    void publish(const std::string& str)
    {
        helicsPublicationPublishString(pub, str.c_str(), HELICS_IGNORE_ERROR);
    }
 
    void publish(int64_t val)
    {
        // returns helics_status
        helicsPublicationPublishInteger(pub, val, HELICS_IGNORE_ERROR);
    }
    void publish(double val) { helicsPublicationPublishDouble(pub, val, HELICS_IGNORE_ERROR); }
 
    void publish(std::complex<double> cmplx)
    {
        helicsPublicationPublishComplex(pub, cmplx.real(), cmplx.imag(), HELICS_IGNORE_ERROR);
    }
    void publish(const std::vector<double>& data)
    {
        helicsPublicationPublishVector(pub,
                                       data.data(),
                                       static_cast<int>(data.size()),
                                       HELICS_IGNORE_ERROR);
    }
    void publish(const double* data, int length)
    {
        helicsPublicationPublishVector(pub, data, length, HELICS_IGNORE_ERROR);
    }
 
#if defined(__GNUC__)
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wstrict-aliasing"
    // std::complex is explicitly allowed to alias like this in the standard
#endif
    void publish(const std::vector<std::complex<double> >& data)
    {
        helicsPublicationPublishComplexVector(pub,
                                              reinterpret_cast<const double*>(data.data()),
                                              static_cast<int>(data.size()),
                                              HELICS_IGNORE_ERROR);
    }
#if defined(__GNUC__)
#    pragma GCC diagnostic pop
#endif
 
    void publishComplex(const double* data, int length)
    {
        helicsPublicationPublishComplexVector(pub, data, length, HELICS_IGNORE_ERROR);
    }
    void publish(const std::string& name, double val)
    {
        helicsPublicationPublishNamedPoint(pub, name.c_str(), val, HELICS_IGNORE_ERROR);
    }
    void publish(bool val)
    {
        helicsPublicationPublishBoolean(pub, val ? HELICS_TRUE : HELICS_FALSE, HELICS_IGNORE_ERROR);
    }
    void publish(DataBuffer& buffer)
    {
        helicsPublicationPublishDataBuffer(pub, buffer.getHelicsDataBuffer(), hThrowOnError());
    }
    HELICS_NODISCARD const char* getName() const { return helicsPublicationGetName(pub); }
    HELICS_NODISCARD const char* getUnits() const { return helicsPublicationGetUnits(pub); }
    HELICS_NODISCARD const char* getType() const { return helicsPublicationGetType(pub); }
    HELICS_NODISCARD const char* getInfo() const { return helicsPublicationGetInfo(pub); }
 
    void setInfo(const std::string& info)
    {
        helicsPublicationSetInfo(pub, info.c_str(), HELICS_IGNORE_ERROR);
    }
    HELICS_NODISCARD const char* getTag(const std::string& tagname) const
    {
        return helicsPublicationGetTag(pub, tagname.c_str());
    }
    void setTag(const std::string& tagname, const std::string& tagvalue)
    {
        helicsPublicationSetTag(pub, tagname.c_str(), tagvalue.c_str(), HELICS_IGNORE_ERROR);
    }
    void setOption(int32_t option, int32_t value = 1)
    {
        helicsPublicationSetOption(pub, option, value, HELICS_IGNORE_ERROR);
    }
    HELICS_NODISCARD int32_t getOption(int32_t option)
    {
        return helicsPublicationGetOption(pub, option);
    }
 
  private:
    HelicsPublication pub;  
};
 
}  // namespace helicscpp
#endif