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 {
 
/*
 * 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