TimeDependencies.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
*/
#pragma once
 
#include "basic_CoreTypes.hpp"
#include "nlohmann/json_fwd.hpp"
 
#include <string>
#include <utility>
#include <vector>
 
namespace helics {
class ActionMessage;
 
enum class TimeState : std::uint8_t {
    initialized = 0,
    exec_requested_require_iteration = 1,
    exec_requested_iterative = 2,
    exec_requested = 3,
    time_granted = 5,
    time_requested_require_iteration = 6,
    time_requested_iterative = 7,
    time_requested = 8,
    error = 10
};
 
enum class ConnectionType : std::uint8_t {
    INDEPENDENT = 0,
    PARENT = 1,
    CHILD = 2,
    SELF = 3,
    NONE = 4,
};
 
enum class TimeProcessingResult : std::uint8_t {
    NOT_PROCESSED = 0,  
    PROCESSED = 1,  
    PROCESSED_AND_CHECK = 2,
    PROCESSED_NEW_REQUEST = 3,
    DELAY_PROCESSING = 5  
};
 
enum class GrantDelayMode : std::uint8_t { NONE = 0, INTERRUPTED = 1, WAITING = 2 };
 
inline GrantDelayMode getDelayMode(bool waiting, bool interrupted)
{
    return waiting ? GrantDelayMode::WAITING :
                     (interrupted ? GrantDelayMode::INTERRUPTED : GrantDelayMode::NONE);
}
 
// helper class containing the basic timeData
class TimeData {
  public:
    Time next{negEpsilon};  
    Time Te{timeZero};  
    Time minDe{timeZero};  
    Time TeAlt{timeZero};  
    Time lastGrant{timeZero};  
    GlobalFederateId minFed{};  
    GlobalFederateId minFedActual{};  
    TimeState mTimeState{TimeState::initialized};
    bool hasData{false};  
    bool interrupted{false};  
    bool delayedTiming{false};  
    std::int8_t timingVersion{-2};  
    std::uint8_t restrictionLevel{0};  
 
    std::int32_t timeoutCount{0};  
    std::int32_t sequenceCounter{0};  
    std::int32_t responseSequenceCounter{0};  
    std::int32_t grantedIteration{0};
    TimeData() = default;
    TimeData(const TimeData&) = default;
    TimeData& operator=(const TimeData&) = default;
    TimeData(TimeData&&) = default;
    TimeData& operator=(TimeData&&) = default;
    explicit TimeData(Time start,
                      TimeState startState = TimeState::initialized,
                      std::uint8_t resLevel = 0U):
        next{start}, Te{start}, minDe{start}, TeAlt{start}, mTimeState{startState},
        restrictionLevel{resLevel} {};
    bool update(const TimeData& update);
};
 
class DependencyInfo: public TimeData {
  public:
    GlobalFederateId fedID{};  
 
    bool cyclic{false};  
    ConnectionType connection{ConnectionType::INDEPENDENT};
    bool dependent{false};  
    bool dependency{false};  
    bool forwarding{false};  
    bool nonGranting{false};  
    bool triggered{false};  
    bool updateRequested{false};  
    // Time forwardEvent{Time::maxVal()};  //!< a predicted event
    DependencyInfo() = default;
    DependencyInfo(const DependencyInfo&) = default;
    DependencyInfo& operator=(const DependencyInfo&) = default;
    DependencyInfo(DependencyInfo&&) = default;
    DependencyInfo& operator=(DependencyInfo&&) = default;
    explicit DependencyInfo(GlobalFederateId id): fedID(id), forwarding{id.isBroker()} {}
 
    template<class... Args>
    explicit DependencyInfo(Time start, Args&&... args):
        TimeData(start, std::forward<Args>(args)...)
    {
    }
};
 
class TimeDependencies {
  private:
    std::vector<DependencyInfo> dependencies;  
    mutable GlobalFederateId mDelayedDependency{};
 
  public:
    TimeDependencies() = default;
    bool isDependency(GlobalFederateId ofed) const;
    bool isDependent(GlobalFederateId ofed) const;
    bool addDependency(GlobalFederateId gid);
    void removeDependency(GlobalFederateId gid);
    bool addDependent(GlobalFederateId gid);
    void removeDependent(GlobalFederateId gid);
    void resetDependency(GlobalFederateId id);
    void removeInterdependence(GlobalFederateId gid);
    TimeProcessingResult updateTime(const ActionMessage& cmd);
    auto size() const { return dependencies.size(); }
    auto begin() { return dependencies.begin(); }
    auto end() { return dependencies.end(); }
    auto begin() const { return dependencies.cbegin(); }
    auto end() const { return dependencies.cend(); }
    auto cbegin() const { return dependencies.cbegin(); }
    auto cend() const { return dependencies.cend(); }
 
    bool empty() const { return dependencies.empty(); }
    const DependencyInfo* getDependencyInfo(GlobalFederateId gid) const;
 
    DependencyInfo* getDependencyInfo(GlobalFederateId gid);
 
    bool checkIfReadyForExecEntry(bool iterating, bool waiting) const;
    bool checkIfAllDependenciesArePastExec(bool iterating) const;
    bool checkIfReadyForTimeGrant(bool iterating,
                                  Time desiredGrantTime,
                                  GrantDelayMode delayMode) const;
 
    void resetIteratingExecRequests();
    void resetIteratingTimeRequests(Time requestTime);
    void resetDependentEvents(Time grantTime);
    bool hasActiveTimeDependencies() const;
    bool verifySequenceCounter(Time tmin, std::int32_t sequenceCount);
    int activeDependencyCount() const;
    GlobalFederateId getMinDependency() const;
 
    void setDependencyVector(const std::vector<DependencyInfo>& deps) { dependencies = deps; }
    std::pair<int, std::string> checkForIssues(bool waiting) const;
 
    bool hasDelayedDependency() const { return mDelayedDependency.isValid(); }
    GlobalFederateId delayedDependency() const { return mDelayedDependency; }
};
 
inline bool checkSequenceCounter(const DependencyInfo& dep, Time tmin, std::int32_t sq)
{
    return (!dep.dependency || !dep.dependent || dep.timingVersion <= 0 || dep.next > tmin ||
            dep.next >= cTerminationTime || dep.responseSequenceCounter == sq);
}
 
const DependencyInfo& getExecEntryMinFederate(const TimeDependencies& dependencies,
                                              GlobalFederateId self,
                                              ConnectionType ignoreType = ConnectionType::NONE,
                                              GlobalFederateId ignore = GlobalFederateId{});
static constexpr GlobalFederateId NoIgnoredFederates{};
 
TimeData generateMinTimeUpstream(const TimeDependencies& dependencies,
                                 bool restricted,
                                 GlobalFederateId self,
                                 GlobalFederateId ignore,
                                 std::int32_t responseCode);
 
TimeData generateMinTimeDownstream(const TimeDependencies& dependencies,
                                   bool restricted,
                                   GlobalFederateId self,
                                   GlobalFederateId ignore,
                                   std::int32_t responseCode);
 
TimeData generateMinTimeTotal(const TimeDependencies& dependencies,
                              bool restricted,
                              GlobalFederateId self,
                              GlobalFederateId ignore,
                              std::int32_t responseCode);
 
void generateJsonOutputTimeData(nlohmann::json& output,
                                const TimeData& dep,
                                bool includeAggregates = true);
 
void addTimeState(nlohmann::json& output, const TimeState state);
 
void generateJsonOutputDependency(nlohmann::json& output, const DependencyInfo& dep);
}  // namespace helics