#ifndef SHARED_PTR_H
#define SHARED_PTR_H

#include <algorithm>

#undef SOLVED_1
#define SOLVED_1

namespace Ti
{
  template <typename T>
    class shared_ptr
    {
      private:
        T* m_ptr;
        unsigned long* m_count;

      public:
        shared_ptr()
          : m_ptr(NULL), m_count(NULL)
        {}

        T* get() const
        {
          return m_ptr;
        }

        shared_ptr(const shared_ptr<T>& other)
          : m_ptr(other.m_ptr), m_count(other.m_count)
        {
          add_ref();
        }

        template <typename O>
          shared_ptr(const shared_ptr<O>& other)
            : m_ptr(other.m_ptr), m_count(other.m_count)
          {
            add_ref();
          }

        /* used to construct shared_ptr with a sub-object of O */
        template <typename O>
          shared_ptr(const shared_ptr<O>& other, T* ptr)
            : m_ptr(ptr), m_count(other.m_count)
          {
            add_ref();
          }

        template <typename O>
          explicit shared_ptr(O* p)
          : m_ptr(p), m_count(new unsigned long(1))
          {}

        shared_ptr& operator=(const shared_ptr<T>& other)
        {
          if (*this == other)
            return *this;
          release();
          m_ptr = other.m_ptr;
          m_count = other.m_count;
          add_ref();
          return *this;
        }

        template <typename O>
          shared_ptr& operator=(const shared_ptr<O>& other)
        {
          if (*this == other)
            return *this;
          release();
          m_ptr = other.m_ptr;
          m_count = other.m_count;
          add_ref();
          return *this;
        }

        ~shared_ptr()
        {
          release();
        }

        T& operator*() const
        {
          return *m_ptr;
        }

        T* operator->() const
        {
          return m_ptr;
        }

        void swap(shared_ptr<T>& other)
        {
          std::swap(m_ptr, other.m_ptr);
          std::swap(m_count, other.m_count);
        }

        inline void reset()
        {
          shared_ptr().swap(*this);
        }

      private:
        void add_ref()
        {
          if (m_count != NULL)
            ++(*m_count);
        }

        void release()
        {
          if (m_ptr != NULL)
          {
            --(*m_count);
            if (*m_count == 0)
            {
              delete m_ptr;
              delete m_count;
            }
          }
        }

        template<class O> friend class shared_ptr;

        template <typename R, typename... Args>
          friend shared_ptr<R> make_shared(Args...);

        template<typename U1, typename U2>
          friend bool operator==(const shared_ptr<U1>& a, const shared_ptr<U2>& b);

        template<typename U1, typename U2>
          friend bool operator==(const shared_ptr<U1>& a, const U2* b);

        template<typename U1, typename U2>
          friend bool operator==(const U1* a, const shared_ptr<U2>& b);

        template<typename U1, typename U2>
          friend bool operator!=(const shared_ptr<U1>& a, const U2* b);

        template<typename U1, typename U2>
          friend bool operator!=(const U1* a, const shared_ptr<U2>& b);

        template<typename U1, typename U2>
          friend bool operator!=(const shared_ptr<U1>& a, const shared_ptr<U2>& b);

        template <typename R, typename F>
          friend shared_ptr<R> shared_dynamic_cast(const shared_ptr<F>& from);
    };

  template <typename T, typename ... Args>
    shared_ptr<T> make_shared(Args ... args)
    {
      return shared_ptr<T>(new T(args ...));
    }

  template<typename U1, typename U2>
    bool operator==(const shared_ptr<U1>& a, const shared_ptr<U2>& b)
    {
      return a.get() == b.get();
    }

  template<typename U1, typename U2>
    bool operator==(const shared_ptr<U1>& a, const U2* b)
    {
      return a.get() == b.get();
    }

  template<typename U1, typename U2>
    bool operator==(const U1* a, const shared_ptr<U2>& b)
    {
      return a.get() == b.get();
    }

  template<typename U1, typename U2>
    bool operator!=(const shared_ptr<U1>& a, const U2* b)
    {
      return a.get() != b.get();
    }

  template<typename U1, typename U2>
    bool operator!=(const U1* a, const shared_ptr<U2>& b)
    {
      return a.get() != b.get();
    }

  template<typename U1, typename U2>
    bool operator!=(const shared_ptr<U1>& a, const shared_ptr<U2>& b)
    {
      return a.get() != b.get();
    }

  template <typename T, typename F>
    shared_ptr<T> shared_dynamic_cast(const shared_ptr<F>& from)
    {
      T* castptr = dynamic_cast<T *>(from.get());
      if (castptr != NULL)
        return shared_ptr<T>(from, castptr);
      else
        return shared_ptr<T>();
    }
} // end namespace ti

namespace std
{
  using namespace Ti;
  template <typename T>
    inline void swap(shared_ptr<T>& t1, shared_ptr<T>& t2)
    {
      t1.swap(t2);
    }
}

#endif

/* vim: set et sw=2 ts=2: */