SurfaceHolderImpl.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRKEVENTPRIMITIVES_SURFACEHOLDER_H
#define TRKEVENTPRIMITIVES_SURFACEHOLDER_H
 
#include "TrkEventPrimitives/SurfaceUniquePtrT.h"
 
namespace Trk {
 
/* Helper to avoid repeating code
 */
template<typename S>
class SurfacePtrHolderImplBase
{
protected:
  // protected we can not create instances of this object
  // is to be used as helper
  ~SurfacePtrHolderImplBase() = default;
};
 
/*
 * Implementation based on plain ptr and
 * isFree semantics
 */
template<typename S>
class SurfacePtrHolderImpl
{
public:
  SurfacePtrHolderImpl() = default;
  explicit SurfacePtrHolderImpl(const S& s)
    : m_associatedSurface(cloneHelper(&s))
  {}
  explicit SurfacePtrHolderImpl(const S* s)
    : m_associatedSurface(s)
  {}
  SurfacePtrHolderImpl(const SurfacePtrHolderImpl& other)
    : m_associatedSurface(cloneHelper(other.m_associatedSurface))
  {}
  SurfacePtrHolderImpl(SurfacePtrHolderImpl&& other) noexcept
  {
    // tranfer ownership and leave other nullptr
    m_associatedSurface = other.m_associatedSurface;
    other.m_associatedSurface = nullptr;
  }
  SurfacePtrHolderImpl& operator=(const SurfacePtrHolderImpl& other)
  {
    if (this != &other) {
      destroySurface(); // clean up ourselves
      m_associatedSurface = cloneHelper(other.m_associatedSurface);
    }
    return *this;
  }
 
  SurfacePtrHolderImpl& operator=(SurfacePtrHolderImpl&& other) noexcept
  {
    // destroy current surface
    destroySurface();
    // steal payload of other and leave it to nullptr
    this->m_associatedSurface = other.m_associatedSurface;
    other.m_associatedSurface = nullptr;
    return *this;
  }
  void destroySurface() noexcept
  {
    if (m_associatedSurface && m_associatedSurface->isFree()) {
      delete m_associatedSurface;
    }
    //
    m_associatedSurface = nullptr;
  }
  const S* surfacePtr() { return m_associatedSurface; }
  const S* release() noexcept
  {
    const S* tmp = m_associatedSurface;
    m_associatedSurface = nullptr;
    return tmp;
  }
  static const S* cloneHelper(const S* input)
  {
    return (input && input->isFree() ? input->clone() : input);
  }
 
protected:
  const S* m_associatedSurface = nullptr;
  // protected we can not create instances of this object
  // is to be used as helper
  ~SurfacePtrHolderImpl() { destroySurface(); };
};
 
/*
 * Implementation based on plain ptr and
 * has detector Element Semantics
 */
template<typename S>
class SurfacePtrHolderImplDetEl
{
 
public:
  SurfacePtrHolderImplDetEl() = default;
  explicit SurfacePtrHolderImplDetEl(const S& s)
    : m_associatedSurface(cloneHelper(&s))
  {}
  explicit SurfacePtrHolderImplDetEl(const S* s)
    : m_associatedSurface(s)
  {}
  SurfacePtrHolderImplDetEl(const SurfacePtrHolderImplDetEl& other)
    : m_associatedSurface(cloneHelper(other.m_associatedSurface))
  {}
  SurfacePtrHolderImplDetEl(SurfacePtrHolderImplDetEl&& other) noexcept
  {
    // tranfer ownership and leave other nullptr
    m_associatedSurface = other.m_associatedSurface;
    other.m_associatedSurface = nullptr;
  }
  SurfacePtrHolderImplDetEl& operator=(const SurfacePtrHolderImplDetEl& other)
  {
    if (this != &other) {
      destroySurface(); // clean up ourselves
      m_associatedSurface = cloneHelper(other.m_associatedSurface);
    }
    return *this;
  }
  SurfacePtrHolderImplDetEl& operator=(
    SurfacePtrHolderImplDetEl&& other) noexcept
  {
    // destroy current surface
    destroySurface();
    // steal payload of other and leave it to nullptr
    this->m_associatedSurface = other.m_associatedSurface;
    other.m_associatedSurface = nullptr;
    return *this;
  }
  const S* surfacePtr() { return m_associatedSurface; }
  const S* release() noexcept
  {
    const S* tmp = m_associatedSurface;
    m_associatedSurface = nullptr;
    return tmp;
  }
  void destroySurface() noexcept
  {
    if (m_associatedSurface &&
        m_associatedSurface->associatedDetectorElement() == nullptr) {
      delete m_associatedSurface;
    }
    //
    m_associatedSurface = nullptr;
  }
 
  static const S* cloneHelper(const S* input)
  {
    return (input && input->associatedDetectorElement() == nullptr
              ? input->clone()
              : input);
  }
 
protected:
  const S* m_associatedSurface = nullptr;
  // protected we can not create instances of this object
  // is to be used as helper
  ~SurfacePtrHolderImplDetEl() { destroySurface(); };
};
 
/*
 * Implementation based on SurfaceUniquePtr
 */
template<typename S>
class SurfaceUniqHolderImpl
{
public:
  SurfaceUniqHolderImpl() = default;
 
 
  explicit SurfaceUniqHolderImpl(const S& s)
    : m_associatedSurface(s.isFree() ? s.clone() : &s)
  {}
 
  explicit SurfaceUniqHolderImpl(const S* s)
    : m_associatedSurface(s)
  {}
 
  SurfaceUniqHolderImpl(const SurfaceUniqHolderImpl& other)
    : m_associatedSurface(other.m_associatedSurface &&
                              other.m_associatedSurface->isFree()
                            ? other.m_associatedSurface->clone()
                            : other.m_associatedSurface.get())
  {}
 
  SurfaceUniqHolderImpl(SurfaceUniqHolderImpl&&) noexcept = default;
 
  SurfaceUniqHolderImpl& operator=(const SurfaceUniqHolderImpl& other)
  {
    if (this != &other) {
      m_associatedSurface.reset(
        (other.m_associatedSurface && other.m_associatedSurface->isFree())
          ? other.m_associatedSurface->clone()
          : other.m_associatedSurface.get());
    }
    return *this;
  }
 
  SurfaceUniqHolderImpl& operator=(SurfaceUniqHolderImpl&&) noexcept = default;
 
  const S* surfacePtr() { return m_associatedSurface.get(); }
 
  void destroySurface() noexcept { m_associatedSurface.reset(); }
 
  const S* release() noexcept { return m_associatedSurface.release(); }
 
protected:
  SurfaceUniquePtrT<const S> m_associatedSurface = nullptr;
  // protected we can not create instances of this object
  // is to be used as helper
  ~SurfaceUniqHolderImpl() = default;
};
}
 
#endif