MessageOperators.hpp

Go to the documentation of this file.

/*
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
*/
#pragma once
 
#include "../core/core-data.hpp"
#include "data_view.hpp"
#include "helics_cxx_export.h"
 
#include <atomic>
#include <functional>
#include <memory>
#include <string>
#include <vector>
namespace helics {
class HELICS_CXX_EXPORT MessageTimeOperator: public FilterOperator {
  public:
    MessageTimeOperator() = default;
    explicit MessageTimeOperator(std::function<Time(Time)> userTimeFunction);
    void setTimeFunction(std::function<Time(Time)> userTimeFunction);
 
  private:
    std::function<Time(Time)> TimeFunction;  
    virtual std::unique_ptr<Message> process(std::unique_ptr<Message> message) override;
};
 
class HELICS_CXX_EXPORT MessageDestOperator: public FilterOperator {
  public:
    MessageDestOperator() = default;
    explicit MessageDestOperator(
        std::function<std::string(const std::string&, const std::string&)> userDestFunction);
    void setDestFunction(
        std::function<std::string(const std::string&, const std::string&)> userDestFunction);
    virtual bool isMessageGenerating() const override { return true; }
 
  private:
    std::function<std::string(const std::string&, const std::string&)>
        DestUpdateFunction;  
    virtual std::unique_ptr<Message> process(std::unique_ptr<Message> message) override;
};
 
class HELICS_CXX_EXPORT MessageDataOperator: public FilterOperator {
  public:
    MessageDataOperator() = default;
    explicit MessageDataOperator(std::function<void(SmallBuffer&)> userDataFunction);
    void setDataFunction(std::function<void(SmallBuffer&)> userDataFunction);
 
  private:
    std::function<void(SmallBuffer&)> dataFunction;  
    virtual std::unique_ptr<Message> process(std::unique_ptr<Message> message) override;
};
 
class HELICS_CXX_EXPORT MessageConditionalOperator: public FilterOperator {
  public:
    MessageConditionalOperator() = default;
    explicit MessageConditionalOperator(
        std::function<bool(const Message*)> userConditionalFunction);
    void setConditionFunction(std::function<bool(const Message*)> userConditionFunction);
 
  private:
    std::function<bool(const Message*)>
        evalFunction;  
    virtual std::unique_ptr<Message> process(std::unique_ptr<Message> message) override;
};
 
class HELICS_CXX_EXPORT CloneOperator: public FilterOperator {
  public:
    CloneOperator() = default;
    explicit CloneOperator(
        std::function<std::vector<std::unique_ptr<Message>>(const Message*)> userCloneFunction);
    void setCloneFunction(
        std::function<std::vector<std::unique_ptr<Message>>(const Message*)> userCloneFunction);
    virtual bool isMessageGenerating() const override { return true; }
 
  private:
    std::function<std::vector<std::unique_ptr<Message>>(const Message*)>
        evalFunction;  
    virtual std::unique_ptr<Message> process(std::unique_ptr<Message> message) override;
    virtual std::vector<std::unique_ptr<Message>>
        processVector(std::unique_ptr<Message> message) override;
};
 
class HELICS_CXX_EXPORT FirewallOperator: public FilterOperator {
  public:
    enum class operations : int {
        none = -1,
        drop = 0,
        pass = 1,
        set_flag1 = 2,
        set_flag2 = 3,
        set_flag3 = 4
    };
    FirewallOperator() = default;
    explicit FirewallOperator(std::function<bool(const Message*)> userCheckFunction);
    void setCheckFunction(std::function<bool(const Message*)> userCheckFunction);
    void setOperation(operations newop) { operation.store(newop); }
 
  private:
    std::function<bool(const Message*)>
        checkFunction;  
    std::atomic<operations> operation{
        operations::drop};  
    virtual std::unique_ptr<Message> process(std::unique_ptr<Message> message) override;
};
 
class HELICS_CXX_EXPORT CustomMessageOperator: public FilterOperator {
  public:
    CustomMessageOperator() = default;
    explicit CustomMessageOperator(
        std::function<std::unique_ptr<Message>(std::unique_ptr<Message>)> userMessageFunction);
    void setMessageFunction(
        std::function<std::unique_ptr<Message>(std::unique_ptr<Message>)> userMessageFunction);
 
  private:
    std::function<std::unique_ptr<Message>(std::unique_ptr<Message>)>
        messageFunction;  
    virtual std::unique_ptr<Message> process(std::unique_ptr<Message> message) override;
};
}  // namespace helics