ShadowPtr.h

Go to the documentation of this file.

#ifndef _utl_ShadowPtr_h_
#define _utl_ShadowPtr_h_

#include <utl/ShadowPtr_fwd.h>
#include <utility>


namespace utl {

  namespace ShadowPtrMeta {

    struct True { };
    struct False { char c[256]; };

    template<typename T>
    True MatchCloneTag(typename T::IsClonableTag* const);

    template<typename T>
    False MatchCloneTag(...);

    template<typename T>
    struct HasClone {
      static const bool value =
        sizeof(MatchCloneTag<T>(0)) == sizeof(True);
    };

    template<bool v, typename T>
    struct BoolSwitch {
      static T* GetCopy(const T& t) { return new T(t); }
    };

    template<typename T>
    struct BoolSwitch<true, T> {
      static T* GetCopy(const T& t) { return t.Clone(); }
    };

    template<typename T>
    T* Clone(const T& src)
    { return BoolSwitch<HasClone<T>::value, T>::GetCopy(src); }

    template<typename T>
    T* CloneOne(const T& src)
    { return Clone(src); }

  }


  template<typename T>
  class Meta {
  private:
    typedef class { } False;
    typedef class { False f[256]; } True;

    template<typename U>
    static True MatchCloneTag(typename U::IsClonableTag* const);

    template<typename U>
    static False MatchCloneTag(...);

    template<typename U>
    struct HasClone {
      static const bool value =
        sizeof(Meta<T>::template MatchCloneTag<U>(0)) == sizeof(True);
    };

    template<bool v, int = 0>
    struct BoolSwitch {
      static T* GetCopy(const T& t) { return new T(t); }
    };

    template<int i>
    struct BoolSwitch<true, i> {
      static T* GetCopy(const T& t) { return t.Clone(); }
    };

  public:
    static T* GetCopy(const T& t)
    { return BoolSwitch<HasClone<T>::value>::GetCopy(t); }
  };


  template<typename T, class DereferenceCheck/* = ThrowOnZeroDereference*/>
  class ShadowPtr {

  public:
    ShadowPtr() { }

    // shallow ctor
    explicit ShadowPtr(T* const p) : fPtr(p) { }

    // deep copy ctor
    ShadowPtr(const ShadowPtr& sp) { DeepCopy(sp.fPtr); }

    ShadowPtr(ShadowPtr&& sp) noexcept : fPtr(std::exchange(sp.fPtr, nullptr)) { }

    ~ShadowPtr() noexcept { Delete(); }

    // deep copy assignment
    ShadowPtr&
    operator=(const ShadowPtr& sp)
    {
      if (this != &sp) {
        Delete();
        DeepCopy(sp.fPtr);
      }
      return *this;
    }

    ShadowPtr&
    operator=(ShadowPtr&& sp)
    {
      Delete();
      fPtr = sp.fPtr;
      sp.fPtr = nullptr;
      return *this;
    }

    ShadowPtr& operator=(T* const p) { Delete(); fPtr = p; return *this; }

    T* Get() { return fPtr; }
    const T* Get() const { return fPtr; }

    T& operator*() { DereferenceCheck::Examine(fPtr); return *fPtr; }
    const T& operator*() const { DereferenceCheck::Examine(fPtr); return *fPtr; }

    T* operator->() { DereferenceCheck::Examine(fPtr); return fPtr; }
    const T* operator->() const { DereferenceCheck::Examine(fPtr); return fPtr; }

    bool operator==(const ShadowPtr& sp) const { return fPtr == sp.fPtr; }
    bool operator!=(const ShadowPtr& sp) const { return fPtr != sp.fPtr; }
    bool operator==(const T* const p) const { return fPtr == p; }
    bool operator!=(const T* const p) const { return fPtr != p; }

    explicit operator bool() const { return fPtr; }

    void Swap(ShadowPtr& sp) { std::swap(fPtr, sp.fPtr); }

  private:
    void Delete() noexcept { delete fPtr; }

  protected:
    void DeepCopy(const T* const p) { fPtr = p ? Meta<T>::GetCopy(*p) : nullptr; }

    T* fPtr = nullptr;

  };


  template<typename T, class DereferenceCheck/* = ThrowOnZeroDereference*/>
  class InitializedShadowPtr : public ShadowPtr<T, DereferenceCheck> {
  public:
    InitializedShadowPtr() : ShadowPtr<T, DereferenceCheck>(new T) { }
  };


  template<typename T, class D>
  inline bool DeepEqual(const ShadowPtr<T, D>& s1, const ShadowPtr<T, D>& s2)
  { return (!s1 && !s2) || (s1 && s2 && *s1 == *s2); }


  template<typename T, class D>
  inline void swap(ShadowPtr<T, D>& a, ShadowPtr<T, D>& b)
  { a.Swap(b); }

}


#endif