any.hpp

#ifndef DITTO_ANY_H
#define DITTO_ANY_H
 
#include <memory>

namespace ditto {

class any {
private:
  struct VirtualBase {
    virtual ~VirtualBase() noexcept = default;
    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;
 
  // TOOD(kj): C++ guidelines recommend using `explicit` for single-arg
  // constructors to avoid unexpected implicit conversions.  However, our
  // AnyHelpers functions currently rely on implicit conversion, so we are
  // intentionally not using `explicit` here.  We should look into whether there
  // is a safer way to do what we are doing.
  template <typename T>
  any(T const &value) noexcept // NOLINT
      : 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;
    }
    throw std::bad_cast();
  }
};
 
template <typename T> T any_cast(ditto::any const &operand) {
  return operand.as<T>();
}
 
} // namespace ditto
 
#endif