myany.cpp

#pragma once

#include <memory>

class Any {
public:
    Any() = default;

    template <class T>
    Any(T value) : ptr_(std::make_unique<Derived<T>>(std::move(value))) {
    }

    template <class T>
    Any(const T& value) : ptr_(std::make_unique<Derived<T>>(value)) {
    }

    template <class T>
    Any& operator=(const T& value) {
        ptr_ = std::make_unique<Base>(Derived<T>(value));
        return *this;
    }

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

    Any& operator=(const Any& rhs) {
        ptr_ = rhs.ptr_->Clone();
        return *this;
    }

    ~Any() {
    }

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

    void Clear() {
        ptr_ = nullptr;
    }

    void Swap(Any& rhs) {
        std::swap(ptr_, rhs.ptr_);
    }

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

private:
    struct Base {
        virtual ~Base() = default;

        virtual std::unique_ptr<Base> Clone() = 0;
    };

    template <class T>
    struct Derived : public Base {
        Derived(T value) : value_(std::move(value)) {
        }

        std::unique_ptr<Base> Clone() override {
            return std::make_unique<Derived<T>>(value_);
        }

        T value_;
    };

    std::unique_ptr<Base> ptr_;
};