ProxyBase.h

Go to the documentation of this file.

#ifndef Tracker_ProxyBase_H
#define Tracker_ProxyBase_H

#include "TrackingTools/TrajectoryParametrization/interface/TrajectoryStateExceptions.h"
#include "TrackingTools/TrajectoryState/interface/CopyUsingNew.h"
#include "FWCore/Utilities/interface/Visibility.h"
#include "FWCore/Utilities/interface/Likely.h"
#include "FWCore/Utilities/interface/GCC11Compatibility.h"

template <class T, class Cloner > 
class ProxyBase {
protected:

  ProxyBase()  noexcept : theData(0) {}

  explicit ProxyBase( T* p)  noexcept : theData(p) {if (theData) theData->addReference();}

  ProxyBase( const ProxyBase& other)  noexcept {
    theData = other.theData;
    if (theData) theData->addReference();
  }

  ~ProxyBase()  noexcept { 
    destroy();
  }

  ProxyBase& operator=( const ProxyBase& other)  noexcept {
    if  likely( theData != other.theData) { 
      destroy();
      theData = other.theData;
      if (theData) theData->addReference();
    }
    return *this;
  }


  void swap(ProxyBase& other)  noexcept {
    std::swap(theData,other.theData);
  }


  ProxyBase(ProxyBase&& other)  noexcept {
    theData = other.theData;
    other.theData=0;
  }
  
  ProxyBase& operator=(ProxyBase&& other)  noexcept {
    if  likely( theData != other.theData) { 
      destroy();
      theData = other.theData;
      other.theData=0;
    }
    return *this;
  }

  const T& data() const { check(); return *theData;}

  T& unsharedData() {
    check(); 
    if ( references() > 1) {
      theData->removeReference();
      theData = Cloner().clone( *theData);
      if (theData) theData->addReference();
    }
    return *theData;
  }

  T& sharedData() { check(); return *theData;}

  bool isValid() const { return theData != 0;}

  void check() const {
    if  unlikely(theData == 0)
      throw TrajectoryStateException("Error: uninitialized ProxyBase used");
  }

  void destroy()  noexcept { if  likely(isValid()) theData->removeReference();}

  int  references() const {return theData->references();}  

private:
  T* theData;
};

template <class T, class Cloner >
inline
void swap(ProxyBase<T,Cloner>& lh, ProxyBase<T,Cloner>& rh)  noexcept {
  lh.swap(rh);
}

#endif // Tracker_ProxyBase_H