InputInfo.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 <cstdint>
#include <memory>
#include <string>
#include <string_view>
#include <tuple>
#include <utility>
#include <vector>
 
namespace helics {
class InputInfo {
  public:
    struct dataRecord {
        Time time{Time::minVal()};  
        unsigned int iteration{0};  
        std::shared_ptr<const SmallBuffer> data;  
        dataRecord() = default;
        dataRecord(Time recordTime, std::shared_ptr<const SmallBuffer> recordData):
            time(recordTime), data(std::move(recordData))
        {
        }
        dataRecord(Time recordTime,
                   unsigned int recordIteration,
                   std::shared_ptr<const SmallBuffer> recordData):
            time(recordTime), iteration(recordIteration), data(std::move(recordData))
        {
        }
    };
 
    struct sourceInformation {
        std::string key;
        std::string type;
        std::string units;
        sourceInformation() = default;
        sourceInformation(std::string_view key_, std::string_view type_, std::string_view units_):
            key(key_), type(type_), units(units_)
        {
        }
    };
    InputInfo(GlobalHandle handle,
              std::string_view key_,
              std::string_view type_,
              std::string_view units_): id(handle), key(key_), type(type_), units(units_)
    {
    }
 
    const GlobalHandle id;  
    const std::string key;  
    const std::string type;  
    const std::string units;  
    bool required{false};
    bool optional{false};  
    bool has_target{false};  
    bool only_update_on_change{false};
    bool not_interruptible{false};
    bool strict_type_matching{false};
    bool ignore_unit_mismatch{false};  
    int32_t required_connnections{0};  
    Time minTimeGap{timeZero};
    std::vector<std::pair<helics::Time, unsigned int>> current_data_time;
    std::vector<std::shared_ptr<const SmallBuffer>> current_data;
    std::vector<GlobalHandle> input_sources;  
    std::vector<Time> deactivated;  
    std::vector<sourceInformation> source_info;  
    std::vector<int32_t> priority_sources;  
  private:
    std::vector<std::vector<dataRecord>> data_queues;  
    std::uint64_t queuedDataSizeBytes{0};  
 
  public:
    const std::vector<std::shared_ptr<const SmallBuffer>>& getAllData() const;
    const std::shared_ptr<const SmallBuffer>& getData(int index) const;
    const std::shared_ptr<const SmallBuffer>& getData(uint32_t* inputIndex) const;
    [[nodiscard]] bool addData(GlobalHandle source_id,
                               Time valueTime,
                               unsigned int iteration,
                               std::shared_ptr<const SmallBuffer> data);
 
    bool updateTimeUpTo(Time newTime);
    bool updateTimeInclusive(Time newTime);
 
    bool updateTimeNextIteration(Time newTime);
    Time nextValueTime() const;
    bool addSource(GlobalHandle newSource,
                   std::string_view sourceName,
                   std::string_view stype,
                   std::string_view sunits);
    void removeSource(GlobalHandle sourceToRemove, Time minTime);
    void removeSource(std::string_view sourceName, Time minTime);
    void disconnectFederate(GlobalFederateId fedToDisconnect, Time minTime);
    void clearFutureData();
    std::uint64_t queuedDataSize() const { return queuedDataSizeBytes; }
 
    const std::string& getInjectionType() const;
    const std::string& getInjectionUnits() const;
    const std::string& getSourceName(GlobalHandle source) const;
    const std::string& getTargets() const;
 
    void setProperty(int32_t option, int32_t value);
    int32_t getProperty(int32_t option) const;
 
  private:
    bool updateData(dataRecord&& update, int index);
    mutable std::string inputUnits;
    mutable std::string inputType;
    mutable std::string sourceTargets;
};
 
bool checkTypeMatch(std::string_view type1, std::string_view type2, bool strict_match);
 
bool checkUnitMatch(const std::string& unit1, const std::string& unit2, bool strict_match);
}  // namespace helics