#pragma once
#include <memory>

class Any {
public:
    class InnerBase {
    public:
        virtual std::unique_ptr<InnerBase> Clone() = 0;
        virtual ~InnerBase() = default;
    };
    template <typename T>
    class Inner : public InnerBase {
    public:
        Inner(T&& val) : val_(std::forward<T>(val)) {
        }
        std::unique_ptr<InnerBase> Clone() override {
            return std::make_unique<Inner<T>>(std::forward<T>(val_));
        }
        T val_;
    };
    template <typename T>
    Any(T&& value) : ptr_(new Inner<T>(std::forward<T>(value))) {
    }
    Any() = default;

    //    template <class T>
    //    Any(const T& value) : ptr_(new Inner<T>(value)) {
    //    }

    Any(const Any& rhs) {
        ptr_ = (*rhs.ptr_).Clone();
    }

    template <class T>
    Any& operator=(const T& value) {
        (Any(value)).Swap(*this);
        return *this;
    }
    Any& operator=(const Any& rhs) {
        if (this == &rhs) {
            return *this;
        }
        (Any(rhs)).Swap(*this);
        return *this;
    }
    ~Any() {
    }

    bool Empty() const {
        if (!ptr_) {
            return true;
        } else {
            return false;
        }
    }

    void Clear() {
        ptr_.reset();
    }
    void Swap(Any& rhs) {
        ptr_.swap(rhs.ptr_);
    }

    template <class T>
    const T& GetValue() const {
        return dynamic_cast<Inner<T>&>(*ptr_).val_;
    }

private:
    std::unique_ptr<InnerBase> ptr_;
};