core-data.hpp

Go to the documentation of this file.

/*
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 "SmallBuffer.hpp"
#include "helics/helics-config.h"
#include "helicsTime.hpp"
 
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
namespace helics {
 
class Message {
  public:
    Time time = timeZero;  
    std::uint16_t flags{0};  
    std::uint16_t messageValidation{0U};  
    std::int32_t messageID{0};  
    SmallBuffer data;  
    std::string dest;  
    std::string source;  
    std::string original_source;  
    std::string original_dest;  
    std::int32_t counter{0};  
    void* backReference{nullptr};  
 
    Message() = default;
    void swap(Message& m2) noexcept
    {
        std::swap(time, m2.time);
        std::swap(flags, m2.flags);
        std::swap(messageID, m2.messageID);
        original_source.swap(m2.original_source);
        source.swap(m2.source);
        dest.swap(m2.dest);
        data.swap(m2.data);
        original_dest.swap(m2.original_dest);
    }
    bool isValid() const noexcept
    {
        return (!data.empty()) ? true : ((!source.empty()) ? true : (!dest.empty()));
    }
    std::string_view to_string() const { return data.to_string(); }
    void clear()
    {
        time = timeZero;
        flags = 0;
        messageID = 0;
        data.resize(0);
        dest.clear();
        source.clear();
        original_source.clear();
        original_dest.clear();
        counter = 0;
    }
};
 
class FilterOperator {
  public:
    FilterOperator() = default;
    virtual ~FilterOperator() = default;
    virtual std::unique_ptr<Message> process(std::unique_ptr<Message> message) = 0;
    virtual std::vector<std::unique_ptr<Message>> processVector(std::unique_ptr<Message> message)
    {
        std::vector<std::unique_ptr<Message>> ret;
        auto res = process(std::move(message));
        if (res) {
            ret.push_back(std::move(res));
        }
        return ret;
    }
    std::unique_ptr<Message> operator()(std::unique_ptr<Message> message)
    {
        return process(std::move(message));
    }
    virtual bool isMessageGenerating() const { return false; }
};
 
class NullFilterOperator final: public FilterOperator {
  public:
    NullFilterOperator() = default;
    virtual std::unique_ptr<Message> process(std::unique_ptr<Message> message) override
    {
        return message;
    }
};
 
class TranslatorOperator {
  public:
    TranslatorOperator() = default;
    virtual ~TranslatorOperator() = default;
    virtual SmallBuffer convertToValue(std::unique_ptr<Message> message) = 0;
 
    virtual std::unique_ptr<Message> convertToMessage(const SmallBuffer& value) = 0;
 
    virtual Time computeNewMessageTime(Time valueTime) { return valueTime + minDelay; }
    virtual Time computeNewValueTime(Time messageTime) { return messageTime + minDelay; }
    Time minDelay{Time::epsilon()};
};
 
class NullTranslatorOperator final: public TranslatorOperator {
  public:
    NullTranslatorOperator() = default;
    virtual SmallBuffer convertToValue(std::unique_ptr<Message> /*message*/) override { return {}; }
 
    virtual std::unique_ptr<Message> convertToMessage(const SmallBuffer& /*value*/) override
    {
        return nullptr;
    }
};
 
class FederateOperator {
  public:
    FederateOperator() = default;
    virtual ~FederateOperator() = default;
    virtual IterationRequest initializeOperations() = 0;
 
    virtual std::pair<Time, IterationRequest> operate(iteration_time newTime) = 0;
    /*NOTE: the following two functions will be called only once and they will be the last call in
     * the federate lifecycle*/
    virtual void finalize() {}
    virtual void error_handler([[maybe_unused]] int error_code,
                               [[maybe_unused]] std::string_view errorString)
    {
    }
};
 
class NullFederateOperator final: public FederateOperator {
  public:
    NullFederateOperator() = default;
    virtual IterationRequest initializeOperations() override
    {
        return IterationRequest::NO_ITERATIONS;
    };
 
    virtual std::pair<Time, IterationRequest>
        operate([[maybe_unused]] iteration_time newTime) override
    {
        return {Time::maxVal(), IterationRequest::NO_ITERATIONS};
    }
};
 
template<class sizeType, class SizedDataType>
inline bool isValidIndex(sizeType testSize, const SizedDataType& vec)
{
    return ((testSize >= sizeType(0)) && (testSize < static_cast<sizeType>(vec.size())));
}
 
}  // namespace helics