Why is there no “option” in boost or Standard?

Question

One of the advantages of any over variant is that you do not need to specify all types that may contain. I noticed that as the number of a variant types can increase, people tend to switch to any at some point, because they simply no longer track all types. I think a hybrid between any and variant is possible. It was possible to save the " placeholder " (by placing new ) any in aligned_storage , with the size calculated in the constexpr function or template metaphone, from a sample of the largest types that might end up being stored. On the other hand, the user will not need to specify all types that any may contain. any can also be started at any time if the user tries to save something more than aligned_storage .

Is there such a class " variant_any "? Is there any inherent problem with the idea?

Answer 1

Here is the basic some .

T copy / assign / move / etc can be implemented in terms of emplace . SFINAE using can_store<T> can ensure that only some types can actually be stored, assigned to it, avoiding unnecessary exceptions.

Currently, moving from some destroys its contents, rather than just moving away from it. And some may be empty (they are "nulllable").

load_from is a constructor of "can-fail" copies from another some - it returns false on failure. I could add 'can not-fail' from the smaller some (even the copy / assign statement) to complete it.

some_meta is a manual table of virtual functions. One exists for type T , which you store in some any size. It stores the erase operations of a type of type T , which wants to use some (in this case, copy the move and destroy), as well as some data about the type (size, alignment, and type identifier). This can be complemented by additional operations such as comparison and serialization. For binary operations, the "inappropriate type" processing logic must be considered. For things like serialization, I would call it the free serialize and deserialize on T In both cases, we impose additional requirements on what some can store (you can deal with “serialization” with a little work, but it becomes messy).

You can even imagine a system in which you can store a set of operations for executing data (binary and unary) and transfer the specified operations associated with types passed to some. At the moment, we are approaching the boost erase library.

 namespace details { template<std::size_t Size, std::size_t Align=0> struct storage_helper { using type = std::aligned_storage_t<Size, Align>; enum { alignment = alignof(type), size = Size }; }; template<std::size_t Size> struct storage_helper<Size, 0> { using type = std::aligned_storage_t<Size>; enum { alignment = alignof(type), size = Size }; }; template<std::size_t size, std::size_t align> using storage_helper_t = typename storage_helper<size,align>::type; template<class T>using type=T; struct some_meta { type<void(void*)>* destroy; type<void(void* dest, void const* src)>* copy; type<void(void* dest, void* src)>* move; std::type_index type; size_t size; size_t align; template<class T> static some_meta const* get() { static const some_meta retval( create<T>() ); return &retval; }; private: template<class T> static some_meta create() { return { [](void* p){ ((T*)p)->~T(); }, [](void* out, void const* in){ new(out)T(*(T*)in); }, [](void* dest, void* src) { new(dest)T(std::move(*(T*)src)); }, typeid(T), sizeof(T), alignof(T) }; } }; } template<class>struct emplace_as{}; template< std::size_t size, std::size_t Align=0 > struct some { enum { align = details::storage_helper<size, Align>::alignment }; using data_type = details::storage_helper_t<size, Align>; template<size_t, size_t> friend struct some; template<class T> struct can_store : std::integral_constant< bool, ((align%alignof(T))==0) && sizeof(T) <= size) > {}; template<size_t x, size_t a> static bool can_fit( some<x,a> const& o ) { if (x<=size && ((align%some<x,a>::align)==0)) return true; // should cause optimizations if (!o.meta) return true; if (o.meta->size > size) return false; if (o.meta->align > align) return false; return true; } private: data_type data; details::some_meta const* meta = nullptr; public: // true iif we are (exactly) a T template<class T> bool is() const { return meta && (meta->type == typeid(T)); } explicit operator bool()const { return meta!=nullptr; } template<class T> T* unsafe_get() { return reinterpret_cast<T*>(&data); } template<class T> T* get() { if (is<T>()) return unsafe_get<T>(); else return nullptr; } void clear() { if (meta) meta->destroy(&data); meta = nullptr; } template<class T, class... Args> std::enable_if_t< can_store<T>{} > emplace(Args&&...args) { clear(); new(&data) T(std::forward<Args>(args)...); meta = details::some_meta::get<T>(); } some()=default; some(some const& o) { *this = o; } some(some const&&o):some(o){} some(some&o):some(const_cast<some const&>(o)){} some(some&& o) { *this = std::move(o); } some& operator=(some const&o) { if (this == &o) return *this; clear(); if (o.meta) { o.meta->copy( &data, &o.data ); meta=o.meta; } return *this; } some& operator=(some &&o) { if (this == &o) return *this; clear(); if (o.meta) { o.meta->move( &data, &o.data ); meta=o.meta; o.clear(); } return *this; } some& operator=(some const&&o) { return *this=o; } some& operator=(some &o) { return *this=const_cast<some const&>(o); } // from non-some: template<class T,class=std::enable_if_t<can_store<std::decay_t<T>>{}>> some(T&& t){ emplace<std::decay_t<T>>(std::forward<T>(t)); } template<class T, class...Args,class=std::enable_if_t<can_store<T>{}>> some( emplace_as<T>, Args&&...args ){ emplace<T>(std::forward<Args>(args)...); } template<class T,class=std::enable_if_t<can_store<std::decay_t<T>>{}>> some& operator=(T&&t){ emplace<std::decay_t<T>>(std::forward<T>(t)); return *this; } template<size_t x, size_t a> bool load_from( some<x,a> const& o ) { if ((void*)&o==this) return true; if (!can_fit(o)) return false; clear(); if (o.meta) { o.meta->copy( &data, &o.data ); meta=o.meta; } return true; } template<size_t x, size_t a> bool load_from( some<x,a> && o ) { if ((void*)&o==this) return true; if (!can_fit(o)) return false; clear(); if (o.meta) { o.meta->move( &data, &o.data ); meta=o.meta; o.clear(); } return true; } ~some() { clear(); } }; template<class T, class...Ts> using some_that_fits = some< (std::max)({sizeof(T),sizeof(Ts)...}), (std::max)({alignof(T),alignof(Ts)...}) >; 

the meta object is a virtual function table implemented manually. This reduces the memory overhead for a given one by one pointer (above the storage buffer).

living example

As shown above, this is quite viable.

Note that create returns a pointer to the same meta for the same type T , even if called more than once.

I used half the codes in my test above. Others probably have errors.

some_that_fits lets you pass a set of types and returns the type some , which is suitable for these types.

No exceptions generated by operations with saved types by specified stored types are thrown. Whenever possible, I test at compile time to ensure type matching.

Could I add support for greater alignment, small types of repositories, running them with an offset in my data?