SharedPtr< T >

#include <fjcore.hh>

Collaboration diagram for SharedPtr< T >:

Classes
class	__SharedCountingPtr

Public Member Functions
	SharedPtr ()
template<class Y >
	SharedPtr (Y *ptr)
	SharedPtr (SharedPtr const &share)
	~SharedPtr ()
void	reset ()
template<class Y >
void	reset (Y *ptr)
template<class Y >
void	reset (SharedPtr< Y > const &share)
SharedPtr &	operator= (SharedPtr const &share)
template<class Y >
SharedPtr &	operator= (SharedPtr< Y > const &share)
T *	operator() () const
T &	operator* () const
T *	operator-> () const
T *	get () const
bool	unique () const
long	use_count () const
	operator bool () const
void	swap (SharedPtr &share)
void	set_count (const long &count)

Private Member Functions
__SharedCountingPtr *	_get_container () const
void	_decrease_count ()

Private Attributes
__SharedCountingPtr *	_ptr

Constructor & Destructor Documentation

SharedPtr() [1/3]

SharedPtr ( )

inline

: _ptr(NULL){}

SharedPtr() [2/3]

SharedPtr ( Y *  ptr )

inlineexplicit

                                              {
    _ptr = new __SharedCountingPtr(ptr);
  }

SharedPtr() [3/3]

SharedPtr ( SharedPtr< T > const &  share )

inline

                                     : _ptr(share._get_container()){
    if (_ptr!=NULL) ++(*_ptr);
  }

~SharedPtr()

~SharedPtr ( )

inline

              {
    if (_ptr==NULL) return;
    _decrease_count();
  }

Member Function Documentation

_decrease_count()

void _decrease_count ( )

inlineprivate

                        {
    (*_ptr)--;
    if (_ptr->use_count()==0)
      delete _ptr; // that automatically deletes the object itself
  }

_get_container()

__SharedCountingPtr* _get_container ( ) const

inlineprivate

                                                    {
    return _ptr;
  }

get()

T* get ( ) const

inline

                       {
    if (_ptr==NULL) return NULL;
    return _ptr->get();
  }

operator bool()

operator bool ( ) const

inline

                              {
    return (get()!=NULL);
  }

operator()()

T* operator() ( ) const

inline

                        {
    if (_ptr==NULL) return NULL;
    return _ptr->get(); // automatically returns NULL when out-of-scope
  }

operator*()

T& operator* ( ) const

inline

                             {
    return *(_ptr->get());
  }

operator->()

T* operator-> ( ) const

inline

                              {
    if (_ptr==NULL) return NULL;
    return _ptr->get();
  }

operator=() [1/2]

SharedPtr& operator= ( SharedPtr< T > const &  share )

inline

                                               {
    reset(share);
    return *this;
  }

operator=() [2/2]

SharedPtr& operator= ( SharedPtr< Y > const &  share )

inline

                                                                    {
    reset(share);
    return *this;
  }

reset() [1/3]

void reset ( )

inline

              {
    SharedPtr().swap(*this);
  }

reset() [2/3]

void reset ( SharedPtr< Y > const &  share )

inline

                                                          {
    if (_ptr!=NULL){
      if (_ptr == share._get_container()) return;
      _decrease_count();
    }
    _ptr = share._get_container();  // Note: automatically set it to NULL if share is empty
    if (_ptr!=NULL) ++(*_ptr);
  }

reset() [3/3]

void reset ( Y *  ptr )

inline

                                       {
    SharedPtr(ptr).swap(*this);
  }

set_count()

void set_count ( const long &  count )

inline

                                    {
    if (_ptr==NULL) return;
    _ptr->set_count(count);
  }

swap()

void swap ( SharedPtr< T > &  share )

inline

                                     {
    __SharedCountingPtr* share_container = share._ptr;
    share._ptr = _ptr;
    _ptr = share_container;
  }

unique()

bool unique ( ) const

inline

                            {
    return (use_count()==1);
  }

use_count()

long use_count ( ) const

inline

                               {
    if (_ptr==NULL) return 0;
    return _ptr->use_count(); // automatically returns NULL when out-of-scope
  }

Member Data Documentation

_ptr

__SharedCountingPtr* _ptr

private

---

The documentation for this class was generated from the following file:

• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/JetObservables/interface/fjcore.hh