cpp98/Translator.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_TRANSLATOR_HPP_
#define HELICS_CPP98_TRANSLATOR_HPP_
 
#include "DataBuffer.hpp"
#include "helics/helics.h"
#include "helicsExceptions.hpp"
 
#include <string>
 
namespace helicscpp {
class Translator {
  public:
    explicit Translator(HelicsTranslator htrans) HELICS_NOTHROW: translator(htrans) {}
    Translator() HELICS_NOTHROW: translator(HELICS_NULL_POINTER) {}
    Translator(const Translator& trans): translator(trans.translator) {}
    Translator& operator=(const Translator& translatorer)
    {
        translator = translatorer.translator;
        return *this;
    }
 
    operator HelicsTranslator() const { return translator; }
    HELICS_NODISCARD HelicsTranslator baseObject() const { return translator; }
    HELICS_NODISCARD bool isValid() const
    {
        return (helicsTranslatorIsValid(translator) == HELICS_TRUE);
    }
    HELICS_NODISCARD const char* getName() const { return helicsTranslatorGetName(translator); }
    void set(const std::string& property, double val)
    {
        helicsTranslatorSet(translator, property.c_str(), val, hThrowOnError());
    }
    void setString(const std::string& property, const std::string& val)
    {
        helicsTranslatorSetString(translator, property.c_str(), val.c_str(), hThrowOnError());
    }
 
    void addDestinationEndpoint(const std::string& dest)
    {
        helicsTranslatorAddDestinationEndpoint(translator, dest.c_str(), hThrowOnError());
    }
 
    void addSourceEndpoint(const std::string& source)
    {
        helicsTranslatorAddSourceEndpoint(translator, source.c_str(), hThrowOnError());
    }
 
    void addDestinationInput(const std::string& dest)
    {
        helicsTranslatorAddInputTarget(translator, dest.c_str(), hThrowOnError());
    }
 
    void addSourcePublication(const std::string& source)
    {
        helicsTranslatorAddPublicationTarget(translator, source.c_str(), hThrowOnError());
    }
    void removeTarget(const std::string& dest)
    {
        helicsTranslatorRemoveTarget(translator, dest.c_str(), hThrowOnError());
    }
    HELICS_NODISCARD const char* getInfo() const { return helicsTranslatorGetInfo(translator); }
    void setInfo(const std::string& info)
    {
        helicsTranslatorSetInfo(translator, info.c_str(), HELICS_IGNORE_ERROR);
    }
    HELICS_NODISCARD const char* getTag(const std::string& tagname) const
    {
        return helicsTranslatorGetTag(translator, tagname.c_str());
    }
    void setTag(const std::string& tagname, const std::string& tagvalue)
    {
        helicsTranslatorSetTag(translator, tagname.c_str(), tagvalue.c_str(), HELICS_IGNORE_ERROR);
    }
    void setOption(int32_t option, int32_t value = 1)
    {
        helicsTranslatorSetOption(translator, option, value, HELICS_IGNORE_ERROR);
    }
    int32_t getOption(int32_t option) { return helicsTranslatorGetOption(translator, option); }
 
    /*
    void setCallback(HelicsMessage (*translatorCall)(HelicsMessage message, void* userData),
                     void* userData)
    {
        helicsTranslatorSetCustomCallback(translator, translatorCall, userData,
    HELICS_IGNORE_ERROR);
    }
    */
  protected:
    HelicsTranslator translator;  
};
 
}  // namespace helicscpp
#endif