ActionMessage.hpp

/*
Copyright (c) 2017-2024,
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 "ActionMessageDefintions.hpp"
#include "SmallBuffer.hpp"
#include "basic_CoreTypes.hpp"
 
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
namespace helics {
constexpr int targetStringLoc{0};
constexpr int sourceStringLoc{1};
constexpr int unitStringLoc{1};
constexpr int origSourceStringLoc{2};
constexpr int origDestStringLoc{3};
constexpr int typeStringLoc{0};
constexpr int typeOutStringLoc{1};
 
constexpr int32_t cmd_info_basis{65536};
 
class ActionMessage {
    // need to try to make sure this object is under 64 bytes in size to fit in cache lines NOT
    // there yet
  private:
    action_message_def::action_t messageAction{CMD_IGNORE};  // 4 -- command
  public:
    int32_t messageID{0};  
    GlobalFederateId source_id{parent_broker_id};  
    InterfaceHandle source_handle{};  
    GlobalFederateId dest_id{parent_broker_id};  
    InterfaceHandle dest_handle{};  
    uint16_t counter{0};  
    uint16_t flags{0};  
    uint32_t sequenceID{0};  
    Time actionTime{timeZero};  
    Time Te{timeZero};  
    Time Tdemin{timeZero};  
    Time Tso{timeZero};  
    SmallBuffer payload;  
  private:
    std::vector<std::string> stringData;  
  public:
    ActionMessage() noexcept {}
    /* implicit */ ActionMessage(action_message_def::action_t startingAction);  // NOLINT
    ActionMessage(action_message_def::action_t startingAction,
                  GlobalFederateId sourceId,
                  GlobalFederateId destId);
    ActionMessage(ActionMessage&& act) noexcept;
    explicit ActionMessage(std::unique_ptr<Message> message);
    explicit ActionMessage(const std::string& bytes);
    explicit ActionMessage(const std::vector<char>& bytes);
    ActionMessage(const void* data, size_t size);
    ~ActionMessage();
    ActionMessage(const ActionMessage& act);
    ActionMessage& operator=(const ActionMessage& act);
    ActionMessage& operator=(ActionMessage&& act) noexcept;
    ActionMessage& operator=(std::unique_ptr<Message> message) noexcept;
    action_message_def::action_t action() const noexcept { return messageAction; }
    void setAction(action_message_def::action_t newAction);
 
    void setSource(GlobalHandle hand)
    {
        source_id = hand.fed_id;
        source_handle = hand.handle;
    }
    void setDestination(GlobalHandle hand)
    {
        dest_id = hand.fed_id;
        dest_handle = hand.handle;
    }
    const std::vector<std::string>& getStringData() const { return stringData; }
    void name(std::string_view name) { payload = name; }
    std::string_view name() const { return payload.to_string(); }
    void clearStringData() { stringData.clear(); }
    // most use cases for this involve short strings, or already have references that need to be
    // copied so supporting move isn't  going to be that useful here, the long strings are going in
    // the payload
    void setStringData(std::string_view string1)
    {
        stringData.resize(1);
        stringData[0] = string1;
    }
    void setStringData(std::string_view string1, std::string_view string2)
    {
        stringData.resize(2);
        stringData[0] = string1;
        stringData[1] = string2;
    }
    void setStringData(std::string_view string1, std::string_view string2, std::string_view string3)
    {
        stringData.resize(3);
        stringData[0] = string1;
        stringData[1] = string2;
        stringData[2] = string3;
    }
    void setStringData(std::string_view string1,
                       std::string_view string2,
                       std::string_view string3,
                       std::string_view string4)
    {
        stringData.resize(4);
        stringData[0] = string1;
        stringData[1] = string2;
        stringData[2] = string3;
        stringData[3] = string4;
    }
    const std::string& getString(int index) const;
 
    void setString(int index, std::string_view str);
    GlobalHandle getSource() const { return GlobalHandle{source_id, source_handle}; }
    GlobalHandle getDest() const { return GlobalHandle{dest_id, dest_handle}; }
    void swapSourceDest() noexcept
    {
        std::swap(source_id, dest_id);
        std::swap(source_handle, dest_handle);
    }
    void setExtraData(int32_t data) { dest_handle = InterfaceHandle{data}; }
    int32_t getExtraData() const { return dest_handle.baseValue(); }
    void setExtraDestData(int32_t data) { source_handle = InterfaceHandle{data}; }
    int32_t getExtraDestData() const { return source_handle.baseValue(); }
    // functions that convert to and from a byte stream
 
    int serializedByteCount() const;
    int toByteArray(std::byte* data, std::size_t buffer_size) const;
    void to_string(std::string& data) const;
    std::string to_string() const;
    std::string to_json_string() const;
    std::string packetize() const;
    void packetize(std::string& data) const;
    std::string packetize_json() const;
    void to_vector(std::vector<char>& data) const;
    std::vector<char> to_vector() const;
    std::size_t fromByteArray(const std::byte* data, std::size_t buffer_size);
    std::size_t depacketize(const void* data, std::size_t buffer_size);
    std::size_t from_string(std::string_view data);
    bool from_json_string(std::string_view data);
    std::size_t from_vector(const std::vector<char>& data);
 
    friend std::unique_ptr<Message> createMessageFromCommand(const ActionMessage& cmd);
    friend std::unique_ptr<Message> createMessageFromCommand(ActionMessage&& cmd);
};
 
inline bool operator<(const ActionMessage& cmd, const ActionMessage& cmd2)
{
    return (cmd.actionTime < cmd2.actionTime);
}
 
std::unique_ptr<Message> createMessageFromCommand(const ActionMessage& cmd);
 
std::unique_ptr<Message> createMessageFromCommand(ActionMessage&& cmd);
 
inline bool isProtocolCommand(const ActionMessage& command) noexcept
{
    return ((command.action() == CMD_PROTOCOL) || (command.action() == CMD_PROTOCOL_PRIORITY) ||
            (command.action() == CMD_PROTOCOL_BIG));
}
inline bool isPriorityCommand(const ActionMessage& command) noexcept
{
    return (command.action() < action_message_def::action_t::cmd_ignore);
}
 
inline bool isTimingCommand(const ActionMessage& command) noexcept
{
    switch (command.action()) {
        case CMD_DISCONNECT:
        case CMD_BROADCAST_DISCONNECT:
        case CMD_DISCONNECT_CORE:
        case CMD_DISCONNECT_BROKER:
        case CMD_DISCONNECT_FED:
        case CMD_TIME_GRANT:
        case CMD_TIME_REQUEST:
        case CMD_EXEC_GRANT:
        case CMD_EXEC_REQUEST:
        case CMD_PRIORITY_DISCONNECT:
        case CMD_TERMINATE_IMMEDIATELY:
        case CMD_ERROR:
        case CMD_LOCAL_ERROR:
        case CMD_GLOBAL_ERROR:
        case CMD_TIMING_INFO:
            return true;
        default:
            return false;
    }
}
 
inline bool isDependencyCommand(const ActionMessage& command) noexcept
{
    switch (command.action()) {
        case CMD_ADD_DEPENDENCY:
        case CMD_REMOVE_DEPENDENCY:
        case CMD_ADD_DEPENDENT:
        case CMD_REMOVE_DEPENDENT:
        case CMD_ADD_INTERDEPENDENCY:
        case CMD_REMOVE_INTERDEPENDENCY:
            return true;
        default:
            return false;
    }
}
 
inline bool isDisconnectCommand(const ActionMessage& command) noexcept
{
    switch (command.action()) {
        case CMD_DISCONNECT:
        case CMD_DISCONNECT_CHECK:
        case CMD_DISCONNECT_NAME:
        case CMD_USER_DISCONNECT:
        case CMD_DISCONNECT_FED:
        case CMD_DISCONNECT_CORE:
        case CMD_PRIORITY_DISCONNECT:
        case CMD_TERMINATE_IMMEDIATELY:
        case CMD_REMOVE_FILTER:
        case CMD_REMOVE_ENDPOINT:
        case CMD_DISCONNECT_FED_ACK:
        case CMD_DISCONNECT_CORE_ACK:
        case CMD_DISCONNECT_BROKER_ACK:
        case CMD_DISCONNECT_BROKER:
        case CMD_BROADCAST_DISCONNECT:
        case CMD_STOP:
            return true;
        case CMD_TIME_GRANT:
            return (command.actionTime == Time::maxVal());
        default:
            return false;
    }
}
 
inline bool isErrorCommand(const ActionMessage& command) noexcept
{
    switch (command.action()) {
        case CMD_ERROR:
        case CMD_LOCAL_ERROR:
        case CMD_GLOBAL_ERROR:
            return true;
        default:
            return false;
    }
}
inline bool isIgnoreableCommand(const ActionMessage& command) noexcept
{
    if (isDisconnectCommand(command)) {
        return true;
    }
    if (isErrorCommand(command)) {
        return true;
    }
    switch (command.action()) {
        case CMD_LOG:
        case CMD_WARNING:
        case CMD_REMOTE_LOG:
        case CMD_TIME_REQUEST:
        case CMD_REQUEST_CURRENT_TIME:
            return true;
        default:
            return false;
    }
}
 
inline bool isValidCommand(const ActionMessage& command) noexcept
{
    return (command.action() != action_message_def::action_t::cmd_invalid);
}
std::string prettyPrintString(const ActionMessage& command);
 
std::ostream& operator<<(std::ostream& out, const ActionMessage& command);
 
int appendMessage(ActionMessage& multiMessage, const ActionMessage& newMessage);
 
std::string errorMessageString(const ActionMessage& command);
 
void setIterationFlags(ActionMessage& command, IterationRequest iterate);
 
}  // namespace helics