28 #ifndef YB_INC_ystdex_any_h_
29 #define YB_INC_ystdex_any_h_ 1
61 template<typename _tPOD = typename aligned_storage<sizeof(void*)>::type>
64 static_assert(is_pod<_tPOD>::value,
"Non-POD underlying type found.");
74 template<
typename _type>
81 template<
typename _type>
85 access<typename remove_reference<_type>::type>() =
yforward(x);
100 template<
typename _type>
104 return *
static_cast<_type*
>(
access());
106 template<
typename _type>
110 return *
static_cast<const _type*
>(
access());
127 template<
typename _type>
133 template<
typename _type>
136 return *
static_cast<_type*
>(&*
this);
142 return const_cast<void*
>(
ptr);
176 virtual const std::type_info&
186 template<typename _type>
189 static_assert(is_object<_type>::value,
"Non-object type found.");
190 static_assert(!(is_const<_type>::value || is_volatile<_type>::value),
191 "Cv-qualified type found.");
211 : held(std::move(value))
224 return std::addressof(held);
228 const std::type_info&
231 return typeid(_type);
242 template<
typename _type>
245 static_assert(std::is_object<_type>::value,
"Invalid type found.");
277 clone()
const override
290 const std::type_info&
293 return p_held ?
typeid(_type) :
typeid(
void);
333 template<
typename _type,
bool bStoredLocally =
sizeof(_type)
341 typedef _type value_type;
342 typedef integral_constant<bool, bStoredLocally> local_storage;
347 return const_cast<value_type*
>(bStoredLocally ? std::addressof(
348 s.access<value_type>()) : s.access<const value_type*>());
358 return *get_pointer(s);
365 new(d.access()) value_type(s.access<value_type>());
371 d =
new value_type(*s.access<value_type*>());
379 d.access<value_type>().~value_type();
384 delete d.access<value_type*>();
387 template<
typename _tValue>
391 init_impl(d,
yforward(x), local_storage());
398 template<
typename _tValue>
402 new(d.access()) value_type(
yforward(x));
404 template<
typename _tValue>
420 d = &
typeid(value_type);
426 copy(d, s, local_storage());
429 uninit(d, local_storage());
435 d =
static_cast<holder*
>(
nullptr);
445 template<
typename _type>
446 class ref_handler :
public value_handler<_type*>
449 typedef _type value_type;
450 typedef value_handler<value_type*> base;
456 return base::get_reference(s);
465 return *get_pointer(s);
469 init(
any_storage& d, std::reference_wrapper<value_type> x)
471 base::init(d, std::addressof(x.get()));
480 d = &
typeid(value_type);
486 base::manage(d, s, op);
496 template<
typename _tHolder>
497 class holder_handler :
public value_handler<_tHolder>
499 static_assert(is_convertible<_tHolder&, holder&>::value,
500 "Invalid holder type found.");
503 typedef typename _tHolder::value_type value_type;
504 typedef value_handler<_tHolder> base;
505 typedef typename base::local_storage local_storage;
510 return static_cast<value_type*
>(base::get_pointer(s)->_tHolder::get());
516 init(
any_storage& d, std::unique_ptr<_tHolder> p, true_type)
518 new(d.access()) _tHolder(std::move(*p));
522 init(
any_storage& d, std::unique_ptr<_tHolder> p, false_type)
532 init(d, std::move(p), local_storage());
537 base::init(d, std::move(x));
539 template<
typename... _tParams>
543 init(d, _tHolder(
yforward(args)...));
552 d = &
typeid(value_type);
558 base::copy(d, s, local_storage());
561 base::uninit(d, local_storage());
564 d = &
typeid(_tHolder);
567 d =
static_cast<holder*
>(base::get_pointer(s));
597 : storage(), manager()
601 template<
typename _type,
typename =
typename
602 std::enable_if<!is_same<_type&, any&>::value,
int>::type>
604 : manager(any_ops::value_handler<typename
605 remove_reference<_type>::type>::manage)
607 any_ops::value_handler<typename remove_rcv<_type>::type>::init(storage,
610 template<
typename _type>
611 any(std::reference_wrapper<_type> x)
612 : manager(any_ops::ref_handler<_type>::manage)
614 any_ops::ref_handler<_type>::init(storage, x);
620 template<
typename _tHolder>
621 any(any_ops::holder_tag, std::unique_ptr<_tHolder> p)
622 : manager(any_ops::holder_handler<_tHolder>::manage)
624 any_ops::holder_handler<_tHolder>::init(storage, std::move(p));
626 template<
typename _type>
628 : manager(any_ops::holder_handler<any_ops::value_holder<typename
632 remove_cv<_type>::type>>::init(storage,
yforward(x));
644 template<
typename _type>
646 operator=(
const _type& x)
656 operator=(
const any& a)
668 any(std::move(a)).swap(*
this);
673 operator!() const ynothrow
679 operator bool() const ynothrow
685 empty() const ynothrow
692 get()
const ynothrow;
701 swap(any& a) ynothrow;
705 template<typename _type>
709 return type() ==
typeid(_type) ? static_cast<_type*>(
get()) :
nullptr;
711 template<
typename _type>
713 target() const ynothrow
715 return type() ==
typeid(_type)
716 ? static_cast<const _type*>(
get()) :
nullptr;
721 const std::type_info&
722 type() const ynothrow;
736 const char* from_name;
745 from_name(
"unknown"), to_name(
"unknown")
747 bad_any_cast(
const std::type_info& from_type,
const std::type_info& to_type)
749 from_name(from_type.name()), to_name(to_type.name())
753 from() const ynothrow
766 what() const ynothrow
override
768 return "Failed conversion: any_cast.";
785 template<
typename _tPo
inter>
789 return p ? p->target<
typename remove_pointer<_tPointer>::type>() :
nullptr;
791 template<
typename _tPo
inter>
795 return p ? p->target<
typename remove_pointer<_tPointer>::type>() :
nullptr;
803 template<
typename _tValue>
807 const auto tmp(
any_cast<
typename remove_reference<_tValue>::type*>(&x));
810 throw bad_any_cast(x.type(),
typeid(_tValue));
811 return static_cast<_tValue
>(*tmp);
813 template<
typename _tValue>
817 const auto tmp(
any_cast<
typename remove_reference<_tValue>::type*>(&x));
820 throw bad_any_cast(x.type(),
typeid(_tValue));
821 return static_cast<_tValue
>(*tmp);
833 template<
typename _type>
839 return static_cast<_type*
>(p->get());
842 template<
typename _type>
848 return static_cast<const _type*
>(p->get());
860 template<
typename... _tParams>
861 inline pseudo_output&
862 operator=(_tParams&&...)