GlobalFederateId.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 "LocalFederateId.hpp"
 
namespace helics {
constexpr IdentifierBaseType gGlobalFederateIdShift{0x0002'0000};
constexpr IdentifierBaseType gGlobalBrokerIdShift{0x7000'0000};
constexpr IdentifierBaseType gGlobalPriorityBlockSize{100'000'000};
 
class GlobalBrokerId {
  public:
    using BaseType = IdentifierBaseType;
    constexpr GlobalBrokerId() = default;
 
    constexpr explicit GlobalBrokerId(BaseType val) noexcept: gid(val) {}
    constexpr BaseType baseValue() const { return gid; }
    constexpr bool operator==(GlobalBrokerId id) const noexcept { return (gid == id.gid); }
    constexpr bool operator!=(GlobalBrokerId id) const noexcept { return (gid != id.gid); }
    constexpr bool operator<(GlobalBrokerId id) const noexcept { return (gid < id.gid); }
 
    constexpr bool isFederate() const
    {
        return ((gid >= gGlobalFederateIdShift) && (gid < gGlobalBrokerIdShift));
    }
    constexpr bool isBroker() const { return (gid >= gGlobalBrokerIdShift || gid == 1); }
    constexpr bool isValid() const
    {
        return (gid != invalid_global_broker_id && gid != detail::gInvalidInterfaceHandle);
    }
    BaseType localIndex() const
    {
        return (gid >= gGlobalBrokerIdShift) ? (gid - gGlobalBrokerIdShift) : gid;
    }
 
  private:
    BaseType gid = invalid_global_broker_id;  
    friend class GlobalFederateId;  // for allowing comparison operators to work well
    static constexpr BaseType invalid_global_broker_id{-2'010'000'000};
};
 
constexpr GlobalBrokerId parent_broker_id{0};
constexpr GlobalBrokerId gRootBrokerID{1};
 
std::ostream& operator<<(std::ostream& os, GlobalBrokerId id);
class GlobalFederateId {
  public:
    using BaseType = IdentifierBaseType;
    constexpr GlobalFederateId() = default;
 
    constexpr explicit GlobalFederateId(BaseType val) noexcept: gid(val) {}
    constexpr GlobalFederateId(GlobalBrokerId id) noexcept: gid(id.gid) {}  // NOLINT
 
    constexpr operator GlobalBrokerId() const noexcept { return GlobalBrokerId{gid}; }  // NOLINT
    constexpr BaseType baseValue() const { return gid; }
    constexpr bool operator==(GlobalFederateId id) const noexcept { return (gid == id.gid); }
    constexpr bool operator!=(GlobalFederateId id) const noexcept { return (gid != id.gid); }
    constexpr bool operator<(GlobalFederateId id) const noexcept { return (gid < id.gid); }
    constexpr bool operator>(GlobalFederateId id) const noexcept { return (gid > id.gid); }
    constexpr bool operator==(GlobalBrokerId id) const noexcept { return (gid == id.gid); }
    constexpr bool operator!=(GlobalBrokerId id) const noexcept { return (gid != id.gid); }
    constexpr bool operator<(GlobalBrokerId id) const noexcept { return (gid < id.gid); }
    constexpr bool operator>(GlobalBrokerId id) const noexcept { return (gid > id.gid); }
    constexpr bool isFederate() const
    {
        return ((gid >= gGlobalFederateIdShift) && (gid < gGlobalBrokerIdShift));
    }
    constexpr bool isBroker() const { return (gid >= gGlobalBrokerIdShift || gid == 1); }
    constexpr bool isValid() const
    {
        return (gid != invalid_global_fed_id && gid != detail::gInvalidInterfaceHandle);
    }
    constexpr BaseType localIndex() const
    {
        return (gid >= gGlobalFederateIdShift) ? (gid - gGlobalFederateIdShift) : gid;
    }
 
    BaseType* getBaseTypePointer() { return &gid; }
 
  private:
    static constexpr BaseType invalid_global_fed_id{-2'010'000'000};
    BaseType gid{invalid_global_fed_id};  
};
constexpr GlobalFederateId gDirectCoreId{-235262};
 
constexpr GlobalFederateId getSpecialFederateId(GlobalBrokerId broker,
                                                GlobalBrokerId::BaseType index)
{
    // allow 3 special federates per subbroker/core + 3 special ones for the root broker
    return (broker != gRootBrokerID) ?
        (GlobalFederateId(gGlobalBrokerIdShift -
                          3 * (broker.baseValue() - gGlobalBrokerIdShift + 2) + index)) :
        GlobalFederateId(gGlobalBrokerIdShift - index - 1);
}
std::ostream& operator<<(std::ostream& os, GlobalFederateId id);
 
class GlobalHandle {
  public:
    GlobalFederateId fed_id = GlobalFederateId{};  
    InterfaceHandle handle = InterfaceHandle{};  
    constexpr GlobalHandle() = default;
    constexpr GlobalHandle(GlobalFederateId fed, InterfaceHandle hand): fed_id(fed), handle(hand) {}
    explicit operator uint64_t() const
    {
        auto key = static_cast<uint64_t>(fed_id.baseValue()) << 32U;
        key += static_cast<uint64_t>(handle.baseValue()) & (0x0000'0000'FFFF'FFFF);
        return key;
    }
    constexpr bool operator==(GlobalHandle id) const noexcept
    {
        return ((fed_id == id.fed_id) && (handle == id.handle));
    }
    constexpr bool operator!=(GlobalHandle id) const noexcept
    {
        return ((fed_id != id.fed_id) || (handle != id.handle));
    }
    constexpr bool operator<(GlobalHandle id) const noexcept
    {
        return (fed_id < id.fed_id) ? true : ((fed_id != id.fed_id) ? false : (handle < id.handle));
    }
    constexpr bool isValid() const { return fed_id.isValid() && handle.isValid(); }
};
 
std::ostream& operator<<(std::ostream& os, GlobalHandle id);
 
class route_id {
  public:
    using BaseType = IdentifierBaseType;
    constexpr route_id() = default;
    constexpr explicit route_id(BaseType val) noexcept: rid(val) {}
    constexpr BaseType baseValue() const { return rid; }
    constexpr bool operator==(route_id id) const noexcept { return (rid == id.rid); }
    constexpr bool operator!=(route_id id) const noexcept { return (rid != id.rid); }
    constexpr bool operator<(route_id id) const noexcept { return (rid < id.rid); }
    constexpr bool isValid() const { return (rid != invalid_route_id); }
 
  private:
    static constexpr BaseType invalid_route_id{-1'295'148'000};
    BaseType rid{invalid_route_id};  
};
 
constexpr route_id parent_route_id{0};
constexpr route_id control_route{-1};
 
constexpr route_id generateRouteId(int32_t route_type_code, int32_t index)
{
    return route_id(route_type_code * 256 * 256 * 256 + index);
}
 
constexpr int32_t getRouteTypeCode(route_id rid)
{
    return (rid.baseValue() >> 24);
}
 
constexpr int32_t normal_route_code{0};
constexpr int32_t json_route_code{10};
std::ostream& operator<<(std::ostream& os, route_id id);
 
}  // namespace helics
 
namespace std {
template<>
struct hash<helics::GlobalFederateId> {
    using argument_type = helics::GlobalFederateId;  
    using result_type = std::size_t;  
    result_type operator()(argument_type const& key) const noexcept
    {
        return std::hash<helics::GlobalFederateId::BaseType>{}(key.baseValue());
    }
};
 
template<>
struct hash<helics::GlobalBrokerId> {
    using argument_type = helics::GlobalBrokerId;  
    using result_type = std::size_t;  
    result_type operator()(argument_type const& key) const noexcept
    {
        return std::hash<helics::GlobalBrokerId::BaseType>{}(key.baseValue());
    }
};
 
template<>
struct hash<helics::route_id> {
    using argument_type = helics::route_id;  
    using result_type = std::size_t;  
    result_type operator()(argument_type const& key) const noexcept
    {
        return std::hash<helics::route_id::BaseType>{}(key.baseValue());
    }
};
 
template<>
struct hash<helics::GlobalHandle> {
    using argument_type = helics::GlobalHandle;  
    using result_type = std::size_t;  
    result_type operator()(argument_type const& key) const noexcept
    {
        return std::hash<uint64_t>{}(static_cast<uint64_t>(key));
    }
};
 
}  // namespace std