Filter.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
*/
#ifndef HELICS_CPP98_FILTER_HPP_
#define HELICS_CPP98_FILTER_HPP_
#pragma once
 
#include "helics/helics.h"
#include "helicsExceptions.hpp"
 
#include <string>
 
namespace helicscpp {
class Filter {
  public:
    explicit Filter(HelicsFilter hfilt) HELICS_NOTHROW: filt(hfilt) {}
    Filter() HELICS_NOTHROW: filt(HELICS_NULL_POINTER) {}
    Filter(const Filter& filter): filt(filter.filt) {}
    Filter& operator=(const Filter& filter)
    {
        filt = filter.filt;
        return *this;
    }
 
    operator HelicsFilter() const { return filt; }
    HELICS_NODISCARD HelicsFilter baseObject() const { return filt; }
    bool isValid() const { return (helicsFilterIsValid(filt) == HELICS_TRUE); }
    const char* getName() const { return helicsFilterGetName(filt); }
    void set(const std::string& property, double val)
    {
        helicsFilterSet(filt, property.c_str(), val, hThrowOnError());
    }
    void setString(const std::string& property, const std::string& val)
    {
        helicsFilterSetString(filt, property.c_str(), val.c_str(), hThrowOnError());
    }
    HELICS_NODISCARD double getProperty(const std::string& property)
    {
        return helicsFilterGetPropertyDouble(filt, property.c_str());
    }
    HELICS_NODISCARD const char* getString(const std::string& property)
    {
        return helicsFilterGetPropertyString(filt, property.c_str());
    }
 
    void addDestinationTarget(const std::string& dest)
    {
        helicsFilterAddDestinationTarget(filt, dest.c_str(), hThrowOnError());
    }
 
    void addSourceTarget(const std::string& source)
    {
        helicsFilterAddSourceTarget(filt, source.c_str(), hThrowOnError());
    }
 
    void removeTarget(const std::string& dest)
    {
        helicsFilterRemoveTarget(filt, dest.c_str(), hThrowOnError());
    }
    HELICS_NODISCARD const char* getInfo() const { return helicsFilterGetInfo(filt); }
    void setInfo(const std::string& info)
    {
        helicsFilterSetInfo(filt, info.c_str(), HELICS_IGNORE_ERROR);
    }
    HELICS_NODISCARD const char* getTag(const std::string& tagname) const
    {
        return helicsFilterGetTag(filt, tagname.c_str());
    }
    void setTag(const std::string& tagname, const std::string& tagvalue)
    {
        helicsFilterSetTag(filt, tagname.c_str(), tagvalue.c_str(), HELICS_IGNORE_ERROR);
    }
    void setOption(int32_t option, int32_t value = 1)
    {
        helicsFilterSetOption(filt, option, value, HELICS_IGNORE_ERROR);
    }
    HELICS_NODISCARD int32_t getOption(int32_t option)
    {
        return helicsFilterGetOption(filt, option);
    }
 
    void setCallback(HelicsMessage (*filtCall)(HelicsMessage message, void* userData),
                     void* userData)
    {
        helicsFilterSetCustomCallback(filt, filtCall, userData, HELICS_IGNORE_ERROR);
    }
 
  protected:
    HelicsFilter filt;  
};
 
class CloningFilter: public Filter {
  public:
    explicit CloningFilter(HelicsFilter hfilt) HELICS_NOTHROW: Filter(hfilt) {}
    CloningFilter() HELICS_NOTHROW {};
    CloningFilter(const CloningFilter& filter): Filter(filter) {}
    CloningFilter& operator=(const CloningFilter& filter)
    {
        Filter::operator=(filter);
        return *this;
    }
 
    void addDeliveryEndpoint(const std::string& deliveryEndpoint)
    {
        helicsFilterAddDeliveryEndpoint(filt, deliveryEndpoint.c_str(), hThrowOnError());
    }
 
    void removeDeliveryEndpoint(const std::string& deliveryEndpoint)
    {
        helicsFilterRemoveDeliveryEndpoint(filt, deliveryEndpoint.c_str(), hThrowOnError());
    }
};
 
}  // namespace helicscpp
#endif