tdesktop/Telegram/SourceFiles/base/unique_any.h

231 lines
5.7 KiB
C++

/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#pragma once
#include <any>
namespace base {
namespace details {
template <typename Value>
struct moveable_as_copyable_wrap {
moveable_as_copyable_wrap(Value &&other)
: value(std::move(other)) {
}
moveable_as_copyable_wrap &operator=(Value &&other) {
value = std::move(other);
return *this;
}
moveable_as_copyable_wrap(moveable_as_copyable_wrap &&other)
: value(std::move(other.value)) {
}
moveable_as_copyable_wrap(
const moveable_as_copyable_wrap &other) {
Unexpected("Attempt to copy-construct a move-only type.");
}
moveable_as_copyable_wrap &operator=(
moveable_as_copyable_wrap &&other) {
value = std::move(other.value);
return *this;
}
moveable_as_copyable_wrap &operator=(
const moveable_as_copyable_wrap &other) {
Unexpected("Attempt to copy-assign a move-only type.");
}
Value value;
};
template <
typename Value,
typename = std::enable_if_t<
std::is_move_constructible_v<std::decay_t<Value>>
&& !std::is_lvalue_reference_v<Value>>>
auto wrap_moveable_as_copyable(Value &&value) {
return moveable_as_copyable_wrap<Value>(std::move(value));
}
} // namespace details
class unique_any;
template <typename Value>
Value *any_cast(unique_any *value) noexcept;
template <typename Value>
const Value *any_cast(const unique_any *value) noexcept;
class unique_any final {
public:
// Construction and destruction [any.cons]
constexpr unique_any() noexcept {
}
unique_any(const unique_any &other) = delete;
unique_any &operator=(const unique_any &other) = delete;
unique_any(unique_any &&other) noexcept
: _impl(std::move(other._impl)) {
}
unique_any &operator=(unique_any &&other) noexcept {
_impl = std::move(other._impl);
return *this;
}
template <
typename Value,
typename = std::enable_if_t<
!std::is_same_v<std::decay_t<Value>, unique_any>>>
unique_any(Value &&other)
: unique_any(
std::forward<Value>(other),
std::is_copy_constructible<std::decay_t<Value>>()) {
}
template <
typename Value,
typename = std::enable_if_t<
!std::is_same_v<std::decay_t<Value>, unique_any>>>
unique_any &operator=(Value &&other) {
if constexpr (std::is_copy_constructible_v<std::decay_t<Value>>) {
_impl = std::forward<Value>(other);
} else if constexpr (std::is_move_constructible_v<std::decay_t<Value>>
&& !std::is_lvalue_reference_v<Value>) {
_impl = details::wrap_moveable_as_copyable(std::move(other));
} else {
static_assert(
false_t(Value{}),
"Bad value for base::unique_any.");
}
return *this;
}
template <
typename Value,
typename ...Args,
typename = std::enable_if_t<
std::is_constructible_v<std::decay_t<Value>, Args...>
&& std::is_copy_constructible_v<decay_t<Value>>>>
std::decay_t<Value> &emplace(Args &&...args) {
return _impl.emplace<Value>(std::forward<Args>(args)...);
}
void reset() noexcept {
_impl.reset();
}
void swap(unique_any &other) noexcept {
_impl.swap(other._impl);
}
bool has_value() const noexcept {
return _impl.has_value();
}
// Should check if it is a moveable_only wrap first.
//const std::type_info &type() const noexcept {
// return _impl.type();
//}
private:
template <
typename Value,
typename = std::enable_if_t<
!std::is_same_v<std::decay_t<Value>, unique_any>
&& std::is_copy_constructible_v<std::decay_t<Value>>>>
unique_any(Value &&other, std::true_type)
: _impl(std::forward<Value>(other)) {
}
template <
typename Value,
typename = std::enable_if_t<
!std::is_same_v<std::decay_t<Value>, unique_any>
&& !std::is_copy_constructible_v<std::decay_t<Value>>
&& std::is_move_constructible_v<std::decay_t<Value>>
&& !std::is_lvalue_reference_v<Value>>>
unique_any(Value &&other, std::false_type)
: _impl(details::wrap_moveable_as_copyable(std::move(other))) {
}
template <
typename Value,
typename ...Args>
friend unique_any make_any(Args &&...args);
template <typename Value>
friend const Value *any_cast(const unique_any *value) noexcept;
template <typename Value>
friend Value *any_cast(unique_any *value) noexcept;
std::any _impl;
};
inline void swap(unique_any &a, unique_any &b) noexcept {
a.swap(b);
}
template <
typename Value,
typename ...Args>
inline auto make_any(Args &&...args)
-> std::enable_if_t<
std::is_copy_constructible_v<std::decay_t<Value>>,
unique_any> {
return std::make_any<Value>(std::forward<Args>(args)...);
}
template <
typename Value,
typename ...Args>
inline auto make_any(Args &&...args)
-> std::enable_if_t<
!std::is_copy_constructible_v<std::decay_t<Value>>
&& std::is_move_constructible_v<std::decay_t<Value>>,
unique_any> {
return Value(std::forward<Args>(args)...);
}
template <typename Value>
inline Value *any_cast(unique_any *value) noexcept {
if constexpr (std::is_copy_constructible_v<Value>) {
return std::any_cast<Value>(&value->_impl);
} else if constexpr (std::is_move_constructible_v<Value>) {
auto wrap = std::any_cast<
details::moveable_as_copyable_wrap<Value>
>(&value->_impl);
return wrap ? &wrap->value : nullptr;
} else {
static_assert(
false_t(Value{}),
"Bad type for base::any_cast.");
}
}
template <typename Value>
inline const Value *any_cast(const unique_any *value) noexcept {
if constexpr (std::is_copy_constructible_v<Value>) {
return std::any_cast<Value>(&value->_impl);
} else if constexpr (std::is_move_constructible_v<Value>) {
auto wrap = std::any_cast<
details::moveable_as_copyable_wrap<Value>
>(&value->_impl);
return wrap ? &wrap->value : nullptr;
} else {
static_assert(
false_t(Value{}),
"Bad type for base::any_cast.");
}
}
} // namespace base