CallbackFederate.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 "CombinationFederate.hpp"
 
#include <memory>
#include <string>
#include <utility>
 
namespace helics {
class CallbackFederateOperator;
 
class HELICS_CXX_EXPORT CallbackFederate: public CombinationFederate {
  public:
    CallbackFederate();
 
    explicit CallbackFederate(std::string_view fedName, const FederateInfo& fedInfo);
 
    CallbackFederate(std::string_view fedName,
                     const std::shared_ptr<Core>& core,
                     const FederateInfo& fedInfo = FederateInfo{});
 
    CallbackFederate(std::string_view fedName,
                     CoreApp& core,
                     const FederateInfo& fedInfo = FederateInfo{});
 
    CallbackFederate(std::string_view fedName, const std::string& configString);
 
    explicit CallbackFederate(const std::string& configString);
 
    CallbackFederate(CallbackFederate&& fed) noexcept;
    virtual ~CallbackFederate();
    CallbackFederate& operator=(CallbackFederate&& fed) noexcept;
    CallbackFederate(const CallbackFederate& fed) = delete;
    CallbackFederate& operator=(const CallbackFederate& fed) = delete;
    void setInitializeCallback(std::function<IterationRequest()> initializeCallback)
    {
        initializationOperation = std::move(initializeCallback);
    }
    void setNextTimeIterativeCallback(
        std::function<std::pair<Time, IterationRequest>(iteration_time)> nextTimeCallback)
    {
        nextTimeOperation1 = std::move(nextTimeCallback);
    }
    void setNextTimeCallback(std::function<Time(Time)> nextTimeCallback)
    {
        nextTimeOperation2 = std::move(nextTimeCallback);
        nextTimeOperation1 = nullptr;
    }
    void clearNextTimeCallback()
    {
        nextTimeOperation1 = nullptr;
        nextTimeOperation2 = nullptr;
    }
    virtual void setFlagOption(int32_t property, bool val) override;
 
  private:
    void loadOperator();
    // pointer for the
    std::shared_ptr<CallbackFederateOperator> op;
    friend CallbackFederateOperator;
    bool mEventTriggered{false};
    std::function<IterationRequest()> initializationOperation;
    std::function<std::pair<Time, IterationRequest>(iteration_time)> nextTimeOperation1;
    std::function<Time(Time)> nextTimeOperation2;
    IterationRequest initializeOperationsCallback();
 
    std::pair<Time, IterationRequest> operateCallback(iteration_time newTime);
 
    void finalizeCallback();
    void errorHandlerCallback(int errorCode, std::string_view errorString);
};
}  // namespace helics