cpp98/Federate.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
*/
#ifndef HELICS_CPP98_FEDERATE_HPP_
#define HELICS_CPP98_FEDERATE_HPP_
#pragma once
 
#include "Filter.hpp"
#include "Translator.hpp"
#include "config.hpp"
#include "helics/helics.h"
#include "helicsExceptions.hpp"
 
#include <complex>
#include <string>
#include <vector>
 
#if defined(HELICS_HAS_FUNCTIONAL) && HELICS_HAS_FUNCTIONAL != 0
#    include <functional>
#    include <utility>
#endif
 
namespace helicscpp {
class FederateInfo {
  public:
    FederateInfo() { fedInfo = helicsCreateFederateInfo(); }
    explicit FederateInfo(const std::string& coretype)
    {
        fedInfo = helicsCreateFederateInfo();
        helicsFederateInfoSetCoreTypeFromString(fedInfo, coretype.c_str(), hThrowOnError());
    }
    explicit FederateInfo(int coretype)
    {
        fedInfo = helicsCreateFederateInfo();
        helicsFederateInfoSetCoreType(fedInfo, coretype, hThrowOnError());
    }
    FederateInfo(const FederateInfo& otherFedInfo)
    {
        fedInfo = helicsFederateClone(otherFedInfo.fedInfo, hThrowOnError());
    }
    FederateInfo& operator=(const FederateInfo& otherFedInfo)
    {
        HelicsFederateInfo fi_new = helicsFederateClone(otherFedInfo.fedInfo, hThrowOnError());
        helicsFederateInfoFree(fedInfo);
        fedInfo = fi_new;
        return *this;
    }
#ifdef HELICS_HAS_RVALUE_REFS
    FederateInfo(FederateInfo&& otherFedInfo) HELICS_NOTHROW
    {
        fedInfo = otherFedInfo.fedInfo;
        otherFedInfo.fedInfo = HELICS_NULL_POINTER;
    }
    FederateInfo& operator=(FederateInfo&& otherFedInfo) HELICS_NOTHROW
    {
        helicsFederateInfoFree(fedInfo);
        fedInfo = otherFedInfo.fedInfo;
        otherFedInfo.fedInfo = HELICS_NULL_POINTER;
        return *this;
    }
#endif
    ~FederateInfo() { helicsFederateInfoFree(fedInfo); }
    void loadFromArgs(const std::string& argString)
    {
        helicsFederateInfoLoadFromString(fedInfo, argString.c_str(), HELICS_NULL_POINTER);
    }
    void setCoreName(const std::string& coreName)
    {
        helicsFederateInfoSetCoreName(fedInfo, coreName.c_str(), HELICS_NULL_POINTER);
    }
    void setSeparator(char sep)
    {
        helicsFederateInfoSetSeparator(fedInfo, sep, HELICS_NULL_POINTER);
    }
    void setCoreInit(const std::string& coreInit)
    {
        helicsFederateInfoSetCoreInitString(fedInfo, coreInit.c_str(), HELICS_NULL_POINTER);
    }
    void setBrokerInit(const std::string& brokerInit)
    {
        helicsFederateInfoSetBrokerInitString(fedInfo, brokerInit.c_str(), HELICS_IGNORE_ERROR);
    }
    void setCoreType(const std::string& coretype)
    {
        helicsFederateInfoSetCoreTypeFromString(fedInfo, coretype.c_str(), hThrowOnError());
    }
    void setCoreType(int coretype)
    {
        helicsFederateInfoSetCoreType(fedInfo, coretype, HELICS_NULL_POINTER);
    }
    void setBroker(const std::string& broker)
    {
        helicsFederateInfoSetBroker(fedInfo, broker.c_str(), HELICS_NULL_POINTER);
    }
    void setBrokerKey(const std::string& brokerkey)
    {
        helicsFederateInfoSetBrokerKey(fedInfo, brokerkey.c_str(), HELICS_NULL_POINTER);
    }
    void setFlagOption(int flag, bool value = true)
    {
        helicsFederateInfoSetFlagOption(fedInfo,
                                        flag,
                                        value ? HELICS_TRUE : HELICS_FALSE,
                                        HELICS_NULL_POINTER);
    }
    void setProperty(int timeProperty, HelicsTime timeValue)
    {
        helicsFederateInfoSetTimeProperty(fedInfo, timeProperty, timeValue, HELICS_NULL_POINTER);
    }
    void setProperty(int integerProperty, int propertyValue)
    {
        helicsFederateInfoSetIntegerProperty(fedInfo,
                                             integerProperty,
                                             propertyValue,
                                             HELICS_NULL_POINTER);
    }
 
    HelicsFederateInfo getInfo() { return fedInfo; }
 
  private:
    HelicsFederateInfo fedInfo;  
};
 
#if defined(HELICS_HAS_FUNCTIONAL) && HELICS_HAS_FUNCTIONAL != 0
namespace details {
    inline void helicCppQueryCallbackExecutor(const char* query,
                                              int stringSize,
                                              HelicsQueryBuffer buffer,
                                              void* userData)
    {
        auto cback = reinterpret_cast<std::function<std::string(const std::string&)>*>(userData);
        std::string val(query, stringSize);
        std::string result = (*cback)(val);
        helicsQueryBufferFill(buffer, result.c_str(), static_cast<int>(result.size()), nullptr);
    }
 
    inline void
        helicCppTimeUpdateCallbackExecutor(HelicsTime time, HelicsBool iterating, void* userData)
    {
        auto cback = reinterpret_cast<std::function<void(HelicsTime, bool)>*>(userData);
        (*cback)(time, iterating == HELICS_TRUE);
    }
 
    inline void helicCppStateChangeCallbackExecutor(HelicsFederateState newState,
                                                    HelicsFederateState oldState,
                                                    void* userData)
    {
        auto cback =
            reinterpret_cast<std::function<void(HelicsFederateState, HelicsFederateState)>*>(
                userData);
        (*cback)(newState, oldState);
    }
 
    inline void helicCppTimeRequestEntryCallbackExecutor(HelicsTime currentTime,
                                                         HelicsTime requestTime,
                                                         HelicsBool iterating,
                                                         void* userData)
    {
        auto cback = reinterpret_cast<std::function<void(HelicsTime, HelicsTime, bool)>*>(userData);
        (*cback)(currentTime, requestTime, iterating == HELICS_TRUE);
    }
    inline void helicCppTimeRequestReturnCallbackExecutor(HelicsTime newTime,
                                                          HelicsBool iterating,
                                                          void* userData)
    {
        auto cback = reinterpret_cast<std::function<void(HelicsTime, bool)>*>(userData);
        (*cback)(newTime, iterating == HELICS_TRUE);
    }
}  // namespace details
#endif
 
typedef struct HelicsIterationTime {
    HelicsTime grantedTime;  
    HelicsIterationResult status;  
} HelicsIterationTime;
 
class Federate {
  public:
    Federate() HELICS_NOTHROW: fed(NULL), exec_async_iterate(false) {}
    Federate(const Federate& fedObj): exec_async_iterate(fedObj.exec_async_iterate)
    {
        fed = helicsFederateClone(fedObj.fed, hThrowOnError());
    }
    Federate& operator=(const Federate& fedObj)
    {
        exec_async_iterate = fedObj.exec_async_iterate;
        fed = helicsFederateClone(fedObj.fed, hThrowOnError());
        return *this;
    }
#ifdef HELICS_HAS_RVALUE_REFS
    Federate(Federate&& fedObj) HELICS_NOTHROW:
        fed(fedObj.fed),
        exec_async_iterate(fedObj.exec_async_iterate)
    {
        fedObj.fed = HELICS_NULL_POINTER;
    }
    Federate& operator=(Federate&& fedObj) HELICS_NOTHROW
    {
        exec_async_iterate = fedObj.exec_async_iterate;
        fed = fedObj.fed;
        fedObj.fed = HELICS_NULL_POINTER;
        return *this;
    }
#endif
    virtual ~Federate()
    {
        if (fed != HELICS_NULL_POINTER) {
            helicsFederateFree(fed);
        }
#if defined(HELICS_HAS_FUNCTIONAL) && HELICS_HAS_FUNCTIONAL != 0
        freeCallbacks();
#endif
    }
    operator HelicsFederate() const { return fed; }
    HelicsFederate baseObject() const { return fed; }
    void setFlagOption(int flag, bool flagValue = true)
    {
        helicsFederateSetFlagOption(fed,
                                    flag,
                                    flagValue ? HELICS_TRUE : HELICS_FALSE,
                                    hThrowOnError());
    }
    void setProperty(int tProperty, HelicsTime timeValue)
    {
        helicsFederateSetTimeProperty(fed, tProperty, timeValue, hThrowOnError());
    }
    void setProperty(int intProperty, int value)
    {
        helicsFederateSetIntegerProperty(fed, intProperty, value, hThrowOnError());
    }
 
    bool getFlagOption(int flag) const
    {
        return (helicsFederateGetFlagOption(fed, flag, hThrowOnError()) != HELICS_FALSE);
    }
    HelicsTime getTimeProperty(int tProperty) const
    {
        return helicsFederateGetTimeProperty(fed, tProperty, hThrowOnError());
    }
    int getIntegerProperty(int intProperty) const
    {
        return helicsFederateGetIntegerProperty(fed, intProperty, hThrowOnError());
    }
    void setSeparator(char sep) { helicsFederateSetSeparator(fed, sep, HELICS_NULL_POINTER); }
    void registerInterfaces(const std::string& configString)
    {
        helicsFederateRegisterInterfaces(fed, configString.c_str(), hThrowOnError());
    }
    HelicsFederateState getCurrentMode() const
    {
        return helicsFederateGetState(fed, HELICS_NULL_POINTER);
    }
    bool isAsyncOperationCompleted() const
    {
        // returns int, 1 = true, 0 = false
        return helicsFederateIsAsyncOperationCompleted(fed, HELICS_NULL_POINTER) != HELICS_FALSE;
    }
    void enterInitializingMode() { helicsFederateEnterInitializingMode(fed, hThrowOnError()); }
    void enterInitializingModeAsync()
    {
        helicsFederateEnterInitializingModeAsync(fed, hThrowOnError());
    }
 
    void enterInitializingModeComplete()
    {
        helicsFederateEnterInitializingModeComplete(fed, hThrowOnError());
    }
 
    void enterInitializingModeIterative()
    {
        helicsFederateEnterInitializingModeIterative(fed, hThrowOnError());
    }
    void enterInitializingModeIterativeAsync()
    {
        helicsFederateEnterInitializingModeIterativeAsync(fed, hThrowOnError());
    }
 
    void enterInitializingModeIterativeComplete()
    {
        helicsFederateEnterInitializingModeIterativeComplete(fed, hThrowOnError());
    }
 
    HelicsIterationResult
        enterExecutingMode(HelicsIterationRequest iterate = HELICS_ITERATION_REQUEST_NO_ITERATION)
    {
        HelicsIterationResult out_iterate = HELICS_ITERATION_RESULT_NEXT_STEP;
        if (iterate == HELICS_ITERATION_REQUEST_NO_ITERATION) {
            helicsFederateEnterExecutingMode(fed, hThrowOnError());
        } else {
            out_iterate = helicsFederateEnterExecutingModeIterative(fed, iterate, hThrowOnError());
        }
        return out_iterate;
    }
    void enterExecutingModeAsync(
        HelicsIterationRequest iterate = HELICS_ITERATION_REQUEST_NO_ITERATION)
    {
        if (iterate == HELICS_ITERATION_REQUEST_NO_ITERATION) {
            helicsFederateEnterExecutingModeAsync(fed, hThrowOnError());
            exec_async_iterate = false;
        } else {
            helicsFederateEnterExecutingModeIterativeAsync(fed, iterate, hThrowOnError());
            exec_async_iterate = true;
        }
    }
 
    HelicsIterationResult enterExecutingModeComplete()
    {
        HelicsIterationResult out_iterate = HELICS_ITERATION_RESULT_NEXT_STEP;
        if (exec_async_iterate) {
            out_iterate = helicsFederateEnterExecutingModeIterativeComplete(fed, hThrowOnError());
        } else {
            helicsFederateEnterExecutingModeComplete(fed, hThrowOnError());
        }
        return out_iterate;
    }
    void finalize() { helicsFederateFinalize(fed, hThrowOnError()); }
    void finalizeAsync() { helicsFederateFinalizeAsync(fed, hThrowOnError()); }
    void finalizeComplete() { helicsFederateFinalizeComplete(fed, hThrowOnError()); }
    HelicsTime getCurrentTime() { return helicsFederateGetCurrentTime(fed, hThrowOnError()); }
    HelicsTime requestTime(HelicsTime time)
    {
        return helicsFederateRequestTime(fed, time, hThrowOnError());
    }
    HelicsTime requestNextStep() { return helicsFederateRequestNextStep(fed, hThrowOnError()); }
 
    HelicsTime requestTimeAdvance(HelicsTime timeDelta)
    {
        return helicsFederateRequestTimeAdvance(fed, timeDelta, hThrowOnError());
    }
    HelicsIterationTime requestTimeIterative(HelicsTime time, HelicsIterationRequest iterate)
    {
        HelicsIterationTime itTime;
        itTime.grantedTime = helicsFederateRequestTimeIterative(
            fed, time, iterate, &(itTime.status), hThrowOnError());
        return itTime;
    }
    void requestTimeAsync(HelicsTime time)
    {
        helicsFederateRequestTimeAsync(fed, time, hThrowOnError());
    }
 
    void requestTimeIterativeAsync(HelicsTime time, HelicsIterationRequest iterate)
    {
        helicsFederateRequestTimeIterativeAsync(fed, time, iterate, hThrowOnError());
    }
 
    HelicsTime requestTimeComplete()
    {
        return helicsFederateRequestTimeComplete(fed, hThrowOnError());
    }
 
    HelicsIterationTime requestTimeIterativeComplete()
    {
        HelicsIterationTime itTime;
        itTime.grantedTime =
            helicsFederateRequestTimeIterativeComplete(fed, &(itTime.status), hThrowOnError());
        return itTime;
    }
 
    void processCommunication(HelicsTime period)
    {
        helicsFederateProcessCommunications(fed, period, HELICS_IGNORE_ERROR);
    }
    const char* getName() const { return helicsFederateGetName(fed); }
 
    void protect() { helicsFederateProtect(helicsFederateGetName(fed), HELICS_IGNORE_ERROR); }
 
    void unProtect() { helicsFederateUnProtect(helicsFederateGetName(fed), HELICS_IGNORE_ERROR); }
 
    std::string query(const std::string& target,
                      const std::string& queryStr,
                      HelicsSequencingModes mode = HELICS_SEQUENCING_MODE_FAST) const
    {
        // returns HelicsQuery
        HelicsQuery q = helicsCreateQuery(target.c_str(), queryStr.c_str());
        if (mode != HELICS_SEQUENCING_MODE_FAST) {
            helicsQuerySetOrdering(q, mode, HELICS_IGNORE_ERROR);
        }
        std::string result(helicsQueryExecute(q, fed, hThrowOnError()));
        helicsQueryFree(q);
        return result;
    }
 
    std::string query(const std::string& queryStr,
                      HelicsSequencingModes mode = HELICS_SEQUENCING_MODE_FAST) const
    {
        // returns HelicsQuery
        HelicsQuery q = helicsCreateQuery(HELICS_NULL_POINTER, queryStr.c_str());
        if (mode != HELICS_SEQUENCING_MODE_FAST) {
            helicsQuerySetOrdering(q, mode, HELICS_IGNORE_ERROR);
        }
        std::string result(helicsQueryExecute(q, fed, hThrowOnError()));
        helicsQueryFree(q);
        return result;
    }
 
    void sendCommand(const std::string& target, const std::string& cmd)
    {
        helicsFederateSendCommand(fed, target.c_str(), cmd.c_str(), HELICS_IGNORE_ERROR);
    }
 
    const char* getCommand() { return helicsFederateGetCommand(fed, HELICS_IGNORE_ERROR); }
 
    const char* waitCommand() { return helicsFederateWaitCommand(fed, HELICS_IGNORE_ERROR); }
 
    const char* getCommandSource()
    {
        return helicsFederateGetCommandSource(fed, HELICS_IGNORE_ERROR);
    }
 
    void setQueryCallback(
        void (*queryAnswer)(const char* query, int querySize, HelicsQueryBuffer, void* userdata),
        void* userdata)
 
    {
        helicsFederateSetQueryCallback(fed, queryAnswer, userdata, hThrowOnError());
    }
 
    void setTimeRequestEntryCallback(void (*timeRequestEntry)(HelicsTime currentTime,
                                                              HelicsTime requestTime,
                                                              HelicsBool iterating,
                                                              void* userdata),
                                     void* userdata)
 
    {
        helicsFederateSetTimeRequestEntryCallback(fed, timeRequestEntry, userdata, hThrowOnError());
    }
 
    void setTimeUpdateCallback(void (*timeUpdate)(HelicsTime time,
                                                  HelicsBool iterating,
                                                  void* userdata),
                               void* userdata)
 
    {
        helicsFederateSetTimeUpdateCallback(fed, timeUpdate, userdata, hThrowOnError());
    }
 
    void setStateChangeCallback(void (*stateChange)(HelicsFederateState newState,
                                                    HelicsFederateState oldState,
                                                    void* userdata),
                                void* userdata)
 
    {
        helicsFederateSetStateChangeCallback(fed, stateChange, userdata, hThrowOnError());
    }
 
    void setTimeRequestReturnCallback(void (*timeRequestReturn)(HelicsTime newTime,
                                                                HelicsBool iterating,
                                                                void* userdata),
                                      void* userdata)
 
    {
        helicsFederateSetTimeRequestReturnCallback(fed,
                                                   timeRequestReturn,
                                                   userdata,
                                                   hThrowOnError());
    }
#if defined(HELICS_HAS_FUNCTIONAL) && HELICS_HAS_FUNCTIONAL != 0
    void setQueryCallback(std::function<std::string(const std::string&)> callback)
 
    {
        checkCallbackAllocation();
        callbackBuffers[queryCallbackLocation] =
            new std::function<std::string(const std::string&)>(std::move(callback));
        helicsFederateSetQueryCallback(fed,
                                       details::helicCppQueryCallbackExecutor,
                                       callbackBuffers[queryCallbackLocation],
                                       hThrowOnError());
    }
 
    void setTimeRequestEntryCallback(
        std::function<void(HelicsTime currentTime, HelicsTime requestTime, bool iterating)>
            callback)
 
    {
        checkCallbackAllocation();
        callbackBuffers[timeRequestEntryCallbackLocation] =
            new std::function<void(HelicsTime, HelicsTime, bool)>(std::move(callback));
        helicsFederateSetTimeRequestEntryCallback(fed,
                                                  details::helicCppTimeRequestEntryCallbackExecutor,
                                                  callbackBuffers[timeRequestEntryCallbackLocation],
                                                  hThrowOnError());
    }
 
    void setTimeUpdateCallback(std::function<void(HelicsTime time, bool iterating)> callback)
 
    {
        checkCallbackAllocation();
        callbackBuffers[timeUpdateCallbackLocation] =
            new std::function<void(HelicsTime time, bool iterating)>(std::move(callback));
        helicsFederateSetTimeUpdateCallback(fed,
                                            details::helicCppTimeUpdateCallbackExecutor,
                                            callbackBuffers[timeUpdateCallbackLocation],
                                            hThrowOnError());
    }
 
    void setStateChangeCallback(
        std::function<void(HelicsFederateState, HelicsFederateState)> callback)
 
    {
        checkCallbackAllocation();
        callbackBuffers[stateChangeCallbackLocation] =
            new std::function<void(HelicsFederateState, HelicsFederateState)>(std::move(callback));
        helicsFederateSetStateChangeCallback(fed,
                                             details::helicCppStateChangeCallbackExecutor,
                                             callbackBuffers[stateChangeCallbackLocation],
                                             hThrowOnError());
    }
 
    void setTimeRequestReturnCallback(
        std::function<void(HelicsTime newTime, bool iterating)> callback)
 
    {
        checkCallbackAllocation();
        callbackBuffers[timeRequestReturnCallbackLocation] =
            new std::function<void(HelicsTime, bool)>(std::move(callback));
        helicsFederateSetTimeRequestReturnCallback(
            fed,
            details::helicCppTimeRequestReturnCallbackExecutor,
            callbackBuffers[timeRequestReturnCallbackLocation],
            hThrowOnError());
    }
#endif
    Filter registerFilter(HelicsFilterTypes type, const std::string& filterName = std::string())
    {
        return Filter(helicsFederateRegisterFilter(fed, type, filterName.c_str(), hThrowOnError()));
    }
 
    CloningFilter registerCloningFilter(const std::string& deliveryEndpoint)
    {
        return CloningFilter(
            helicsFederateRegisterCloningFilter(fed, deliveryEndpoint.c_str(), hThrowOnError()));
    }
    Filter registerGlobalFilter(HelicsFilterTypes type,
                                const std::string& filterName = std::string())
    {
        return Filter(
            helicsFederateRegisterGlobalFilter(fed, type, filterName.c_str(), hThrowOnError()));
    }
 
    CloningFilter registerGlobalCloningFilter(const std::string& deliveryEndpoint)
    {
        return CloningFilter(helicsFederateRegisterGlobalCloningFilter(fed,
                                                                       deliveryEndpoint.c_str(),
                                                                       hThrowOnError()));
    }
    int getFilterCount() const { return helicsFederateGetFilterCount(fed); }
    Filter getFilter(const std::string& filterName)
    {
        return Filter(helicsFederateGetFilter(fed, filterName.c_str(), hThrowOnError()));
    }
    Filter getFilter(int index)
    {
        return Filter(helicsFederateGetFilterByIndex(fed, index, hThrowOnError()));
    }
 
    void setGlobal(const std::string& valueName, const std::string& value)
    {
        helicsFederateSetGlobal(fed, valueName.c_str(), value.c_str(), hThrowOnError());
    }
 
    void addAlias(const std::string& interfaceName, const std::string& alias)
    {
        helicsFederateAddAlias(fed, interfaceName.c_str(), alias.c_str(), hThrowOnError());
    }
 
    void setTag(const std::string& tag, const std::string& value)
    {
        helicsFederateSetTag(fed, tag.c_str(), value.c_str(), hThrowOnError());
    }
    const char* getTag(const std::string& tag) const
    {
        return helicsFederateGetTag(fed, tag.c_str(), hThrowOnError());
    }
 
    void addDependency(const std::string& fedName)
    {
        helicsFederateAddDependency(fed, fedName.c_str(), hThrowOnError());
    }
 
    void localError(int errorCode, const std::string& errorString)
    {
        helicsFederateLocalError(fed, errorCode, errorString.c_str(), hThrowOnError());
    }
 
    void globalError(int errorCode, const std::string& errorString)
    {
        helicsFederateGlobalError(fed, errorCode, errorString.c_str(), hThrowOnError());
    }
 
    void logErrorMessage(const std::string& message)
    {
        helicsFederateLogErrorMessage(fed, message.c_str(), hThrowOnError());
    }
    void logWarningMessage(const std::string& message)
    {
        helicsFederateLogWarningMessage(fed, message.c_str(), hThrowOnError());
    }
    void logInfoMessage(const std::string& message)
    {
        helicsFederateLogInfoMessage(fed, message.c_str(), hThrowOnError());
    }
    void logDebugMessage(const std::string& message)
    {
        helicsFederateLogDebugMessage(fed, message.c_str(), hThrowOnError());
    }
    void logMessage(int level, const std::string& message)
    {
        helicsFederateLogLevelMessage(fed, level, message.c_str(), hThrowOnError());
    }
    HelicsCore getCore() { return helicsFederateGetCore(fed, hThrowOnError()); }
    HelicsFederate getObject() const { return fed; }
 
  protected:
    HelicsFederate fed;  
    bool exec_async_iterate;  
#if defined(HELICS_HAS_FUNCTIONAL) && HELICS_HAS_FUNCTIONAL != 0
  private:
    static constexpr int numberOfCallbacks = 5;
    static constexpr int timeRequestEntryCallbackLocation = 0;
    static constexpr int timeUpdateCallbackLocation = 1;
    static constexpr int stateChangeCallbackLocation = 2;
    static constexpr int queryCallbackLocation = 3;
    static constexpr int timeRequestReturnCallbackLocation = 4;
    void** callbackBuffers{nullptr};
 
    void checkCallbackAllocation()
    {
        if (callbackBuffers == nullptr) {
            callbackBuffers = new void*[numberOfCallbacks];
            for (int ii = 0; ii < numberOfCallbacks; ++ii) {
                callbackBuffers[ii] = nullptr;
            }
        }
    }
    void freeCallbacks()
    {
        if (callbackBuffers == nullptr) {
            return;
        }
        if (callbackBuffers[queryCallbackLocation] != nullptr) {
            auto cback = reinterpret_cast<std::function<std::string(const std::string&)>*>(
                callbackBuffers[queryCallbackLocation]);
            delete cback;
        }
        if (callbackBuffers[timeRequestEntryCallbackLocation] != nullptr) {
            auto cback = reinterpret_cast<std::function<void(HelicsTime, HelicsTime, bool)>*>(
                callbackBuffers[timeRequestEntryCallbackLocation]);
            delete cback;
        }
        if (callbackBuffers[timeUpdateCallbackLocation] != nullptr) {
            auto cback = reinterpret_cast<std::function<void(HelicsTime, bool)>*>(
                callbackBuffers[timeUpdateCallbackLocation]);
            delete cback;
        }
        if (callbackBuffers[stateChangeCallbackLocation] != nullptr) {
            auto cback =
                reinterpret_cast<std::function<void(HelicsFederateState, HelicsFederateState)>*>(
                    callbackBuffers[stateChangeCallbackLocation]);
            delete cback;
        }
        if (callbackBuffers[timeRequestReturnCallbackLocation] != nullptr) {
            auto cback = reinterpret_cast<std::function<void(HelicsTime, bool)>*>(
                callbackBuffers[timeRequestReturnCallbackLocation]);
            delete cback;
        }
        delete[] callbackBuffers;
    }
#endif
};
 
inline void protect(const std::string& name)
{
    helicsFederateProtect(name.c_str(), hThrowOnError());
}
inline void unProtect(const std::string& name)
{
    helicsFederateUnProtect(name.c_str(), hThrowOnError());
}
 
inline bool isProtected(const std::string& name)
{
    return (helicsFederateIsProtected(name.c_str(), hThrowOnError()) == HELICS_TRUE) ? true : false;
}
 
}  // namespace helicscpp
 
#endif