flagOperations.hpp

Go to the documentation of this file.

/*
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 <cstdint>
 
namespace helics {
enum GeneralFlags : uint16_t {
    error_flag = 4,  
    indicator_flag = 5,  
};
 
enum TimingFlags : uint16_t {
    iteration_requested_flag = 0,  
    non_granting_flag = 7,
 
    interrupted_flag = 8,
    delayed_timing_flag = 10,
    parent_flag = 13,
 
    child_flag = 14
};
 
enum InterfaceFlags : uint16_t {
    buffer_data_flag = 0,
    destination_target = 1,
    required_flag = 2,
    single_connection_flag = 3,
    only_update_on_change_flag = 6,
    reconnectable_flag = 7,
    optional_flag = 8,
 
    // 9,10,11,13,14 are interface specific
 
    only_transmit_on_change_flag = 12,
 
    nameless_interface_flag = 15
};
 
enum EndpointFlags {
    targeted_flag = 10,
 
    has_source_filter_flag = 11,
    source_only_flag = 13,
    receive_only_flag = 14
};
 
enum FilterFlags {
    clone_flag = 9,
    has_dest_filter_flag = 13,
    has_non_cloning_dest_filter_flag = 14,
};
 
enum ConnectionFlags : uint16_t {
    core_flag = 3,
    global_timing_flag = 5,
 
    use_json_serialization_flag = 6,
    async_timing_flag = 7,
    observer_flag = 8,
    dynamic_join_flag = 9,
    reentrant_flag = 10,
    disconnected_flag = 12,
    test_connection_flag = 13,
    slow_responding_flag = 14,
    non_counting_flag = 15
 
};
 
enum MessageFlags : uint16_t {
    filter_processing_required_flag = 7,
    user_custom_message_flag1 = 10,
    destination_processing_flag = 11,
    user_custom_message_flag2 = 13,
    user_custom_message_flag3 = 14,
    empty_flag = 15,
};
 
enum OperationFlags : uint16_t {
    cancel_flag = 13
};
 
// extra_flag1 = 7,  //!< extra flag
 
// extra_flag2 = 10,  //!< extra flag
 
// extra_flag3 = 13,  //!< extra flag
// extra_flag4 = 14,  //!< extra flag
 
template<class FlagContainer, class FlagIndex>
inline void setActionFlag(FlagContainer& M, FlagIndex flag)
{
    M.flags |= (static_cast<decltype(M.flags)>((1U) << (static_cast<uint16_t>((flag)))));
}
 
template<class FlagIndex>
inline bool checkActionFlag(uint16_t flags, FlagIndex flag)
{
    return ((flags & (static_cast<uint16_t>((1U) << (static_cast<uint16_t>((flag)))))) != 0U);
}
 
template<class FlagContainer, class FlagIndex>
inline bool checkActionFlag(const FlagContainer& M, FlagIndex flag)
{
    return ((M.flags & (static_cast<decltype(M.flags)>((1U) << (static_cast<uint16_t>((flag)))))) !=
            0U);
}
 
template<class FlagContainer, class FlagIndex>
inline void clearActionFlag(FlagContainer& M, FlagIndex flag)
{
    M.flags &= static_cast<decltype(M.flags)>(~((1U) << (static_cast<uint16_t>((flag)))));
}
 
template<class FlagContainer, class FlagIndex>
inline void toggleActionFlag(FlagContainer& M, FlagIndex flag)
{
    if (checkActionFlag(M, flag)) {
        clearActionFlag(M, flag);
    } else {
        setActionFlag(M, flag);
    }
}
 
inline constexpr uint16_t make_flags(unsigned int flag)
{
    return static_cast<uint16_t>(1U << (flag));
}
 
inline constexpr uint16_t make_flags(unsigned int flag1, unsigned int flag2)
{
    return make_flags(flag1) | make_flags(flag2);
}
 
inline constexpr uint16_t make_flags(unsigned int flag1, unsigned int flag2, unsigned int flag3)
{
    return make_flags(flag1, flag2) | make_flags(flag3);
}
 
inline constexpr uint16_t toggle_flag(uint16_t base, unsigned int flag)
{
    return base ^ make_flags(flag);
}
}  // namespace helics