LocalFederateId.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 <cstdint>
#include <functional>
#include <iosfwd>
 
namespace helics {
using IdentifierBaseType = int32_t;
 
class LocalFederateId {
  public:
    using BaseType = IdentifierBaseType;
    constexpr LocalFederateId() = default;
    constexpr explicit LocalFederateId(BaseType val) noexcept: fid(val) {}
    constexpr BaseType baseValue() const { return fid; }
    bool operator==(LocalFederateId id) const noexcept { return (fid == id.fid); }
    bool operator!=(LocalFederateId id) const noexcept { return (fid != id.fid); }
    bool operator<(LocalFederateId id) const noexcept { return (fid < id.fid); }
    bool isValid() const { return (fid != invalid_fid); }
 
  private:
    static constexpr BaseType invalid_fid{-2'000'000'000};  
    BaseType fid{invalid_fid};  
};
 
#if defined HELICS_STATIC_CORE_LIBRARY && !defined HELICS_SHARED_LIBRARY
std::ostream& operator<<(std::ostream& os, LocalFederateId fid);
 
#endif
constexpr LocalFederateId gLocalCoreId(-259);
 
namespace detail {
    constexpr IdentifierBaseType gInvalidInterfaceHandle{-1'700'000'000};
}  // namespace detail
 
class InterfaceHandle {
  public:
    using BaseType = IdentifierBaseType;
    constexpr InterfaceHandle() = default;
 
    constexpr explicit InterfaceHandle(BaseType val) noexcept: hid(val) {}
    constexpr BaseType baseValue() const { return hid; }
    bool operator==(InterfaceHandle id) const noexcept { return (hid == id.hid); }
    bool operator!=(InterfaceHandle id) const noexcept { return (hid != id.hid); }
    bool operator<(InterfaceHandle id) const noexcept { return (hid < id.hid); }
    bool operator>(InterfaceHandle id) const noexcept { return (hid > id.hid); }
    bool isValid() const { return (hid != mInvalidHandle); }
    BaseType* getBaseTypePointer() { return &hid; }
 
  private:
    static constexpr BaseType mInvalidHandle{detail::gInvalidInterfaceHandle};
    BaseType hid{mInvalidHandle};  
};
 
#if defined HELICS_STATIC_CORE_LIBRARY && !defined HELICS_SHARED_LIBRARY
std::ostream& operator<<(std::ostream& os, InterfaceHandle handle);
#endif
 
constexpr InterfaceHandle gDirectSendHandle{
    -1'745'234};  
 
}  // namespace helics
 
namespace std {
template<>
struct hash<helics::LocalFederateId> {
    std::size_t operator()(helics::LocalFederateId const& key) const noexcept
    {
        return std::hash<helics::LocalFederateId::BaseType>{}(key.baseValue());
    }
};
 
template<>
struct hash<helics::InterfaceHandle> {
    std::size_t operator()(helics::InterfaceHandle const& key) const noexcept
    {
        return std::hash<helics::InterfaceHandle::BaseType>{}(key.baseValue());
    }
};
 
}  // namespace std