#ifndef UNIQUE_PTR_GUARD
#define UNIQUE_PTR_GUARD
#include <algorithm>

namespace ptrs::unique {
template <typename T = int>
struct default_deleter {
    void operator()(T *ptr) {
        delete ptr;
    }
};
template <typename T, typename Deleter = struct default_deleter<T>>
struct unique_ptr {
private:
    T *ptr_on_object;
    Deleter my_deleter;

public:
    unique_ptr(T *cur_ptr, Deleter tmp)
        : ptr_on_object(std::move(cur_ptr)), my_deleter(std::move(tmp)) {
    }
    unique_ptr() : ptr_on_object(nullptr) {
    }
    explicit unique_ptr(T *cur_ptr) : ptr_on_object(std::move(cur_ptr)) {
    }
    explicit unique_ptr(const unique_ptr &other) = delete;
    unique_ptr(unique_ptr &&other)
        : ptr_on_object(std::exchange(other.ptr_on_object, nullptr)),
          my_deleter(std::move(other.my_deleter)) {
    }
    unique_ptr &operator=(const unique_ptr &other) = delete;
    unique_ptr &operator=(unique_ptr &&other) {
        auto tmp = std::exchange(other.ptr_on_object, nullptr);
        if (ptr_on_object != nullptr) {
            my_deleter(ptr_on_object);
        }
        ptr_on_object = std::move(tmp);
        my_deleter = std::move(other.my_deleter);
        return *this;
    }
    ~unique_ptr() {
        my_deleter(ptr_on_object);
    };

    T *get() const {
        return ptr_on_object;
    }

    explicit operator bool() const {
        return ptr_on_object != nullptr;
    }

    friend void swap(unique_ptr<T, Deleter> &a, unique_ptr<T, Deleter> &b) {
        std::swap(a.ptr_on_object, b.ptr_on_object);
        std::swap(a.my_deleter, b.my_deleter);
    }

    T *release() {
        auto tmp = std::move(ptr_on_object);
        ptr_on_object = nullptr;
        return tmp;
    }

    void reset() {
        my_deleter(ptr_on_object);
        ptr_on_object = nullptr;
    }

    void reset(T * const other) {
        my_deleter(ptr_on_object);
        ptr_on_object = std::move(other);
    }

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

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

    bool operator==(const unique_ptr &other) const {
        return ptr_on_object == other.ptr_on_object;
    }

    bool operator!=(const unique_ptr &other) const {
        return ptr_on_object != other.ptr_on_object;
    }
};

}  // namespace ptrs::unique
#endif