Filters.hpp

/*
Copyright (c) 2017-2025,
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.hpp"
#include "Federate.hpp"
#include "helics/helics_enums.h"
 
#include <memory>
#include <string>
 
namespace helics {
class FilterOperations;
class FilterOperator;
class CoreApp;
enum class FilterTypes {
    CUSTOM = HELICS_FILTER_TYPE_CUSTOM,
    DELAY = HELICS_FILTER_TYPE_DELAY,
    RANDOM_DELAY = HELICS_FILTER_TYPE_RANDOM_DELAY,
    RANDOM_DROP = HELICS_FILTER_TYPE_RANDOM_DROP,
    REROUTE = HELICS_FILTER_TYPE_REROUTE,
    CLONE = HELICS_FILTER_TYPE_CLONE,
    FIREWALL = HELICS_FILTER_TYPE_FIREWALL,
    UNRECOGNIZED = 7
 
};
 
#define EMPTY_STRING std::string_view()
 
HELICS_CXX_EXPORT FilterTypes filterTypeFromString(std::string_view filterType) noexcept;
 
class HELICS_CXX_EXPORT Filter: public Interface {
  protected:
    bool cloning = false;
    bool disableAssign = false;  
  private:
    std::shared_ptr<FilterOperations>
        filtOp;  
  public:
    Filter() = default;
    explicit Filter(Federate* ffed, std::string_view filtName = EMPTY_STRING);
    Filter(Federate* ffed, std::string_view filtName, InterfaceHandle ihandle);
    Filter(Core* core, std::string_view filtName, InterfaceHandle ihandle);
    Filter(InterfaceVisibility locality, Federate* ffed, std::string_view filtName = EMPTY_STRING);
    explicit Filter(Core* core, std::string_view filtName = EMPTY_STRING);
    virtual ~Filter() = default;
 
    Filter(Filter&& filt) = default;
    Filter(const Filter& filt) = default;
    Filter& operator=(Filter&& filt) = default;
    Filter& operator=(const Filter& filt) = default;
    bool isCloningFilter() const { return cloning; }
    void setOperator(std::shared_ptr<FilterOperator> filterOp);
 
    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);
 
    virtual std::string getString(std::string_view property);
 
    virtual double getProperty(std::string_view property);
 
    void addTarget(std::string_view target) { addSourceTarget(target); }
 
    void setFilterType(std::int32_t type);
 
  protected:
    void setFilterOperations(std::shared_ptr<FilterOperations> filterOps);
    friend void addOperations(Filter* filt, FilterTypes type, Core* cptr);
};
 
class HELICS_CXX_EXPORT CloningFilter: public Filter {
  public:
    CloningFilter() = default;
    explicit CloningFilter(Core* core, std::string_view filtName = EMPTY_STRING);
    explicit CloningFilter(Federate* ffed, std::string_view filtName = EMPTY_STRING);
    CloningFilter(InterfaceVisibility locality,
                  Federate* ffed,
                  std::string_view filtName = EMPTY_STRING);
 
    CloningFilter(Federate* ffed, std::string_view filtName, InterfaceHandle handle);
    CloningFilter(CloningFilter&& filt) = default;
    CloningFilter(const CloningFilter& filt) = default;
    CloningFilter& operator=(CloningFilter&& filt) = default;
    CloningFilter& operator=(const CloningFilter& filt) = default;
    ~CloningFilter() = default;
    void addDeliveryEndpoint(std::string_view endpoint);
 
    void removeDeliveryEndpoint(std::string_view endpoint);
 
    virtual void setString(std::string_view property, std::string_view val) override;
 
  private:
    friend class FilterFederateManager;
};
 
HELICS_CXX_EXPORT Filter&
    make_filter(FilterTypes type, Federate* fed, std::string_view name = EMPTY_STRING);
 
HELICS_CXX_EXPORT Filter& make_filter(InterfaceVisibility locality,
                                      FilterTypes type,
                                      Federate* fed,
                                      std::string_view name = EMPTY_STRING);
 
HELICS_CXX_EXPORT std::unique_ptr<Filter>
    make_filter(FilterTypes type, Core* core, std::string_view name = EMPTY_STRING);
 
HELICS_CXX_EXPORT std::unique_ptr<Filter>
    make_filter(FilterTypes type, CoreApp& core, std::string_view name = EMPTY_STRING);
 
HELICS_CXX_EXPORT CloningFilter& make_cloning_filter(FilterTypes type,
                                                     Federate* fed,
                                                     std::string_view delivery,
                                                     std::string_view name = EMPTY_STRING);
 
HELICS_CXX_EXPORT CloningFilter& make_cloning_filter(InterfaceVisibility locality,
                                                     FilterTypes type,
                                                     Federate* fed,
                                                     std::string_view delivery,
                                                     std::string_view name = EMPTY_STRING);
 
HELICS_CXX_EXPORT std::unique_ptr<CloningFilter>
    make_cloning_filter(FilterTypes type,
                        Core* core,
                        std::string_view delivery,
                        std::string_view name = EMPTY_STRING);
 
HELICS_CXX_EXPORT std::unique_ptr<CloningFilter>
    make_cloning_filter(FilterTypes type,
                        CoreApp& core,
                        std::string_view delivery,
                        std::string_view name = EMPTY_STRING);
 
}  // namespace helics