LameShadowPtr.h

Go to the documentation of this file.

#ifndef _utl_LameShadowPtr_h_
#define _utl_LameShadowPtr_h_

#include <algorithm>
#include <utl/ShadowPtrPolicy.h>
#include <utl/LameShadowPtr_fwd.h>

namespace utl {

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

  public:
    LameShadowPtr() { }

    explicit LameShadowPtr(T* const p) : fPtr(p) { }

    explicit LameShadowPtr(const LameShadowPtr& sp) { DeepCopy(sp.fPtr); }

    LameShadowPtr(LameShadowPtr&& sp) : fPtr(sp.fPtr) { sp.fPtr = nullptr; }

    ~LameShadowPtr() { Delete(); }

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

    LameShadowPtr&
    operator=(const LameShadowPtr& sp)
    {
      if (this != &sp) {
        Delete();
        DeepCopy(sp.fPtr);
      }
      return *this;
    }

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

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

    T& operator*();
    const T& operator*() const;

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

    bool operator==(const LameShadowPtr& sp) const { return fPtr == sp.fPtr; }
    bool operator!=(const LameShadowPtr& 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(LameShadowPtr& sp) { std::swap(fPtr, sp.fPtr); }

  private:
    void Delete();

  protected:
    void DeepCopy(const T* const p);

    T* fPtr = nullptr;

  };


  template<typename T, class DereferenceCheck/* = ThrowOnZeroDereference*/>
  class InitializedLameShadowPtr : public LameShadowPtr<T, DereferenceCheck> {

  public:
    InitializedLameShadowPtr() : LameShadowPtr<T, DereferenceCheck>(new T) { }

  };


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


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

}


#endif