FilterOperations.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 "../common/GuardedTypes.hpp"
#include "../core/helicsTime.hpp"
#include "gmlc/libguarded/cow_guarded.hpp"
 
#include <atomic>
#include <memory>
#include <set>
#include <string>
#include <string_view>
#include <vector>
 
namespace helics {
class Core;
class FilterOperator;
class MessageTimeOperator;
class Message;
class MessageConditionalOperator;
class MessageDestOperator;
class CloneOperator;
class FirewallOperator;
class FilterOperations {
  public:
    FilterOperations() = default;
    virtual ~FilterOperations() = default;
    // still figuring out if these functions have a use or not
    FilterOperations(const FilterOperations& fo) = delete;
    FilterOperations(FilterOperations&& fo) = delete;
    FilterOperations& operator=(const FilterOperations& fo) = delete;
    FilterOperations& operator=(FilterOperations&& 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<FilterOperator> getOperator() = 0;
};
 
class DelayFilterOperation: public FilterOperations {
  private:
    std::atomic<Time> delay{timeZero};
    std::shared_ptr<MessageTimeOperator> td;
 
  public:
    explicit DelayFilterOperation(Time delayTime = timeZero);
    virtual void set(std::string_view property, double val) override;
    virtual void setString(std::string_view property, std::string_view val) override;
    virtual std::shared_ptr<FilterOperator> getOperator() override;
};
 
class RandomDelayGenerator;
 
class RandomDelayFilterOperation: public FilterOperations {
  private:
    std::shared_ptr<MessageTimeOperator> td;  
    std::unique_ptr<RandomDelayGenerator> rdelayGen;  
 
  public:
    RandomDelayFilterOperation();
    // the destructor is defined mainly to prevent the need to define the RandomDelayGenerator
    // object here
    ~RandomDelayFilterOperation();
    virtual void set(std::string_view property, double val) override;
    virtual void setString(std::string_view property, std::string_view val) override;
    virtual std::shared_ptr<FilterOperator> getOperator() override;
};
 
class RandomDropFilterOperation: public FilterOperations {
  private:
    std::atomic<double> dropProb{0.0};
    std::shared_ptr<MessageConditionalOperator> tcond;
 
  public:
    RandomDropFilterOperation();
    ~RandomDropFilterOperation();
    virtual void set(std::string_view property, double val) override;
    virtual void setString(std::string_view property, std::string_view val) override;
    virtual std::shared_ptr<FilterOperator> getOperator() override;
};
 
class RerouteFilterOperation: public FilterOperations {
  private:
    std::shared_ptr<MessageDestOperator> op;  
    atomic_guarded<std::string> newDest;  
    shared_guarded<std::set<std::string>>
        conditions;  
 
  public:
    RerouteFilterOperation();
    ~RerouteFilterOperation();
    virtual void set(std::string_view property, double val) override;
    virtual void setString(std::string_view property, std::string_view val) override;
    virtual std::shared_ptr<FilterOperator> getOperator() override;
 
  private:
    std::string rerouteOperation(const std::string& src, const std::string& dest) const;
};
 
class FirewallFilterOperation: public FilterOperations {
  private:
    std::shared_ptr<FirewallOperator> op;  
    gmlc::libguarded::cow_guarded<std::vector<std::string>> allowed;
    gmlc::libguarded::cow_guarded<std::vector<std::string>> blocked;
 
  public:
    FirewallFilterOperation();
    ~FirewallFilterOperation();
    virtual void set(std::string_view property, double val) override;
    virtual void setString(std::string_view property, std::string_view val) override;
    virtual std::shared_ptr<FilterOperator> getOperator() override;
 
  private:
    bool allowPassed(const Message* mess) const;
};
 
class CloneFilterOperation: public FilterOperations {
  private:
    std::shared_ptr<CloneOperator> op;  
    shared_guarded<std::vector<std::string>> deliveryAddresses;
 
  public:
    explicit CloneFilterOperation();
 
    ~CloneFilterOperation();
    virtual void set(std::string_view property, double val) override;
    virtual void setString(std::string_view property, std::string_view val) override;
    virtual std::shared_ptr<FilterOperator> getOperator() override;
 
  private:
    std::vector<std::unique_ptr<Message>> sendMessage(const Message* mess) const;
};
 
}  // namespace helics