#pragma once
#include "shared_pointer.hh"
template <typename T>
SharedPointer<T>::SharedPointer(element_type* p)
{
    if (p == nullptr)
    {
        data_ = nullptr;
        count_ = nullptr;
    }
    else
    {
        data_ = p;
        count_ = new long{ 1 };
    }
}
template <typename T>
SharedPointer<T>::~SharedPointer()
{
    if (count_ != nullptr)
    {
        (*count_)--;
        if (*count_ == 0)
        {
            delete count_;
            if (data_ != nullptr)
                delete data_;
        }
    }
}
template <typename T>
SharedPointer<T>::SharedPointer(const SharedPointer<element_type>& other)
{
    this->~SharedPointer();
    data_ = other.data_;
    if (data_ == nullptr)
        count_ = nullptr;
    count_ = other.count_;
    if (count_ != nullptr)
        (*count_)++;
}
template <typename T>
void SharedPointer<T>::reset(element_type* p)
{
    if (data_ == p)
        return;
    this->~SharedPointer();
    data_ = p;
    if (p == nullptr)
        count_ = nullptr;
    else
        count_ = new long{ 1 };
}
template <typename T>
SharedPointer<T>& SharedPointer<T>::operator=(const SharedPointer<T>& other)
{
    this->~SharedPointer();

    data_ = other.data_;
    count_ = other.count_;
    if (nullptr != other.data_)
    {
        (*this->count_)++;
    }
    return *this;
}
template <typename T>
T& SharedPointer<T>::operator*() const
{
    return *data_;
}

template <typename T>
T* SharedPointer<T>::operator->() const
{
    return data_;
}
template <typename T>
T* SharedPointer<T>::get() const
{
    return data_;
}
template <typename T>
long SharedPointer<T>::use_count() const
{
    if (count_ == nullptr)
        return 0;
    return *count_;
}
template <typename T>
template <typename U>
bool SharedPointer<T>::operator==(const SharedPointer<U>& rhs) const
{
    if (rhs.data_ == this->data_)
        return true;
    return false;
}
template <typename T>
template <typename U>
bool SharedPointer<T>::operator!=(const SharedPointer<U>& rhs) const
{
    return !(*this == rhs);
}
template <typename T>
bool SharedPointer<T>::operator==(const T* p) const
{
    return this->data_ == p;
}
template <typename T>
bool SharedPointer<T>::operator!=(const T* p) const
{
    return this->data_ != p;
}
template <typename T>
SharedPointer<T>& SharedPointer<T>::operator=(SharedPointer<T>&& other) noexcept
{
    this->~SharedPointer();
    data_ = other.data_;
    count_ = other.count_;
    other.data_ = nullptr;
    other.count_ = nullptr;
    return *this;
}
template <typename T>
SharedPointer<T>::SharedPointer(SharedPointer&& other)
{
    this->~SharedPointer();
    data_ = other.data_;
    count_ = other.count_;

    other.data_ = nullptr;
    other.count_ = nullptr;
}
template <typename T>
SharedPointer<T>::operator bool() const
{
    return data_ != nullptr;
}
template <typename T>
template <typename U>
bool SharedPointer<T>::is_a() const
{
    return dynamic_cast<U*>(data_);
}