EIC code displayed by LXR master/​jana2/​src/​python/​externals/​pybind11-2.10.3/​tests/​object.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 10:17:51

 #if !defined(__OBJECT_H)
 #    define __OBJECT_H
 
 #    include "constructor_stats.h"
 
 #    include <atomic>
 
 /// Reference counted object base class
 class Object {
 public:
     /// Default constructor
     Object() { print_default_created(this); }
 
     /// Copy constructor
     Object(const Object &) : m_refCount(0) { print_copy_created(this); }
 
     /// Return the current reference count
     int getRefCount() const { return m_refCount; };
 
     /// Increase the object's reference count by one
     void incRef() const { ++m_refCount; }
 
     /** \brief Decrease the reference count of
      * the object and possibly deallocate it.
      *
      * The object will automatically be deallocated once
      * the reference count reaches zero.
      */
     void decRef(bool dealloc = true) const {
         --m_refCount;
         if (m_refCount == 0 && dealloc) {
             delete this;
         } else if (m_refCount < 0) {
             throw std::runtime_error("Internal error: reference count < 0!");
         }
     }
 
     virtual std::string toString() const = 0;
 
 protected:
     /** \brief Virtual protected deconstructor.
      * (Will only be called by \ref ref)
      */
     virtual ~Object() { print_destroyed(this); }
 
 private:
     mutable std::atomic<int> m_refCount{0};
 };
 
 // Tag class used to track constructions of ref objects.  When we track constructors, below, we
 // track and print out the actual class (e.g. ref<MyObject>), and *also* add a fake tracker for
 // ref_tag.  This lets us check that the total number of ref<Anything> constructors/destructors is
 // correct without having to check each individual ref<Whatever> type individually.
 class ref_tag {};
 
 /**
  * \brief Reference counting helper
  *
  * The \a ref refeference template is a simple wrapper to store a
  * pointer to an object. It takes care of increasing and decreasing
  * the reference count of the object. When the last reference goes
  * out of scope, the associated object will be deallocated.
  *
  * \ingroup libcore
  */
 template <typename T>
 class ref {
 public:
     /// Create a nullptr reference
     ref() : m_ptr(nullptr) {
         print_default_created(this);
         track_default_created((ref_tag *) this);
     }
 
     /// Construct a reference from a pointer
     explicit ref(T *ptr) : m_ptr(ptr) {
         if (m_ptr) {
             ((Object *) m_ptr)->incRef();
         }
 
         print_created(this, "from pointer", m_ptr);
         track_created((ref_tag *) this, "from pointer");
     }
 
     /// Copy constructor
     ref(const ref &r) : m_ptr(r.m_ptr) {
         if (m_ptr) {
             ((Object *) m_ptr)->incRef();
         }
 
         print_copy_created(this, "with pointer", m_ptr);
         track_copy_created((ref_tag *) this);
     }
 
     /// Move constructor
     ref(ref &&r) noexcept : m_ptr(r.m_ptr) {
         r.m_ptr = nullptr;
 
         print_move_created(this, "with pointer", m_ptr);
         track_move_created((ref_tag *) this);
     }
 
     /// Destroy this reference
     ~ref() {
         if (m_ptr) {
             ((Object *) m_ptr)->decRef();
         }
 
         print_destroyed(this);
         track_destroyed((ref_tag *) this);
     }
 
     /// Move another reference into the current one
     ref &operator=(ref &&r) noexcept {
         print_move_assigned(this, "pointer", r.m_ptr);
         track_move_assigned((ref_tag *) this);
 
         if (*this == r) {
             return *this;
         }
         if (m_ptr) {
             ((Object *) m_ptr)->decRef();
         }
         m_ptr = r.m_ptr;
         r.m_ptr = nullptr;
         return *this;
     }
 
     /// Overwrite this reference with another reference
     ref &operator=(const ref &r) {
         if (this == &r) {
             return *this;
         }
         print_copy_assigned(this, "pointer", r.m_ptr);
         track_copy_assigned((ref_tag *) this);
 
         if (m_ptr == r.m_ptr) {
             return *this;
         }
         if (m_ptr) {
             ((Object *) m_ptr)->decRef();
         }
         m_ptr = r.m_ptr;
         if (m_ptr) {
             ((Object *) m_ptr)->incRef();
         }
         return *this;
     }
 
     /// Overwrite this reference with a pointer to another object
     ref &operator=(T *ptr) {
         print_values(this, "assigned pointer");
         track_values((ref_tag *) this, "assigned pointer");
 
         if (m_ptr == ptr) {
             return *this;
         }
         if (m_ptr) {
             ((Object *) m_ptr)->decRef();
         }
         m_ptr = ptr;
         if (m_ptr) {
             ((Object *) m_ptr)->incRef();
         }
         return *this;
     }
 
     /// Compare this reference with another reference
     bool operator==(const ref &r) const { return m_ptr == r.m_ptr; }
 
     /// Compare this reference with another reference
     bool operator!=(const ref &r) const { return m_ptr != r.m_ptr; }
 
     /// Compare this reference with a pointer
     bool operator==(const T *ptr) const { return m_ptr == ptr; }
 
     /// Compare this reference with a pointer
     bool operator!=(const T *ptr) const { return m_ptr != ptr; }
 
     /// Access the object referenced by this reference
     T *operator->() { return m_ptr; }
 
     /// Access the object referenced by this reference
     const T *operator->() const { return m_ptr; }
 
     /// Return a C++ reference to the referenced object
     T &operator*() { return *m_ptr; }
 
     /// Return a const C++ reference to the referenced object
     const T &operator*() const { return *m_ptr; }
 
     /// Return a pointer to the referenced object
     explicit operator T *() { return m_ptr; }
 
     /// Return a const pointer to the referenced object
     T *get_ptr() { return m_ptr; }
 
     /// Return a pointer to the referenced object
     const T *get_ptr() const { return m_ptr; }
 
 private:
     T *m_ptr;
 };
 
 #endif /* __OBJECT_H */

This page was automatically generated by the 2.3.7 LXR engine. The LXR team