PhxPtr.h

Go to the documentation of this file.

#ifndef PHX_PTR_H
#define PHX_PTR_H

#include <Phx/PhxConfig.h>
#include <iostream>

namespace Phx {

  template <class T>
  class Ptr {
  public:
    // Default constructor makes NULL pointer
    Ptr() : mPtr(0) { }

    // create a new Ptr from a raw pointer.
    Ptr(T* p) : mPtr(p) { if (mPtr) mPtr->newReference(); }

    Ptr(const Ptr<T>& p) : mPtr(p.mPtr) { if (mPtr) mPtr->newReference(); }

    template <class Y> /* explicit? */
    Ptr(const Ptr<Y>& p) : mPtr(p.ptr()) { if (mPtr) mPtr->newReference(); }

    ~Ptr() {if (mPtr) mPtr->deleteReference();}

    // assignment
    const Ptr<T>& operator=(const Ptr<T>& rhs) {
      T* oldPtr = mPtr;
      mPtr = rhs.mPtr;
      if (mPtr) mPtr->newReference();
      if (oldPtr) oldPtr->deleteReference();
      return *this;
    }

    // less-than comparison only (for containers, mostly)
    bool operator<(const Ptr<T>& rhs) { return mPtr < rhs.ptr(); }

    // equality comparison
    bool operator==(const Ptr<T>& rhs) const {
      return mPtr == rhs.mPtr;
    }
    // inequality comparison
    bool operator!=(const Ptr<T>& rhs) const {
      return mPtr != rhs.mPtr;
    }

    // pointer operator overloading
    T* operator->() const { return mPtr; }
    T& operator*() const { return *mPtr; }
    bool operator!() const { return !mPtr; }

    operator bool() const { return mPtr ? true : false; }

    T* ptr() const { return mPtr; }

    template <class Y>
    Ptr<Y> dynamicCast(void) const { return Ptr<Y>(dynamic_cast<Y*>(mPtr)); }

    template <class Y>
    Ptr<Y> staticCast(void) const { return Ptr<Y>(static_cast<Y*>(mPtr)); }

  private:
    T* mPtr;
  };

  template <class T> std::ostream& operator<<(std::ostream& os, const Ptr<T>& ptr) {
    os << ptr.ptr();
    return os;
  }

}; // namespace Phx

#endif /* PHX_PTR_H */

---