d2/d33/refPtr_8h_source.html

 #ifndef GUM_REFPTR_H
 #define GUM_REFPTR_H

 #include <new>

 #include <agrum/agrum.h>

 namespace gum {

 #ifndef DOXYGEN_SHOULD_SKIP_THIS

   template < typename Val >
   class RefPtr;

   template < typename Val >
   class HashFunc;
 #endif

   /* DOXYGEN does not like template functions...
    *
    * @brief Swap the contents of two RefPtr.
    * @tparam Val The type referenced by both gum::RefPtr.
    * @param ptr1 The smart pointer the content of which we swap with that of
    * ptr2.
    * @param ptr2 The smart pointer the content of which we replace with that of
    * ptr1.
    */
   template < typename Val >
   void swap(RefPtr< Val >& ptr1, RefPtr< Val >& ptr2);

   // ===========================================================================
   // ===                           SMART POINTERS                            ===
   // ===========================================================================
   template < typename Val >
   class RefPtr {
     public:
     friend void swap<>(RefPtr< Val >&, RefPtr< Val >&);

     // ============================================================================
     // ============================================================================

     explicit RefPtr(Val* val = 0);

     RefPtr(const RefPtr< Val >& from);

     template < typename DownVal >
     RefPtr(const RefPtr< DownVal >& from);

     ~RefPtr();

     // ============================================================================
     // ============================================================================

     operator bool() const;

     void clear();

     unsigned int refCount() const;

     // ============================================================================
     // ============================================================================

     RefPtr< Val >& operator=(const RefPtr< Val >& from);

     RefPtr< Val >& operator=(Val* from);

     template < typename DownVal >
     RefPtr< Val >& operator=(const RefPtr< DownVal >& from);

     bool operator==(const RefPtr< Val >& from) const;

     bool operator!=(const RefPtr< Val >& from) const;

     Val* operator->() const;

     Val& operator*();

     const Val& operator*() const;

     // ============================================================================
     // ============================================================================
     private:
     template < typename T >
     friend class RefPtr;

     template < typename T >
     friend class HashFunc;

     Val* __val;

     unsigned int* __refcount;

     void __destroy(unsigned int*, Val*);

     unsigned int* __refCountPtr() const;
   };

 } /* namespace gum */


 #ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
 #  ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
 #    ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
 extern template class gum::RefPtr< int >;
 #    endif
 #  endif
 #endif
 #ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
 #  ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
 #    ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
 extern template class gum::RefPtr< long >;
 #    endif
 #  endif
 #endif

 #ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
 #  ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
 #    ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
 extern template class gum::RefPtr< double >;
 #    endif
 #  endif
 #endif


 // always include the _tpl.h as it contains only templates
 #include <agrum/core/refPtr_tpl.h>

 #endif /* GUM_REFPTR_H */
gum::RefPtr::operator=
RefPtr< Val > & operator=(const RefPtr< Val > &from)
Copy operator.
Definition: refPtr_tpl.h:84

gum::RefPtr::RefPtr
friend class RefPtr
A friend to allow downcastings.
Definition: refPtr.h:331

gum::RefPtr::~RefPtr
~RefPtr()
Class destructor.
Definition: refPtr_tpl.h:173

gum::RefPtr::__refCountPtr
unsigned int * __refCountPtr() const
A function to return the refcount pointer.
Definition: refPtr_tpl.h:253

gum::RefPtr::operator->
Val * operator->() const
Dereferencing operator.
Definition: refPtr_tpl.h:214

agrum.h

gum::RefPtr::__destroy
void __destroy(unsigned int *, Val *)
A function to remove the content of the smart pointer, if any.
Definition: refPtr_tpl.h:68

gum::HashFunc
Class template representing hashing function of LpCol.
Definition: hashFunc.h:471

gum
Copyright 2005-2019 Pierre-Henri WUILLEMIN et Christophe GONZALES (LIP6) {prenom.nom}_at_lip6.fr.
Definition: agrum.h:25

gum::RefPtr
Smart pointersaGrUM&#39;s smart pointers keep track of the number of times the value they point to is ref...
Definition: refPtr.h:117

gum::RefPtr::__val
Val * __val
The dumb pointer encapsulated into the "smart" pointer.
Definition: refPtr.h:338

gum::RefPtr::operator!=
bool operator!=(const RefPtr< Val > &from) const
Checks whether two RefPtr<Val> are smart pointers for different elements.
Definition: refPtr_tpl.h:189

refPtr_tpl.h
Copyright 2005-2019 Pierre-Henri WUILLEMIN et Christophe GONZALES (LIP6) {prenom.nom}_at_lip6.fr.

gum::RefPtr::operator==
bool operator==(const RefPtr< Val > &from) const
Checks whether two RefPtr<Val> are smart pointers for the same element.
Definition: refPtr_tpl.h:182

gum::RefPtr::clear
void clear()
Makes the smart pointer point to 0.
Definition: refPtr_tpl.h:230

bool

gum::RefPtr::operator*
Val & operator*()
Dereferencing operator.
Definition: refPtr_tpl.h:196

gum::swap
void swap(RefPtr< Val > &ptr1, RefPtr< Val > &ptr2)
Swap the contents of two RefPtr.
Definition: refPtr_tpl.h:260

gum::RefPtr::refCount
unsigned int refCount() const
Returns the number of smart pointer referencing the contained pointer.
Definition: refPtr_tpl.h:244

gum::RefPtr::__refcount
unsigned int * __refcount
A reference counter on *val.
Definition: refPtr.h:341