application_api/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
*/
#pragma once
 
#include "../core/Core.hpp"
#include "Federate.hpp"
#include "helics/helics_enums.h"
 
#include <memory>
#include <string>
 
namespace helics {
class TranslatorOperations;
class TranslatorOperator;
class CoreApp;
enum TranslatorTypes : std::int32_t {
    CUSTOM = HELICS_TRANSLATOR_TYPE_CUSTOM,
    JSON = HELICS_TRANSLATOR_TYPE_JSON,
    BINARY = HELICS_TRANSLATOR_TYPE_BINARY,
    UNRECOGNIZED = 7
};
 
constexpr std::string_view emptyString{""};
 
HELICS_CXX_EXPORT TranslatorTypes
    translatorTypeFromString(std::string_view translatorType) noexcept;
 
class HELICS_CXX_EXPORT Translator: public Interface {
  protected:
    bool disableAssign = false;  
  private:
    std::shared_ptr<TranslatorOperations>
        transOp;  
  public:
    Translator() = default;
    Translator(Federate* ffed, std::string_view translatorName, InterfaceHandle ihandle);
    Translator(Core* core, std::string_view translatorName, InterfaceHandle ihandle);
    explicit Translator(Core* core, std::string_view translatorName = emptyString);
    virtual ~Translator() = default;
 
    Translator(Translator&& trans) = default;
    Translator(const Translator& trans) = default;
    Translator& operator=(Translator&& trans) = default;
    Translator& operator=(const Translator& trans) = default;
 
    void setOperator(std::shared_ptr<TranslatorOperator> operation);
 
    virtual const std::string& getDisplayName() const override { return getName(); }
 
    virtual void set(std::string_view property, double val);
 
    virtual void setString(std::string_view property, std::string_view val);
 
    void addPublication(std::string_view target)
    {
        addSourceTarget(target, InterfaceType::PUBLICATION);
    }
    void addInputTarget(std::string_view target)
    {
        addDestinationTarget(target, InterfaceType::INPUT);
    }
    void addSourceEndpoint(std::string_view target)
    {
        addSourceTarget(target, InterfaceType::ENDPOINT);
    }
    void addDestinationEndpoint(std::string_view target)
    {
        addDestinationTarget(target, InterfaceType::ENDPOINT);
    }
    void addSourceFilter(std::string_view filterName)
    {
        addSourceTarget(filterName, InterfaceType::FILTER);
    }
    void addDestinationFilter(std::string_view filterName)
    {
        addDestinationTarget(filterName, InterfaceType::FILTER);
    }
    void setTranslatorType(std::int32_t type);
 
  protected:
    void setTranslatorOperations(std::shared_ptr<TranslatorOperations> translatorOps);
    friend void addOperations(Translator* translator, TranslatorTypes type);
};
 
}  // namespace helics