UniqueId.h

Go to the documentation of this file.

/*
 * Project: RooFit
 * Authors:
 *   Jonas Rembser, CERN, Jun 2021
 *
 * Copyright (c) 2021, CERN
 *
 * Redistribution and use in source and binary forms,
 * with or without modification, are permitted according to the terms
 * listed in LICENSE (http://roofit.sourceforge.net/license.txt)
 */
 
#ifndef roofit_roofitcore_RooFit_UniqueId_h
#define roofit_roofitcore_RooFit_UniqueId_h
 
#include <atomic>
 
namespace RooFit {
 
/// A UniqueId can be added as a class member to enhance any class with a
/// unique identifier for each instantiated object.
///
/// Example:
/// ~~~{.cpp}
/// class MyClass {
///
/// public:
///    /// Return unique ID by reference.
///    /// Please always use the name `uniqueId` for the getter.
///    UniqueId<MyClass> const& uniqueId() const { return _uniqueId; }
///
/// private:
///    const UniqueId<MyClass> _uniqueId; //! should be non-persistent
///
/// };
/// ~~~
 
template <class Class>
struct UniqueId {
public:
   using Value_t = unsigned long;
 
   /// Create a new UniqueId with the next value from the static counter.
   UniqueId() : _val{++counter} {}
 
   // Disable all sorts of copying and moving to ensure uniqueness.
   UniqueId(const UniqueId &) = delete;
   UniqueId &operator=(const UniqueId &) = delete;
   UniqueId(UniqueId &&) = delete;
   UniqueId &operator=(UniqueId &&) = delete;
 
   operator Value_t() const { return _val; }
 
   /// Return numerical value of ID.
   /// Use only if necessary, as the UniqueId type information is lost and
   /// copying/moving is not prohibited for the value type.
   /// Please don't turn this into a cast operator, as a function with an
   /// explicit name is easier to track in the codebase.
   constexpr Value_t value() const { return _val; }
 
   bool operator==(UniqueId const &other) const { return _val == other._val; }
   bool operator<(UniqueId const &other) const { return _val < other._val; }
 
   /// Get an ID that is less than the ID of any object (similar to nullptr).
   static UniqueId const &nullid()
   {
      static const UniqueId nid{nullval};
      return nid;
   }
 
   static constexpr Value_t nullval = 0UL; ///< The value of the nullid.
 
private:
   UniqueId(Value_t val) : _val{val} {}
 
   Value_t _val; ///< Numerical value of the ID.
 
   static std::atomic<Value_t> counter; ///< The static object counter to get the next ID value.
};
 
template <class Class>
std::atomic<typename UniqueId<Class>::Value_t> UniqueId<Class>::counter{UniqueId<Class>::nullval};
 
/// A helper function to replace pointer comparisons with UniqueId comparisons.
/// With pointer comparisons, we can also have `nullptr`. In the UniqueId case,
/// this translates to the `nullid`.
template <class Class,
          class UniqueId_t = std::remove_reference_t<decltype(std::declval<std::remove_pointer_t<Class>>().uniqueId())>>
UniqueId_t const &getUniqueId(Class const *ptr)
{
   return ptr ? ptr->uniqueId() : UniqueId_t::nullid();
}
 
} // namespace RooFit
 
#endif