TranslatorOperations.hpp

Go to the documentation of this file.

/*
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 "../common/GuardedTypes.hpp"
#include "../core/core-data.hpp"
#include "../core/helicsTime.hpp"
 
#include <atomic>
#include <functional>
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>
 
namespace helics {
class Core;
 
class JsonTranslatorOperator: public TranslatorOperator {
  public:
    JsonTranslatorOperator() = default;
 
  private:
    virtual SmallBuffer convertToValue(std::unique_ptr<Message> message) override;
    virtual std::unique_ptr<Message> convertToMessage(const SmallBuffer& value) override;
};
 
class BinaryTranslatorOperator: public TranslatorOperator {
  public:
    BinaryTranslatorOperator() = default;
 
  private:
    virtual SmallBuffer convertToValue(std::unique_ptr<Message> message) override;
    virtual std::unique_ptr<Message> convertToMessage(const SmallBuffer& value) override;
};
 
class CustomTranslatorOperator: public TranslatorOperator {
  public:
    CustomTranslatorOperator() = default;
 
    void setToValueFunction(
        std::function<SmallBuffer(std::unique_ptr<Message> message)> userToValueFunction)
    {
        toValueFunction = std::move(userToValueFunction);
    }
 
    void setToMessageFunction(
        std::function<std::unique_ptr<Message>(const SmallBuffer& value)> userToMessageFunction)
    {
        toMessageFunction = std::move(userToMessageFunction);
    }
 
  private:
    std::function<SmallBuffer(std::unique_ptr<Message> message)> toValueFunction;
    std::function<std::unique_ptr<Message>(const SmallBuffer& value)> toMessageFunction;
 
    virtual SmallBuffer convertToValue(std::unique_ptr<Message> message) override;
    virtual std::unique_ptr<Message> convertToMessage(const SmallBuffer& value) override;
};
 
class TranslatorOperations {
  public:
    TranslatorOperations() = default;
    virtual ~TranslatorOperations() = default;
    // still figuring out if these functions have a use or not
    TranslatorOperations(const TranslatorOperations& fo) = delete;
    TranslatorOperations(TranslatorOperations&& fo) = delete;
    TranslatorOperations& operator=(const TranslatorOperations& fo) = delete;
    TranslatorOperations& operator=(TranslatorOperations&& fo) = delete;
 
    virtual void set(std::string_view property, double val);
    virtual void setString(std::string_view property, std::string_view val);
    virtual std::shared_ptr<TranslatorOperator> getOperator() = 0;
};
 
class CustomTranslatorOperation: public TranslatorOperations {
  private:
    std::shared_ptr<TranslatorOperator> to;
 
  public:
    explicit CustomTranslatorOperation(std::shared_ptr<TranslatorOperator> op): to(std::move(op)) {}
    virtual std::shared_ptr<TranslatorOperator> getOperator() override { return to; }
};
 
class JsonTranslatorOperation: public TranslatorOperations {
  private:
    std::shared_ptr<JsonTranslatorOperator> to;
 
  public:
    JsonTranslatorOperation();
    virtual std::shared_ptr<TranslatorOperator> getOperator() override
    {
        return std::static_pointer_cast<TranslatorOperator>(to);
    }
};
 
class BinaryTranslatorOperation: public TranslatorOperations {
  private:
    std::shared_ptr<BinaryTranslatorOperator> to;
 
  public:
    BinaryTranslatorOperation();
 
    virtual std::shared_ptr<TranslatorOperator> getOperator() override
    {
        return std::static_pointer_cast<TranslatorOperator>(to);
    }
};
 
}  // namespace helics