any.hpp

#ifndef _ANY_
#define _ANY_
 
#include <memory>
 
namespace ditto {
 
class any {
private:
  struct VirtualBase {
    virtual ~VirtualBase() noexcept {}
    virtual std::type_info const &virtual_type() const noexcept = 0;
    virtual std::unique_ptr<VirtualBase> virtual_clone() const noexcept = 0;
 
    template <typename T>
    static std::unique_ptr<VirtualBase> upcast(T const &value) noexcept {
      return std::unique_ptr<VirtualBase>(new ConcreteType<T>(value));
    }
  };
 
  // main field of `any`:
  std::unique_ptr<VirtualBase> erased_value;
 
  // helper to go from `<T>` to `VirtualBase`.
  template <typename T> struct ConcreteType : VirtualBase {
    T value;
 
    explicit ConcreteType(T const &val) noexcept : value(val) {}
 
    std::type_info const &virtual_type() const noexcept override {
      return typeid(T);
    }
 
    std::unique_ptr<VirtualBase> virtual_clone() const noexcept override {
      return any::VirtualBase::upcast(value);
    }
  };
 
  template <typename T> friend T any_cast(ditto::any const &operand);
 
public:
  any() noexcept;
 
  template <typename T>
  any(T const &value) noexcept
      : erased_value(any::VirtualBase::upcast(value)) {}
 
  any(any const &other) noexcept;
 
  void swap(any &other) noexcept;
 
  any &operator=(any const &other) noexcept;
 
  std::type_info const &type() const noexcept;
 
  bool has_value() const noexcept;
 
  template <typename T> T as() const {
    if (auto ptr =
            dynamic_cast<any::ConcreteType<T> const *>(erased_value.get())) {
      return ptr->value;
    } else {
      throw std::bad_cast();
    }
  }
};
 
template <typename T> T any_cast(ditto::any const &operand) {
  return operand.as<T>();
}
 
} // namespace ditto
 
#endif // _ANY_